Complete Async

modules/core/arrow-annotations-processor/src/main/java/arrow/common/utils/AbstractProcessor.kt

@@ -3,6 +3,8 @@ package arrow.common.utils
 import arrow.common.messager.logE
 import arrow.documented
 import arrow.meta.encoder.jvm.KotlinMetatadataEncoder
+import me.eugeniomarletti.kotlin.metadata.kotlinMetadata
+import me.eugeniomarletti.kotlin.metadata.shadow.metadata.deserialization.receiverType
 import me.eugeniomarletti.kotlin.processing.KotlinAbstractProcessor
 import java.io.File
 import java.io.IOException
@@ -58,8 +60,14 @@ abstract class AbstractProcessor : KotlinAbstractProcessor(), ProcessorUtils, Ko
       ElementKind.INTERFACE -> (this as TypeElement).qualifiedName.toString()
       ElementKind.METHOD -> (this as ExecutableElement).let {
         val name = (it.enclosingElement as TypeElement).qualifiedName.toString()
+
+        val extensionName = (it.enclosingElement.kotlinMetadata?.asClassOrPackageDataWrapper(it.enclosingElement as TypeElement) as? ClassOrPackageDataWrapper.Class)?.let { classData ->
+          val n = classData.getFunction(it).toMeta(classData, it).receiverType?.simpleName
+          if (n == classData.simpleName) "" else "$n-"
+        } ?: ""
+
         val functionName = it.simpleName.toString()
-        "$name.$functionName"
+        "$name.$extensionName$functionName"
       }
       else -> knownError("Unsupported @documented $kind")
     }

modules/core/arrow-annotations-processor/src/main/java/arrow/instances/PolyTemplateGenerator.kt

@@ -110,7 +110,7 @@ interface PolyTemplateGenerator : MetaApi {
   private fun String.replaceMonadDeferImports(info: TypeClassInstance): String {
     val monadDeferPackageName = PackageName(info.instance.packageName.value +
       "." + info.projectedCompanion.simpleName.substringAfterLast(".").toLowerCase() +
-      ".monaddefer")
+      ".monadDefer")
     return replace(
       "_imports_monaddefer_",
       """
@@ -133,8 +133,7 @@ interface PolyTemplateGenerator : MetaApi {
              |import ${packageName.value.quote()}.*
              |import arrow.core.*
              |$factoryImports
-             |$additionalImports
-             |""".trimMargin()
+             |$additionalImports""".trimMargin()
     )
   }
 
@@ -152,8 +151,7 @@ interface PolyTemplateGenerator : MetaApi {
         val factory = it.returnType?.simpleName?.decapitalize()?.substringBefore("<") ?: ""
         val fact = if (factory == "functor") "monad" else factory
         """|import arrow.instances.id.$fact.$fact
-              |import arrow.core.*
-            """.trimMargin()
+           |import arrow.core.*""".trimMargin()
       }
     }
 

modules/core/arrow-core/src/test/kotlin/arrow/core/IdTest.kt

@@ -1,13 +1,13 @@
 package arrow.core
 
-import arrow.core.Id
 import arrow.instances.eq
 import arrow.instances.hash
 import arrow.instances.id.applicative.applicative
 import arrow.instances.id.comonad.comonad
 import arrow.instances.id.eq.eq
 import arrow.instances.id.hash.hash
 import arrow.instances.id.monad.monad
+import arrow.instances.id.monoid.monoid
 import arrow.instances.id.show.show
 import arrow.instances.id.traverse.traverse
 import arrow.instances.id.semigroup.semigroup

modules/core/arrow-data/src/main/kotlin/arrow/data/StateT.kt

