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)