Update Arrow "cancel" wording for consistency

arrow-benchmarks-fx/src/jmh/kotlin/arrow/benchmarks/Cancellable.kt

@@ -24,17 +24,17 @@ open class Cancellable {
  @Param("100")
  var size: Int = 0
 
- fun evalCancelable(n: Int): IO<Int> =
- IO.concurrent().cancelable<Int> { cb ->
+ fun evalCancellable(n: Int): IO<Int> =
+ IO.concurrent().cancellable<Int> { cb ->
  cb(Right(n))
  IO.unit
  }.fix()
 
- fun cancelableLoop(i: Int): IO<Int> =
- if (i < size) evalCancelable(i + 1).flatMap { cancelableLoop(it) }
- else evalCancelable(i)
+ fun cancellableLoop(i: Int): IO<Int> =
+ if (i < size) evalCancellable(i + 1).flatMap { cancellableLoop(it) }
+ else evalCancellable(i)
 
  @Benchmark
  fun io(): Int =
- cancelableLoop(0).unsafeRunSync()
+ cancellableLoop(0).unsafeRunSync()
 }

arrow-benchmarks-fx/src/jmh/kotlin/arrow/benchmarks/Queue.kt

@@ -9,7 +9,7 @@ import arrow.fx.extensions.io.concurrent.concurrent
 import arrow.fx.extensions.io.functor.unit
 import arrow.fx.extensions.io.monad.flatMap
 import arrow.fx.fix
-import arrow.fx.internal.CancelableQueue
+import arrow.fx.internal.CancellableQueue
 import org.openjdk.jmh.annotations.Benchmark
 import org.openjdk.jmh.annotations.CompilerControl
 import org.openjdk.jmh.annotations.Fork
@@ -39,7 +39,7 @@ open class Queue {
  @Setup(Level.Trial)
  fun createQueues(): Unit {
  ConcurQueue = ConcurrentQueue.empty<ForIO, Int>(IO.concurrent()).fix().unsafeRunSync()
- CancelQueue = CancelableQueue.empty<ForIO, Int>(IO.concurrent()).fix().unsafeRunSync()
+ CancelQueue = CancellableQueue.empty<ForIO, Int>(IO.concurrent()).fix().unsafeRunSync()
  }
 
  fun <A> IOOf<A>.repeat(n: Int): IO<A> =
@@ -54,5 +54,5 @@ open class Queue {
  fun concurrentQueue(): Unit = loop(ConcurQueue)
 
  @Benchmark
- fun cancelableQueue(): Unit = loop(CancelQueue)
+ fun cancellableQueue(): Unit = loop(CancelQueue)
 }

arrow-benchmarks-fx/src/jmh/kotlin/arrow/benchmarks/Uncancellable.kt

@@ -21,10 +21,10 @@ open class Uncancellable {
  @Param("100")
  var size: Int = 0
 
- fun ioUncancelableLoop(i: Int): IO<Int> =
- if (i < size) IO { i + 1 }.uncancelable().flatMap { ioUncancelableLoop(it) }
+ fun ioUncancellableLoop(i: Int): IO<Int> =
+ if (i < size) IO { i + 1 }.uncancellable().flatMap { ioUncancellableLoop(it) }
  else IO.just(i)
 
  @Benchmark
- fun io(): Int = ioUncancelableLoop(0).unsafeRunSync()
+ fun io(): Int = ioUncancellableLoop(0).unsafeRunSync()
 }

arrow-docs/docs/fiber/README.md

@@ -8,11 +8,11 @@ permalink: /effects/fiber/
 
 
 A `Fiber` is a concurrency primitive for describing parallel operations or multi-tasking.
-Concurrently started tasks can either be joined or canceled, and these are the only two operators available on `Fiber`.
+Concurrently started tasks can either be joined or cancelled, and these are the only two operators available on `Fiber`.
 
 Using `Fiber`, we can describe parallel operations such as `parallelMap` relatively easily.
 **Note** the operation written below does not support proper cancellation.
-When the resulting `IO` is canceled, it does not propagate this cancellation back to the underlying `IO`.
+When the resulting `IO` is cancelled, it does not propagate this cancellation back to the underlying `IO`.
 
 ```kotlin:ank
 import arrow.fx.*

arrow-docs/docs/fx/typeclasses/bracket/README.md

@@ -253,7 +253,7 @@ println(safeComputation)
 #### bracketCase
 
 It's a generalized version of `bracket()` that uses `ExitCase` to distinguish between different exit cases when
-releasing the acquired resource. `ExitCase` can take the values `Completed`, `Canceled`, or `Error(e)`. So, depending
+releasing the acquired resource. `ExitCase` can take the values `Completed`, `Cancelled`, or `Error(e)`. So, depending
 how the `use` execution finalizes, the corresponding `ExitCase` value will be passed to the `release` lambda.
 
 It requires passing `release` and `use` lambdas. It ensures acquiring, using, and releasing the resource at the end.
@@ -282,7 +282,7 @@ val safeComputation = openFile("data.json").bracketCase(
  release = { file, exitCase ->
  when (exitCase) {
  is ExitCase.Completed -> { /* do something */ }
- is ExitCase.Canceled -> { /* do something */ }
+ is ExitCase.Cancelled -> { /* do something */ }
  is ExitCase.Error -> { /* do something */ }
  }
  closeFile(file)
@@ -297,7 +297,7 @@ println(safeComputation)
 
 #### guarantee/guaranteeCase - onCancel/onError
 
-Ignores the acquisition and focuses on using a resource and performing an action whenever it finishes in any way (completed, error, canceled).
+Ignores the acquisition and focuses on using a resource and performing an action whenever it finishes in any way (completed, error, cancelled).
 
 Similarly as for `bracketCase`, `guaranteeCase` works in the same way as `guarantee` but uses `ExitCase` to distinguish between different exit cases when
 releasing the acquired resource.

arrow-docs/docs/integrations/kotlinxcoroutines/README.md

@@ -32,7 +32,7 @@ If you'd like to introduce `IO` in your project, you might want to keep using th
 
 ### unsafeRunScoped & unsafeRunIO
 
-`IO.unsafeRunScoped(scope, cb)` runs the specific `IO` with a [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html), so it will be automatically canceled when the scope does as well.
+`IO.unsafeRunScoped(scope, cb)` runs the specific `IO` with a [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html), so it will be automatically cancelled when the scope does as well.
 
 Similarly, there's `scope.unsafeRunIO(IO, cb)`, which works in the same way with different syntax:
 

arrow-docs/docs/promise/README.md

@@ -14,7 +14,7 @@ A `Promise` guarantees (promises) `A` at some point in the future within the con
 
 ## Constructing a Promise
 
-A promise can easily be made by calling `uncancelable`.
+A promise can easily be made by calling `uncancellable`.
 Since the allocation of mutable state is not referentially transparent, this side-effect is contained within `F`.
 
 ```kotlin:ank:playground
@@ -24,21 +24,21 @@ import arrow.fx.extensions.io.async.async
 fun main(args: Array<String>) {
 //sampleStart
 val promise: IO<Promise<ForIO, Int>> =
- Promise.uncancelable<ForIO, Int>(IO.async()).fix()
+ Promise.uncancellable<ForIO, Int>(IO.async()).fix()
 //sampleEnd
 println(promise)
 }
 ```
 
-In case you want the side-effect to execute immediately and return the `Promise` instance, you can use the `unsafeUncancelable` function.
+In case you want the side-effect to execute immediately and return the `Promise` instance, you can use the `unsafeUncancellable` function.
 
 ```kotlin:ank:playground
 import arrow.fx.*
 import arrow.fx.extensions.io.async.async
 
 fun main(args: Array<String>) {
 //sampleStart
-val unsafePromise: Promise<ForIO, Int> = Promise.unsafeUncancelable(IO.async())
+val unsafePromise: Promise<ForIO, Int> = Promise.unsafeUncancellable(IO.async())
 //sampleEnd
 println(unsafePromise)
 }
@@ -55,7 +55,7 @@ import arrow.fx.extensions.io.monad.flatMap
 
 fun main(args: Array<String>) {
 //sampleStart
-Promise.uncancelable<ForIO, Int>(IO.async()).flatMap { p ->
+Promise.uncancellable<ForIO, Int>(IO.async()).flatMap { p ->
  p.get()
 } //never ends because `get` keeps waiting for p to be fulfilled.
 //sampleEnd
@@ -69,7 +69,7 @@ import arrow.fx.extensions.io.monad.flatMap
 
 fun main(args: Array<String>) {
 //sampleStart
-val result = Promise.uncancelable<ForIO, Int>(IO.async()).flatMap { p ->
+val result = Promise.uncancellable<ForIO, Int>(IO.async()).flatMap { p ->
  p.complete(1).flatMap {
  p.get()
  }
@@ -90,7 +90,7 @@ import arrow.fx.extensions.io.monad.flatMap
 
 fun main(args: Array<String>) {
 //sampleStart
-val result = Promise.uncancelable<ForIO, Int>(IO.async()).flatMap { p ->
+val result = Promise.uncancellable<ForIO, Int>(IO.async()).flatMap { p ->
  p.complete(2).flatMap {
  p.get()
  }
@@ -107,7 +107,7 @@ import arrow.fx.extensions.io.monad.flatMap
 
 fun main(args: Array<String>) {
 //sampleStart
-val result = Promise.uncancelable<ForIO, Int>(IO.async()).flatMap { p ->
+val result = Promise.uncancellable<ForIO, Int>(IO.async()).flatMap { p ->
  p.complete(1).flatMap {
  p.complete(2)
  }
@@ -130,7 +130,7 @@ import arrow.fx.extensions.io.monad.flatMap
 
 fun main(args: Array<String>) {
 //sampleStart
-val result = Promise.uncancelable<ForIO, Int>(IO.async()).flatMap { p ->
+val result = Promise.uncancellable<ForIO, Int>(IO.async()).flatMap { p ->
  p.error(RuntimeException("Break promise"))
 }
  .attempt()
@@ -147,7 +147,7 @@ import arrow.fx.extensions.io.monad.flatMap
 
 fun main(args: Array<String>) {
 //sampleStart
-val result = Promise.uncancelable<ForIO, Int>(IO.async()).flatMap { p ->
+val result = Promise.uncancellable<ForIO, Int>(IO.async()).flatMap { p ->
  p.complete(1).flatMap {
  p.error(RuntimeException("Break promise"))
  }

arrow-fx-kotlinx-coroutines/src/test/kotlin/arrow/integrations/kotlinx/CoroutinesIntegrationTest.kt

@@ -90,7 +90,7 @@ class CoroutinesIntegrationTest : UnitSpec() {
  val promise = !Promise<Int>()
  !effect {
  scope.launch {
- IO.cancelable<Unit> { promise.complete(i) }.suspendCancellable()
+ IO.cancellable<Unit> { promise.complete(i) }.suspendCancellable()
  }
  }
  !effect { scope.cancel() }
@@ -135,7 +135,7 @@ class CoroutinesIntegrationTest : UnitSpec() {
  val scope = TestCoroutineScope(Job() + TestCoroutineDispatcher())
  val promise = !Promise<Int>()
  !effect {
- IO.cancelable<Unit> { promise.complete(i) }.unsafeRunScoped(scope) { }
+ IO.cancellable<Unit> { promise.complete(i) }.unsafeRunScoped(scope) { }
  }
  !effect { scope.cancel() }
  !promise.get()

arrow-fx-reactor/src/main/kotlin/arrow/fx/reactor/FluxK.kt

@@ -79,7 +79,7 @@ data class FluxK<out A>(val flux: Flux<out A>) : FluxKOf<A> {
  * release = { file, exitCase ->
  * when (exitCase) {
  * is ExitCase.Completed -> { /* do something */ }
- * is ExitCase.Canceled -> { /* do something */ }
+ * is ExitCase.Cancelled -> { /* do something */ }
  * is ExitCase.Error -> { /* do something */ }
  * }
  * closeFile(file)
@@ -94,13 +94,13 @@ data class FluxK<out A>(val flux: Flux<out A>) : FluxKOf<A> {
  fun <B> bracketCase(use: (A) -> FluxKOf<B>, release: (A, ExitCase<Throwable>) -> FluxKOf<Unit>): FluxK<B> =
  FluxK(Flux.create<B> { sink ->
  flux.subscribe({ a ->
- if (sink.isCancelled) release(a, ExitCase.Canceled).fix().flux.subscribe({}, sink::error)
+ if (sink.isCancelled) release(a, ExitCase.Cancelled).fix().flux.subscribe({}, sink::error)
  else try {
  sink.onDispose(use(a).fix()
  .flatMap { b -> release(a, ExitCase.Completed).fix().map { b } }
  .handleErrorWith { e -> release(a, ExitCase.Error(e)).fix().flatMap { FluxK.raiseError<B>(e) } }
  .flux
- .doOnCancel { release(a, ExitCase.Canceled).fix().flux.subscribe({}, sink::error) }
+ .doOnCancel { release(a, ExitCase.Cancelled).fix().flux.subscribe({}, sink::error) }
  .subscribe({ sink.next(it) }, sink::error, { }, {
  sink.onRequest(it::request)
  })
@@ -208,8 +208,8 @@ data class FluxK<out A>(val flux: Flux<out A>) : FluxKOf<A> {
  * ```
  */
  @Deprecated(message =
- "For wrapping cancelable operations you should use cancelable instead.\n" +
- "For wrapping uncancelable operations you can use the non-deprecated async")
+ "For wrapping cancellable operations you should use cancellable instead.\n" +
+ "For wrapping uncancellable operations you can use the non-deprecated async")
  fun <A> async(fa: FluxKProc<A>): FluxK<A> =
  Flux.create<A> { sink ->
  val conn = FluxKConnection()
@@ -241,8 +241,8 @@ data class FluxK<out A>(val flux: Flux<out A>) : FluxKOf<A> {
  }.k()
 
  @Deprecated(message =
- "For wrapping cancelable operations you should use cancelableF instead.\n" +
- "For wrapping uncancelable operations you can use the non-deprecated asyncF")
+ "For wrapping cancellable operations you should use cancellableF instead.\n" +
+ "For wrapping uncancellable operations you can use the non-deprecated asyncF")
  fun <A> asyncF(fa: FluxKProcF<A>): FluxK<A> =
  Flux.create { sink: FluxSink<A> ->
  val conn = FluxKConnection()
@@ -273,7 +273,11 @@ data class FluxK<out A>(val flux: Flux<out A>) : FluxKOf<A> {
  }.fix().flux.subscribe({}, sink::error)
  }.k()
 
+ @Deprecated("Renaming this api for consistency", ReplaceWith("cancellable(fa)"))
  fun <A> cancelable(fa: ((Either<Throwable, A>) -> Unit) -> CancelToken<ForFluxK>): FluxK<A> =
+ cancellable(fa)
+
+ fun <A> cancellable(fa: ((Either<Throwable, A>) -> Unit) -> CancelToken<ForFluxK>): FluxK<A> =
  Flux.create<A> { sink ->
  val token = fa { either: Either<Throwable, A> ->
  either.fold({ e ->
@@ -286,7 +290,11 @@ data class FluxK<out A>(val flux: Flux<out A>) : FluxKOf<A> {
  sink.onDispose { token.value().subscribe({}, sink::error) }
  }.k()
 
+ @Deprecated("Renaming this api for consistency", ReplaceWith("cancellableF(fa)"))
  fun <A> cancelableF(fa: ((Either<Throwable, A>) -> Unit) -> FluxKOf<CancelToken<ForFluxK>>): FluxK<A> =
+ cancellableF(fa)
+
+ fun <A> cancellableF(fa: ((Either<Throwable, A>) -> Unit) -> FluxKOf<CancelToken<ForFluxK>>): FluxK<A> =
  Flux.create<A> { sink ->
  val cb = { either: Either<Throwable, A> ->
  either.fold({ e ->

arrow-fx-reactor/src/main/kotlin/arrow/fx/reactor/FluxKConnection.kt

@@ -5,9 +5,9 @@ import arrow.fx.KindConnection
 import arrow.fx.typeclasses.ExitCase
 import arrow.fx.typeclasses.MonadDefer
 
-@Deprecated("Cancellation should be done with the cancelable combinator")
+@Deprecated("Cancellation should be done with the cancellable combinator")
 typealias FluxKProc<A> = (KindConnection<ForFluxK>, (Either<Throwable, A>) -> Unit) -> Unit
-@Deprecated("Cancellation should be done with the cancelable combinator")
+@Deprecated("Cancellation should be done with the cancellable combinator")
 typealias FluxKProcF<A> = (KindConnection<ForFluxK>, (Either<Throwable, A>) -> Unit) -> FluxKOf<Unit>
 
 /**
@@ -22,7 +22,7 @@ typealias FluxKProcF<A> = (KindConnection<ForFluxK>, (Either<Throwable, A>) -> U
  */
 @Suppress("UNUSED_PARAMETER", "FunctionName")
 @Deprecated(message = "Cancelling operations through FluxKConnection will not be supported anymore." +
- "In case you need to cancel multiple processes can do so by using cancelable and composing cancel operations using zipWith or other parallel operators")
+ "In case you need to cancel multiple processes can do so by using cancellable and composing cancel operations using zipWith or other parallel operators")
 fun FluxKConnection(dummy: Unit = Unit): KindConnection<ForFluxK> = KindConnection(object : MonadDefer<ForFluxK> {
  override fun <A> defer(fa: () -> FluxKOf<A>): FluxK<A> =
  FluxK.defer(fa)