@@ -201,7 +201,7 @@ class StateT<F, S, A>(
    * @param ff function with the [StateT] context.
    */
   fun <B> ap(MF: Monad<F>, ff: StateTOf<F, S, (A) -> B>): StateT<F, S, B> =
-    ff.fix().map2(MF, this) { f, a -> f(a) }
+    ff.fix().map2(MF, this) { f: (A) -> B, a: A -> f(a) }
 
   /**
    * Create a product of the value types of [StateT].

modules/core/arrow-data/src/test/kotlin/arrow/data/KleisliTest.kt

@@ -46,7 +46,7 @@ class KleisliTest : UnitSpec() {
 
     testLaws(
       BracketLaws.laws(
-        BF = Kleisli.bracket<ForIO, Int, Throwable>(IO.bracket()),
+        Kleisli.bracket<ForIO, Int, Throwable>(IO.bracket()),
         EQ = IOEQ(),
         EQ_EITHER = IOEitherEQ(),
         EQERR = IOEQ()

modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/id.kt

@@ -39,18 +39,41 @@ interface IdShowInstance<A> : Show<Id<A>> {
     toString()
 }
 
+@extension
+interface IdSemigroupInstance<A> : Semigroup<Id<A>> {
+
+  fun SA(): Semigroup<A>
+
+  override fun Id<A>.combine(b: Id<A>): Id<A> = SA().run {
+    Id(value().combine(b.value()))
+  }
+
+}
+
+@extension
+interface IdMonoidInstance<A> : Monoid<Id<A>>, IdSemigroupInstance<A> {
+
+  fun MA(): Monoid<A>
+
+  override fun SA() = MA()
+
+  override fun empty(): Id<A> =
+    Id(MA().empty())
+
+}
+
 @extension
 interface IdFunctorInstance : Functor<ForId> {
-  override fun <A, B> Kind<ForId, A>.map(f: (A) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.map(f: (A) -> B): Id<B> =
     fix().map(f)
 }
 
 @extension
 interface IdApplicativeInstance : Applicative<ForId> {
-  override fun <A, B> Kind<ForId, A>.ap(ff: Kind<ForId, (A) -> B>): Id<B> =
+  override fun <A, B> IdOf<A>.ap(ff: IdOf<(A) -> B>): Id<B> =
     fix().ap(ff)
 
-  override fun <A, B> Kind<ForId, A>.map(f: (A) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.map(f: (A) -> B): Id<B> =
     fix().map(f)
 
   override fun <A> just(a: A): Id<A> =
@@ -59,16 +82,16 @@ interface IdApplicativeInstance : Applicative<ForId> {
 
 @extension
 interface IdMonadInstance : Monad<ForId> {
-  override fun <A, B> Kind<ForId, A>.ap(ff: Kind<ForId, (A) -> B>): Id<B> =
+  override fun <A, B> IdOf<A>.ap(ff: IdOf<(A) -> B>): Id<B> =
     fix().ap(ff)
 
-  override fun <A, B> Kind<ForId, A>.flatMap(f: (A) -> Kind<ForId, B>): Id<B> =
+  override fun <A, B> IdOf<A>.flatMap(f: (A) -> IdOf<B>): Id<B> =
     fix().flatMap(f)
 
   override fun <A, B> tailRecM(a: A, f: kotlin.Function1<A, IdOf<Either<A, B>>>): Id<B> =
     Id.tailRecM(a, f)
 
-  override fun <A, B> Kind<ForId, A>.map(f: (A) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.map(f: (A) -> B): Id<B> =
     fix().map(f)
 
   override fun <A> just(a: A): Id<A> =
@@ -77,46 +100,46 @@ interface IdMonadInstance : Monad<ForId> {
 
 @extension
 interface IdComonadInstance : Comonad<ForId> {
-  override fun <A, B> Kind<ForId, A>.coflatMap(f: (Kind<ForId, A>) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.coflatMap(f: (IdOf<A>) -> B): Id<B> =
     fix().coflatMap(f)
 
-  override fun <A> Kind<ForId, A>.extract(): A =
+  override fun <A> IdOf<A>.extract(): A =
     fix().extract()
 
-  override fun <A, B> Kind<ForId, A>.map(f: (A) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.map(f: (A) -> B): Id<B> =
     fix().map(f)
 }
 
 @extension
 interface IdBimonadInstance : Bimonad<ForId> {
-  override fun <A, B> Kind<ForId, A>.ap(ff: Kind<ForId, (A) -> B>): Id<B> =
+  override fun <A, B> IdOf<A>.ap(ff: IdOf<(A) -> B>): Id<B> =
     fix().ap(ff)
 
-  override fun <A, B> Kind<ForId, A>.flatMap(f: (A) -> Kind<ForId, B>): Id<B> =
+  override fun <A, B> IdOf<A>.flatMap(f: (A) -> IdOf<B>): Id<B> =
     fix().flatMap(f)
 
   override fun <A, B> tailRecM(a: A, f: kotlin.Function1<A, IdOf<Either<A, B>>>): Id<B> =
     Id.tailRecM(a, f)
 
-  override fun <A, B> Kind<ForId, A>.map(f: (A) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.map(f: (A) -> B): Id<B> =
     fix().map(f)
 
   override fun <A> just(a: A): Id<A> =
     Id.just(a)
 
-  override fun <A, B> Kind<ForId, A>.coflatMap(f: (Kind<ForId, A>) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.coflatMap(f: (IdOf<A>) -> B): Id<B> =
     fix().coflatMap(f)
 
-  override fun <A> Kind<ForId, A>.extract(): A =
+  override fun <A> IdOf<A>.extract(): A =
     fix().extract()
 }
 
 @extension
 interface IdFoldableInstance : Foldable<ForId> {
-  override fun <A, B> Kind<ForId, A>.foldLeft(b: B, f: (B, A) -> B): B =
+  override fun <A, B> IdOf<A>.foldLeft(b: B, f: (B, A) -> B): B =
     fix().foldLeft(b, f)
 
-  override fun <A, B> Kind<ForId, A>.foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B> =
+  override fun <A, B> IdOf<A>.foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B> =
     fix().foldRight(lb, f)
 }
 
@@ -129,13 +152,13 @@ fun <A, G> IdOf<Kind<G, A>>.sequence(GA: Applicative<G>): Kind<G, Id<A>> =
 
 @extension
 interface IdTraverseInstance : Traverse<ForId> {
-  override fun <A, B> Kind<ForId, A>.map(f: (A) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.map(f: (A) -> B): Id<B> =
     fix().map(f)
 
-  override fun <G, A, B> Kind<ForId, A>.traverse(AP: Applicative<G>, f: (A) -> Kind<G, B>): Kind<G, Id<B>> =
+  override fun <G, A, B> IdOf<A>.traverse(AP: Applicative<G>, f: (A) -> Kind<G, B>): Kind<G, Id<B>> =
     idTraverse(AP, f)
 
-  override fun <A, B> Kind<ForId, A>.foldLeft(b: B, f: (B, A) -> B): B =
+  override fun <A, B> IdOf<A>.foldLeft(b: B, f: (B, A) -> B): B =
     fix().foldLeft(b, f)
 
   override fun <A, B> arrow.Kind<arrow.core.ForId, A>.foldRight(lb: arrow.core.Eval<B>, f: (A, arrow.core.Eval<B>) -> arrow.core.Eval<B>): Eval<B> =
@@ -153,7 +176,7 @@ interface IdHashInstance<A> : Hash<Id<A>>, IdEqInstance<A> {
 }
 
 object IdContext : IdBimonadInstance, IdTraverseInstance {
-  override fun <A, B> Kind<ForId, A>.map(f: (A) -> B): Id<B> =
+  override fun <A, B> IdOf<A>.map(f: (A) -> B): Id<B> =
     fix().map(f)
 }
 

modules/core/arrow-instances-data/src/main/kotlin/arrow/instances/kleisli.kt

@@ -95,6 +95,12 @@ interface KleisliMonadErrorInstance<F, D, E> : MonadError<KleisliPartialOf<F, D>
   override fun AE(): ApplicativeError<F, E> = ME()
 
   override fun AF(): Applicative<F> = ME()
+
+}
+
+@extension
+interface KleisliMonadThrow<F, D> : MonadThrow<KleisliPartialOf<F, D>>, KleisliMonadErrorInstance<F, D, Throwable> {
+  override fun ME(): MonadError<F, Throwable>
 }
 
 /**

modules/core/arrow-mtl/src/main/kotlin/arrow/mtl/typeclasses/MonadCombine.kt

@@ -3,7 +3,6 @@ package arrow.mtl.typeclasses
 import arrow.Kind
 import arrow.Kind2
 import arrow.core.Tuple2
-import arrow.instances.statet.applicative.just
 import arrow.typeclasses.Alternative
 import arrow.typeclasses.Bifoldable
 import arrow.typeclasses.Foldable

modules/core/arrow-test/src/main/kotlin/arrow/test/laws/AsyncLaws.kt

@@ -4,12 +4,19 @@ import arrow.Kind
 import arrow.core.Either
 import arrow.core.Left
 import arrow.core.Right
+import arrow.effects.IO
+import arrow.effects.Promise
+import arrow.effects.instances.io.async.defer
+import arrow.effects.instances.io.monadDefer.defer
 import arrow.effects.typeclasses.Async
+import arrow.effects.typeclasses.ExitCase
+import arrow.test.generators.genEither
 import arrow.test.generators.genIntSmall
 import arrow.test.generators.genThrowable
 import arrow.typeclasses.Eq
 import io.kotlintest.properties.Gen
 import io.kotlintest.properties.forAll
+import io.kotlintest.properties.map
 import kotlinx.coroutines.newSingleThreadContext
 
 object AsyncLaws {
@@ -26,7 +33,11 @@ object AsyncLaws {
       Law("Async Laws: error equivalence") { AC.asyncError(EQERR) },
       Law("Async Laws: continueOn jumps threads") { AC.continueOn(EQ) },
       Law("Async Laws: async constructor") { AC.asyncConstructor(EQ) },
-      Law("Async Laws: continueOn on comprehensions") { AC.continueOnComprehension(EQ) }
+      Law("Async Laws: async can be derived from asyncF") { AC.asyncCanBeDerivedFromAsyncF(EQ) },
+      Law("Async Laws: bracket release is called on completed or error") { AC.bracketReleaseIscalledOnCompletedOrError(EQ) },
+      Law("Async Laws: continueOn on comprehensions") { AC.continueOnComprehension(EQ) },
+      Law("Async Laws: async cancelable coherence") { AC.asyncCancelableCoherence(EQ) },
+      Law("Async Laws: cancelable cancelableF coherence") { AC.cancelableCancelableFCoherence(EQ) }
     )
 
   fun <F> Async<F>.asyncSuccess(EQ: Eq<Kind<F, Int>>): Unit =
@@ -68,7 +79,46 @@ object AsyncLaws {
       }.equalUnderTheLaw(just(threadId1 + threadId2), EQ)
     }
 
-  // Turns out that kotlinx.coroutines decides to rewrite thread names
-  private fun getCurrentThread() =
-    Thread.currentThread().name.substringBefore(' ').toInt()
-}
+  fun <F> Async<F>.asyncCanBeDerivedFromAsyncF(EQ: Eq<Kind<F, Int>>): Unit =
+    forAll(genEither(genThrowable(), Gen.int())) { eith ->
+      val k: ((Either<Throwable, Int>) -> Unit) -> Unit = { f ->
+        f(eith)
+      }
+
+      async(k).equalUnderTheLaw(asyncF { cb -> delay { k(cb) } }, EQ)
+    }
+
+  fun <F> Async<F>.bracketReleaseIscalledOnCompletedOrError(EQ: Eq<Kind<F, Int>>): Unit =
+    forAll(Gen.string().map(::just), Gen.int()) { fa, b ->
+      Promise.uncancelable<F, Int>(this).flatMap { promise ->
+        val br = delay { promise }.bracketCase(use = { fa }, release = { r, exitCase ->
+          when (exitCase) {
+            is ExitCase.Completed -> r.complete(b)
+            is ExitCase.Error -> r.complete(b)
+            else -> just(Unit)
+          }
+        })
+
+        asyncF<Unit> { cb ->
+          br.flatMap { delay { cb(Right(Unit)) } }
+        }.flatMap { promise.get }
+      }.equalUnderTheLaw(just(b), EQ)
+    }
+
+  fun <F> Async<F>.asyncCancelableCoherence(EQ: Eq<Kind<F, Int>>): Unit =
+    forAll(genEither(genThrowable(), Gen.int())) { eith ->
+      async<Int> { cb -> cb(eith) }
+        .equalUnderTheLaw(cancelable { cb -> cb(eith); just(Unit) }, EQ)
+    }
+
+  fun <F> Async<F>.cancelableCancelableFCoherence(EQ: Eq<Kind<F, Int>>): Unit =
+    forAll(genEither(genThrowable(), Gen.int())) { eith ->
+      cancelable<Int> { cb -> cb(eith); just(Unit) }
+          .equalUnderTheLaw(cancelableF { cb -> delay { cb(eith); just(Unit) } }, EQ)
+      }
+
+      // Turns out that kotlinx.coroutines decides to rewrite thread names
+      private fun getCurrentThread() =
+        Thread.currentThread().name.substringBefore(' ').toInt()
+
+    }

modules/core/arrow-typeclasses/src/main/kotlin/arrow/typeclasses/Applicative.kt

@@ -13,7 +13,8 @@ interface Applicative<F> : Functor<F> {
 
   fun <A> just(a: A): Kind<F, A>
 
-  fun <A> A.just(dummy: Unit = Unit): Kind<F, A> = just(this)
+  fun <A> A.just(dummy: Unit = Unit): Kind<F, A> =
+    just(this)
 
   fun unit(): Kind<F, Unit> = just(Unit)
 
@@ -22,11 +23,14 @@ interface Applicative<F> : Functor<F> {
   fun <A, B> Kind<F, A>.product(fb: Kind<F, B>): Kind<F, Tuple2<A, B>> =
     fb.ap(this.map { a: A -> { b: B -> Tuple2(a, b) } })
 
-  override fun <A, B> Kind<F, A>.map(f: (A) -> B): Kind<F, B> = ap(just(f))
+  override fun <A, B> Kind<F, A>.map(f: (A) -> B): Kind<F, B> =
+    ap(just(f))
 
-  fun <A, B, Z> Kind<F, A>.map2(fb: Kind<F, B>, f: (Tuple2<A, B>) -> Z): Kind<F, Z> = product(fb).map(f)
+  fun <A, B, Z> Kind<F, A>.map2(fb: Kind<F, B>, f: (Tuple2<A, B>) -> Z): Kind<F, Z> =
+    product(fb).map(f)
 
-  fun <A, B, Z> Kind<F, A>.map2Eval(fb: Eval<Kind<F, B>>, f: (Tuple2<A, B>) -> Z): Eval<Kind<F, Z>> = fb.map { fc -> map2(fc, f) }
+  fun <A, B, Z> Kind<F, A>.map2Eval(fb: Eval<Kind<F, B>>, f: (Tuple2<A, B>) -> Z): Eval<Kind<F, Z>> =
+    fb.map { fc -> map2(fc, f) }
 
   fun <A, B, Z> Kind<F, Tuple2<A, B>>.product(
     other: Kind<F, Z>,