Remove dependency on kotlinx.coroutines for effects

kategory-core/build.gradle

@@ -1,6 +1,5 @@
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlinVersion"
-    compile "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinxCoroutinesVersion"
     compile project(':kategory-annotations')
     kapt project(':kategory-annotations-processor')
     kaptTest project(':kategory-annotations-processor')

kategory-core/src/main/kotlin/kategory/data/Option.kt

@@ -49,14 +49,15 @@ sealed class Option<out A> : OptionKind<A> {
 
     /**
      * Returns true if the option is [None], false otherwise.
-     * Used only for performance instead of fold.
+     * @note Used only for performance instead of fold.
      */
     internal abstract val isEmpty: Boolean
 
     /**
      * Returns true if the option is an instance of $some, false otherwise.
+     * @note Used only for performance instead of fold.
      */
-    val isDefined: Boolean = !isEmpty
+    internal val isDefined: Boolean = !isEmpty
 
     /**
      * Returns a $some containing the result of applying $f to this $option's
@@ -142,8 +143,9 @@ sealed class Option<out A> : OptionKind<A> {
     /**
      * Returns false if the option is $none, true otherwise.
      * @note Implemented here to avoid the implicit conversion to Iterable.
+     * @note Used only for performance instead of fold.
      */
-    val nonEmpty = isDefined
+    internal val nonEmpty = isDefined
 
     /**
      * Returns true if this option is nonempty '''and''' the predicate

kategory-core/src/main/kotlin/kategory/typeclasses/Comonad.kt

@@ -1,12 +1,9 @@
 package kategory
 
 import java.io.Serializable
-import kotlin.coroutines.experimental.Continuation
-import kotlin.coroutines.experimental.EmptyCoroutineContext
-import kotlin.coroutines.experimental.RestrictsSuspension
+import kotlin.coroutines.experimental.*
 import kotlin.coroutines.experimental.intrinsics.COROUTINE_SUSPENDED
 import kotlin.coroutines.experimental.intrinsics.suspendCoroutineOrReturn
-import kotlin.coroutines.experimental.startCoroutine
 
 /**
  * The dual of monads, used to extract values from F
@@ -27,9 +24,7 @@ inline fun <reified F, A> HK<F, A>.extract(FT: Comonad<F> = comonad()): A = FT.e
 inline fun <reified F, A> HK<F, A>.duplicate(FT: Comonad<F> = comonad()): HK<F, HK<F, A>> = FT.duplicate(this)
 
 @RestrictsSuspension
-open class ComonadContinuation<F, A : Any>(val CM: Comonad<F>) : Serializable, Continuation<A> {
-
-    override val context = EmptyCoroutineContext
+open class ComonadContinuation<F, A : Any>(val CM: Comonad<F>, override val context: CoroutineContext = EmptyCoroutineContext) : Serializable, Continuation<A> {
 
     override fun resume(value: A) {
         returnedMonad = value
@@ -59,7 +54,7 @@ open class ComonadContinuation<F, A : Any>(val CM: Comonad<F>) : Serializable, C
  * A coroutine is initiated and inside `MonadContinuation` suspended yielding to `flatMap` once all the flatMap binds are completed
  * the underlying monad is returned from the act of executing the coroutine
  */
-fun <F, B : Any> Comonad<F>.cobinding(c: suspend ComonadContinuation<F, *>.() -> B): B {
+fun <F, B : Any> Comonad<F>.cobinding(coroutineContext: CoroutineContext = EmptyCoroutineContext, c: suspend ComonadContinuation<F, *>.() -> B): B {
     val continuation = ComonadContinuation<F, B>(this)
     c.startCoroutine(continuation, continuation)
     return continuation.returnedMonad

kategory-core/src/main/kotlin/kategory/typeclasses/Eq.kt

@@ -6,6 +6,11 @@ interface Eq<in F> : Typeclass {
     fun neqv(a: F, b: F): Boolean = !eqv(a, b)
 
     companion object {
+        inline operator fun <F> invoke(crossinline feqv: (F, F) -> Boolean): Eq<F> = object : Eq<F> {
+            override fun eqv(a: F, b: F): Boolean =
+                    feqv(a, b)
+        }
+
         fun any(): Eq<Any?> = EqAny
 
         object EqAny : Eq<Any?> {

kategory-core/src/main/kotlin/kategory/typeclasses/Monad.kt

@@ -1,6 +1,5 @@
 package kategory
 
-import kotlinx.coroutines.experimental.runBlocking
 import java.io.Serializable
 import kotlin.coroutines.experimental.Continuation
 import kotlin.coroutines.experimental.CoroutineContext
@@ -67,17 +66,6 @@ open class MonadContinuation<F, A>(M: Monad<F>, override val context: CoroutineC
         COROUTINE_SUSPENDED
     }
 
-    suspend fun <B> bindInContext(coroutineContext: CoroutineContext, m: suspend () -> HK<F, B>): B = suspendCoroutineOrReturn { c ->
-        val labelHere = c.stackLabels // save the whole coroutine stack labels
-        val result = runBlocking(coroutineContext) { m() }
-        returnedMonad = flatMap(result, { x: B ->
-            c.stackLabels = labelHere
-            c.resume(x)
-            returnedMonad
-        })
-        COROUTINE_SUSPENDED
-    }
-
     infix fun <B> yields(b: B): HK<F, B> = yields { b }
 
     infix fun <B> yields(b: () -> B): HK<F, B> = pure(b())
@@ -125,17 +113,6 @@ open class StackSafeMonadContinuation<F, A>(M: Monad<F>, override val context: C
         COROUTINE_SUSPENDED
     }
 
-    suspend fun <B> bindInContext(coroutineContext: CoroutineContext, m: suspend () -> Free<F, B>): B = suspendCoroutineOrReturn { c ->
-        val labelHere = c.stackLabels // save the whole coroutine stack labels
-        val freeResult = runBlocking(coroutineContext) { m() }
-        returnedMonad = freeResult.flatMap { z ->
-            c.stackLabels = labelHere
-            c.resume(z)
-            returnedMonad
-        }
-        COROUTINE_SUSPENDED
-    }
-
     infix fun <B> yields(b: B): Free<F, B> = yields { b }
 
     infix fun <B> yields(b: () -> B): Free<F, B> = Free.liftF(pure(b()))

kategory-core/src/test/kotlin/kategory/data/CoproductTest.kt

@@ -2,13 +2,11 @@ package kategory
 
 import io.kotlintest.KTestJUnitRunner
 import io.kotlintest.matchers.shouldNotBe
-import io.kotlintest.properties.forAll
 import org.junit.runner.RunWith
 
 @RunWith(KTestJUnitRunner::class)
 class CoproductTest : UnitSpec() {
-    val EQ: Eq<HK3<CoproductHK, IdHK, IdHK, Int>> = object : Eq<HK3<CoproductHK, IdHK, IdHK, Int>> {
-        override fun eqv(a: CoproductKind<IdHK, IdHK, Int>, b: CoproductKind<IdHK, IdHK, Int>): Boolean =
+    val EQ: Eq<HK3<CoproductHK, IdHK, IdHK, Int>> = Eq { a, b ->
                 a.ev().extract() == b.ev().extract()
     }
 

kategory-core/src/test/kotlin/kategory/data/EitherTest.kt

@@ -1,7 +1,6 @@
 package kategory
 
 import io.kotlintest.KTestJUnitRunner
-import io.kotlintest.matchers.shouldBe
 import io.kotlintest.matchers.shouldNotBe
 import io.kotlintest.properties.forAll
 import kategory.Either.Left
@@ -10,6 +9,10 @@ import org.junit.runner.RunWith
 
 @RunWith(KTestJUnitRunner::class)
 class EitherTest : UnitSpec() {
+    val EQ: Eq<HK<EitherKindPartial<IdHK>, Int>> = Eq { a, b ->
+        a.ev() == b.ev()
+    }
+
     init {
 
         "instances can be resolved implicitly" {
@@ -24,13 +27,7 @@ class EitherTest : UnitSpec() {
 
         testLaws(MonadErrorLaws.laws(Either.monadError(), Eq.any(), Eq.any()))
         testLaws(TraverseLaws.laws(Either.traverse<Throwable>(), Either.applicative(), { it.right() }, Eq.any()))
-        testLaws(SemigroupKLaws.laws(
-                Either.semigroupK(),
-                Either.applicative(),
-                object : Eq<HK<EitherKindPartial<IdHK>, Int>> {
-                    override fun eqv(a: HK<EitherKindPartial<IdHK>, Int>, b: HK<EitherKindPartial<IdHK>, Int>): Boolean =
-                            a.ev() == b.ev()
-                }))
+        testLaws(SemigroupKLaws.laws(Either.semigroupK(), Either.applicative(), EQ))
 
         "getOrElse should return value" {
             forAll { a: Int, b: Int ->

kategory-core/src/test/kotlin/kategory/data/EvalTest.kt

@@ -8,8 +8,7 @@ import org.junit.runner.RunWith
 class EvalTest : UnitSpec() {
     init {
 
-        testLaws(MonadLaws.laws(Eval.monad(), object : Eq<HK<EvalHK, Int>> {
-            override fun eqv(a: HK<EvalHK, Int>, b: HK<EvalHK, Int>): Boolean =
+        testLaws(MonadLaws.laws(Eval.monad(), Eq { a, b ->
                     a.ev().value() == b.ev().value()
         }))
 

kategory-core/src/test/kotlin/kategory/data/Function0Test.kt

@@ -1,14 +1,12 @@
 package kategory
 
 import io.kotlintest.KTestJUnitRunner
-import io.kotlintest.matchers.shouldBe
 import org.junit.runner.RunWith
 
 @RunWith(KTestJUnitRunner::class)
 class Function0Test : UnitSpec() {
-    val EQ: Eq<HK<Function0HK, Int>> = object : Eq<HK<Function0HK, Int>> {
-        override fun eqv(a: HK<Function0HK, Int>, b: HK<Function0HK, Int>): Boolean =
-                a() == b()
+    val EQ: Eq<HK<Function0HK, Int>> = Eq { a, b ->
+        a() == b()
     }
 
     init {

kategory-core/src/test/kotlin/kategory/data/Function1Test.kt

@@ -1,12 +1,15 @@
 package kategory
 
 import io.kotlintest.KTestJUnitRunner
-import io.kotlintest.matchers.shouldBe
 import io.kotlintest.matchers.shouldNotBe
 import org.junit.runner.RunWith
 
 @RunWith(KTestJUnitRunner::class)
 class Function1Test : UnitSpec() {
+    val EQ: Eq<Function1Kind<Int, Int>> = Eq { a, b ->
+        a(1) == b(1)
+    }
+
     init {
 
         "instances can be resolved implicitly" {
@@ -16,9 +19,6 @@ class Function1Test : UnitSpec() {
             monadReader<Function1KindPartial<Int>, Int>()  shouldNotBe null
         }
 
-        testLaws(MonadLaws.laws(Function1.monad<Int>(), object : Eq<Function1Kind<Int, Int>> {
-            override fun eqv(a: Function1Kind<Int, Int>, b: Function1Kind<Int, Int>): Boolean =
-                a(1) == b(1)
-        }))
+        testLaws(MonadLaws.laws(Function1.monad<Int>(), EQ))
     }
 }

kategory-core/src/test/kotlin/kategory/data/KleisliTest.kt

@@ -7,12 +7,8 @@ import org.junit.runner.RunWith
 
 @RunWith(KTestJUnitRunner::class)
 class KleisliTest : UnitSpec() {
-    private fun <A> EQ(): Eq<KleisliKind<TryHK, Int, A>> {
-        return object : Eq<KleisliKind<TryHK, Int, A>> {
-            override fun eqv(a: KleisliKind<TryHK, Int, A>, b: KleisliKind<TryHK, Int, A>): Boolean =
-                    a.ev().run(1) == b.ev().run(1)
-
-        }
+    private fun <A> EQ(): Eq<KleisliKind<TryHK, Int, A>> = Eq { a, b ->
+        a.ev().run(1) == b.ev().run(1)
     }
 
     init {

kategory-core/src/test/kotlin/kategory/data/OptionTTest.kt

@@ -7,6 +7,12 @@ import org.junit.runner.RunWith
 
 @RunWith(KTestJUnitRunner::class)
 class OptionTTest : UnitSpec() {
+    val EQ_ID: Eq<HK<OptionTKindPartial<IdHK>, Int>> = Eq { a, b ->
+        a.value() == b.value()
+    }
+
+    val NELM: Monad<NonEmptyListHK> = monad<NonEmptyListHK>()
+
     init {
 
         "instances can be resolved implicitly" {
@@ -20,51 +26,44 @@ class OptionTTest : UnitSpec() {
             functorFilter<OptionTKindPartial<ListKWHK>>() shouldNotBe null
         }
 
-        val OptionTFIdEq = object : Eq<HK<OptionTKindPartial<IdHK>, Int>> {
-            override fun eqv(a: HK<OptionTKindPartial<IdHK>, Int>, b: HK<OptionTKindPartial<IdHK>, Int>): Boolean =
-                    a.ev().value == b.ev().value
-        }
-
         testLaws(MonadLaws.laws(OptionT.monad(NonEmptyList.monad()), Eq.any()))
         testLaws(TraverseLaws.laws(OptionT.traverse(), OptionT.applicative(Id.monad()), { OptionT(Id(it.some())) }, Eq.any()))
         testLaws(SemigroupKLaws.laws(
                 OptionT.semigroupK(Id.monad()),
                 OptionT.applicative(Id.monad()),
-                OptionTFIdEq))
+                EQ_ID))
 
         testLaws(MonoidKLaws.laws(
                 OptionT.monoidK(Id.monad()),
                 OptionT.applicative(Id.monad()),
-                OptionTFIdEq))
+                EQ_ID))
 
         testLaws(FunctorFilterLaws.laws(
                 OptionT.functorFilter(),
                 { OptionT(Id(it.some())) },
-                OptionTFIdEq))
-
-        val nelMonad = monad<NonEmptyListHK>()
+                EQ_ID))
 
         "toLeft for Some should build a correct EitherT" {
             forAll { a: Int, b: String ->
-                OptionT.fromOption<NonEmptyListHK, Int>(Option.Some(a)).toLeft({ b }, nelMonad) == EitherT.left<NonEmptyListHK, Int, String>(a, applicative())
+                OptionT.fromOption<NonEmptyListHK, Int>(Option.Some(a)).toLeft({ b }, NELM) == EitherT.left<NonEmptyListHK, Int, String>(a, applicative())
             }
         }
 
         "toLeft for None should build a correct EitherT" {
             forAll { a: Int, b: String ->
-                OptionT.fromOption<NonEmptyListHK, Int>(Option.None).toLeft({ b }, nelMonad) == EitherT.right<NonEmptyListHK, Int, String>(b, applicative())
+                OptionT.fromOption<NonEmptyListHK, Int>(Option.None).toLeft({ b }, NELM) == EitherT.right<NonEmptyListHK, Int, String>(b, applicative())
             }
         }
 
         "toRight for Some should build a correct EitherT" {
             forAll { a: Int, b: String ->
-                OptionT.fromOption<NonEmptyListHK, String>(Option.Some(b)).toRight({ a }, nelMonad) == EitherT.right<NonEmptyListHK, Int, String>(b, applicative())
+                OptionT.fromOption<NonEmptyListHK, String>(Option.Some(b)).toRight({ a }, NELM) == EitherT.right<NonEmptyListHK, Int, String>(b, applicative())
             }
         }
 
         "toRight for None should build a correct EitherT" {
             forAll { a: Int, b: String ->
-                OptionT.fromOption<NonEmptyListHK, String>(Option.None).toRight({ a }, nelMonad) == EitherT.left<NonEmptyListHK, Int, String>(a, applicative())
+                OptionT.fromOption<NonEmptyListHK, String>(Option.None).toRight({ a }, NELM) == EitherT.left<NonEmptyListHK, Int, String>(a, applicative())
             }
         }
 

kategory-core/src/test/kotlin/kategory/data/OptionTest.kt

@@ -24,8 +24,7 @@ class OptionTest : UnitSpec() {
             monadError<OptionHK, Unit>() shouldNotBe null
         }
 
-        val EQ_EITHER: Eq<HK<OptionHK, Either<Unit, Int>>> = object : Eq<HK<OptionHK, Either<Unit, Int>>> {
-            override fun eqv(a: HK<OptionHK, Either<Unit, Int>>, b: HK<OptionHK, Either<Unit, Int>>): Boolean =
+        val EQ_EITHER: Eq<HK<OptionHK, Either<Unit, Int>>> = Eq { a, b ->
                     a.ev().fold(
                             { b.ev().fold({ true }, { false }) },
                             { eitherA: Either<Unit, Int> ->

kategory-core/src/test/kotlin/kategory/data/StateTTests.kt

@@ -7,6 +7,20 @@ import org.junit.runner.RunWith
 @RunWith(KTestJUnitRunner::class)
 class StateTTests : UnitSpec() {
 
+    val M: StateTMonadStateInstance<TryHK, Int> = StateT.monadState<TryHK, Int>(Try.monad())
+
+    val EQ: Eq<StateTKind<TryHK, Int, Int>> = Eq { a, b ->
+        a.runM(1, Try.monad()) == b.runM(1, Try.monad())
+    }
+
+    val EQ_UNIT: Eq<StateTKind<TryHK, Int, Unit>> = Eq { a, b ->
+        a.runM(1, Try.monad()) == b.runM(1, Try.monad())
+    }
+
+    val EQ_LIST: Eq<HK<StateTKindPartial<ListKWHK, Int>, Int>> = Eq { a, b ->
+        a.runM(1, ListKW.monad()) == b.runM(1, ListKW.monad())
+    }
+
     init {
 
         "instances can be resolved implicitly" {
@@ -17,35 +31,15 @@ class StateTTests : UnitSpec() {
             semigroupK<StateTKindPartial<NonEmptyListHK, NonEmptyListHK>>() shouldNotBe null
         }
 
-        val m: StateTMonadStateInstance<TryHK, Int> = StateT.monadState<TryHK, Int>(Try.monad())
-
-        testLaws(MonadStateLaws.laws(
-                m,
-                object : Eq<StateTKind<TryHK, Int, Int>> {
-                    override fun eqv(a: StateTKind<TryHK, Int, Int>, b: StateTKind<TryHK, Int, Int>): Boolean =
-                            a.runM(1, Try.monad()) == b.runM(1, Try.monad())
-
-                },
-                object : Eq<StateTKind<TryHK, Int, Unit>> {
-                    override fun eqv(a: StateTKind<TryHK, Int, Unit>, b: StateTKind<TryHK, Int, Unit>): Boolean =
-                            a.runM(1, Try.monad()) == b.runM(1, Try.monad())
-                }))
-
+        testLaws(MonadStateLaws.laws(M, EQ, EQ_UNIT))
         testLaws(SemigroupKLaws.laws(
                 StateT.semigroupK<ListKWHK, Int>(ListKW.monad(), ListKW.semigroupK()),
                 StateT.applicative<ListKWHK, Int>(ListKW.monad()),
-                object : Eq<HK<StateTKindPartial<ListKWHK, Int>, Int>> {
-                    override fun eqv(a: HK<StateTKindPartial<ListKWHK, Int>, Int>, b: HK<StateTKindPartial<ListKWHK, Int>, Int>): Boolean =
-                            a.runM(1, ListKW.monad()) == b.runM(1, ListKW.monad())
-                }))
-
+                EQ_LIST))
         testLaws(MonadCombineLaws.laws(StateT.monadCombine<ListKWHK, Int>(ListKW.monadCombine()),
                 { StateT.lift(ListKW.pure(it), ListKW.monad()) },
                 { StateT.lift(ListKW.pure({ s: Int -> s * 2 }), ListKW.monad()) },
-                object : Eq<HK<StateTKindPartial<ListKWHK, Int>, Int>> {
-                    override fun eqv(a: HK<StateTKindPartial<ListKWHK, Int>, Int>, b: HK<StateTKindPartial<ListKWHK, Int>, Int>): Boolean =
-                            a.runM(1, ListKW.monad()) == b.runM(1, ListKW.monad())
-                }))
+                EQ_LIST))
 
     }
 }