arrow-kt · pakoito · Jul 16, 2017 · Jul 16, 2017 · Jul 16, 2017 · Jul 16, 2017
diff --git a/kategory/src/main/kotlin/kategory/instances/EvalEq.kt b/kategory/src/main/kotlin/kategory/instances/EvalEq.kt
@@ -0,0 +1,6 @@
+package kategory
+
+class EvalEq : Eq<HK<Eval.F, Int>> {
+    override fun eqv(a: HK<Eval.F, Int>, b: HK<Eval.F, Int>): Boolean =
+            a.ev().value() == b.ev().value()
+}
diff --git a/kategory/src/main/kotlin/kategory/instances/FreeEq.kt b/kategory/src/main/kotlin/kategory/instances/FreeEq.kt
@@ -0,0 +1,11 @@
+package kategory
+
+data class FreeEq<in F, in G, in A>(private val interpreter: FunctionK<F, G>, private val MG: Monad<G>) : Eq<HK<FreeF<F>, A>> {
+    override fun eqv(a: HK<FreeF<F>, A>, b: HK<FreeF<F>, A>): Boolean =
+            a.ev().foldMap(interpreter, MG) == b.ev().foldMap(interpreter, MG)
+
+    companion object {
+        inline operator fun <F, reified G, A> invoke(interpreter: FunctionK<F, G>, MG: Monad<G> = monad(), dummy: Unit = Unit): FreeEq<F, G, A> =
+                FreeEq(interpreter, MG)
+    }
+}
diff --git a/kategory/src/main/kotlin/kategory/instances/Function0Eq.kt b/kategory/src/main/kotlin/kategory/instances/Function0Eq.kt
@@ -0,0 +1,6 @@
+package kategory
+
+class Function0Eq : Eq<HK<Function0.F, Int>> {
+    override fun eqv(a: HK<Function0.F, Int>, b: HK<Function0.F, Int>): Boolean =
+            a.ev()() == b.ev()()
+}
diff --git a/kategory/src/main/kotlin/kategory/instances/IOEq.kt b/kategory/src/main/kotlin/kategory/instances/IOEq.kt
@@ -0,0 +1,6 @@
+package kategory
+
+class IOEq : Eq<HK<IO.F, Int>> {
+    override fun eqv(a: HK<IO.F, Int>, b: HK<IO.F, Int>): Boolean =
+            a.ev().unsafeRunSync() == b.ev().unsafeRunSync()
+}
diff --git a/kategory/src/main/kotlin/kategory/typeclasses/Eq.kt b/kategory/src/main/kotlin/kategory/typeclasses/Eq.kt
@@ -7,11 +7,14 @@ interface Eq<in F> : Typeclass {
             !eqv(a, b)
 
     companion object {
-        operator fun <F> invoke() = object : Eq<F> {
-            override fun eqv(a: F, b: F): Boolean =
+        fun any(): Eq<Any?> =
+                EqAny()
+
+        private class EqAny : Eq<Any?> {
+            override fun eqv(a: Any?, b: Any?): Boolean =
                     a == b
 
-            override fun neqv(a: F, b: F): Boolean =
+            override fun neqv(a: Any?, b: Any?): Boolean =
                     a != b
         }
     }

diff --git a/kategory/src/test/kotlin/kategory/data/EitherTTest.kt b/kategory/src/test/kotlin/kategory/data/EitherTTest.kt
@@ -10,7 +10,7 @@ import org.junit.runner.RunWith
 class EitherTTest : UnitSpec() {
     init {
 
-        testLaws(MonadLaws.laws(EitherTMonad<Id.F, Int>(), Eq()))
+        testLaws(MonadLaws.laws(EitherTMonad<Id.F, Int>(), Eq.any()))
 
         "map should modify value" {
             forAll { a: String ->
@@ -182,7 +182,7 @@ class EitherTTest : UnitSpec() {
             forAll(Gen.oneOf(listOf(10000))) { limit: Int ->
                 val value: EitherT<Id.F, Int, Int> = EitherTMonad<Id.F, Int>(Id).tailRecM(0) { current ->
                     if (current == limit)
-                        EitherT.left<Id.F, Int, Either<Int, Int>>(current)
+                        EitherT.left(current)
                     else
                         EitherT.pure<Id.F, Int, Either<Int, Int>>(Either.Left(current + 1))
                 }

diff --git a/kategory/src/test/kotlin/kategory/data/EitherTest.kt b/kategory/src/test/kotlin/kategory/data/EitherTest.kt
@@ -11,7 +11,7 @@ import org.junit.runner.RunWith
 class EitherTest : UnitSpec() {
     init {
 
-        testLaws(MonadErrorLaws.laws(EitherMonadError<Throwable>(), Eq()))
+        testLaws(MonadErrorLaws.laws(EitherMonadError(), Eq.any()))
 
         "map should modify value" {
             forAll { a: Int, b: String ->

diff --git a/kategory/src/test/kotlin/kategory/data/EvalTest.kt b/kategory/src/test/kotlin/kategory/data/EvalTest.kt
@@ -8,10 +8,7 @@ import org.junit.runner.RunWith
 class EvalTest : UnitSpec() {
     init {
 
-        testLaws(MonadLaws.laws(Eval, object : Eq<HK<Eval.F, Int>> {
-            override fun eqv(a: HK<Eval.F, Int>, b: HK<Eval.F, Int>): Boolean =
-                    a.ev().value() == b.ev().value()
-        }))
+        testLaws(MonadLaws.laws(Eval, EvalEq()))
 
         "should map wrapped value" {
             val sideEffect = SideEffect()

diff --git a/kategory/src/test/kotlin/kategory/data/Function0Test.kt b/kategory/src/test/kotlin/kategory/data/Function0Test.kt
@@ -8,10 +8,7 @@ import org.junit.runner.RunWith
 class Function0Test : UnitSpec() {
     init {
 
-        testLaws(MonadLaws.laws(Function0, object : Eq<HK<Function0.F, Int>> {
-            override fun eqv(a: HK<Function0.F, Int>, b: HK<Function0.F, Int>): Boolean =
-                    a.ev()() == b.ev()()
-        }))
+        testLaws(MonadLaws.laws(Function0, Function0Eq()))
 
         "Function0Monad.binding should for comprehend over all values of multiple Function0" {
             Function0.binding {

diff --git a/kategory/src/test/kotlin/kategory/data/IdTest.kt b/kategory/src/test/kotlin/kategory/data/IdTest.kt
@@ -8,7 +8,7 @@ import org.junit.runner.RunWith
 class IdTest : UnitSpec() {
     init {
 
-        testLaws(MonadLaws.laws(Id, Eq()))
+        testLaws(MonadLaws.laws(Id, Eq.any()))
 
         "IdMonad.binding should for comprehend over all values of multiple Ids" {
             Id.binding {

diff --git a/kategory/src/test/kotlin/kategory/data/IorTest.kt b/kategory/src/test/kotlin/kategory/data/IorTest.kt
@@ -13,7 +13,7 @@ class IorTest : UnitSpec() {
 
         val intIorMonad = IorMonad(IntMonoid)
 
-        testLaws(MonadLaws.laws(intIorMonad, Eq()))
+        testLaws(MonadLaws.laws(intIorMonad, Eq.any()))
 
         "flatMap() should modify entity" {
             forAll { a: Int, b: String ->

diff --git a/kategory/src/test/kotlin/kategory/data/NonEmptyListTest.kt b/kategory/src/test/kotlin/kategory/data/NonEmptyListTest.kt
@@ -9,7 +9,7 @@ import org.junit.runner.RunWith
 class NonEmptyListTest : UnitSpec() {
     init {
 
-        testLaws(MonadLaws.laws(NonEmptyList, Eq()))
+        testLaws(MonadLaws.laws(NonEmptyList, Eq.any()))
 
         "map should modify values" {
             NonEmptyList.of(14).map { it * 3 } shouldBe NonEmptyList.of(42)

diff --git a/kategory/src/test/kotlin/kategory/data/OptionTTest.kt b/kategory/src/test/kotlin/kategory/data/OptionTTest.kt
@@ -9,7 +9,7 @@ import org.junit.runner.RunWith
 class OptionTTest : UnitSpec() {
     init {
 
-        testLaws(MonadLaws.laws(OptionTMonad(NonEmptyList), Eq()))
+        testLaws(MonadLaws.laws(OptionTMonad(NonEmptyList), Eq.any()))
 
         "map should modify value" {
             forAll { a: String ->

diff --git a/kategory/src/test/kotlin/kategory/data/OptionTest.kt b/kategory/src/test/kotlin/kategory/data/OptionTest.kt
@@ -13,7 +13,7 @@ class OptionTest: UnitSpec() {
 
     init {
 
-        testLaws(MonadLaws.laws(Option, Eq()))
+        testLaws(MonadLaws.laws(Option, Eq.any()))
 
         "map should modify value" {
             Some(12).map { "flower" } shouldBe Some("flower")

diff --git a/kategory/src/test/kotlin/kategory/data/TryTest.kt b/kategory/src/test/kotlin/kategory/data/TryTest.kt
@@ -11,7 +11,7 @@ class TryTest : UnitSpec() {
 
     init {
 
-        testLaws(MonadErrorLaws.laws(Try, Eq()))
+        testLaws(MonadErrorLaws.laws(Try, Eq.any()))
 
         "invoke of any should be success" {
             Try.invoke { 1 } shouldBe Success(1)

diff --git a/kategory/src/test/kotlin/kategory/data/ValidatedTest.kt b/kategory/src/test/kotlin/kategory/data/ValidatedTest.kt
@@ -16,7 +16,7 @@ class ValidatedTest : UnitSpec() {
             override fun combine(a: String, b: String): String = "$a $b"
         }
 
-        testLaws(ApplicativeLaws.laws(ValidatedApplicativeError(concatStringSG), Eq()))
+        testLaws(ApplicativeLaws.laws(ValidatedApplicativeError(concatStringSG), Eq.any()))
 
         "fold should call function on Invalid" {
             val exception = Exception("My Exception")

diff --git a/kategory/src/test/kotlin/kategory/data/WriterTTest.kt b/kategory/src/test/kotlin/kategory/data/WriterTTest.kt
@@ -9,7 +9,7 @@ import org.junit.runner.RunWith
 class WriterTTest : UnitSpec() {
     init {
 
-        testLaws(MonadLaws.laws(WriterTMonad(NonEmptyList, IntMonoid), Eq()))
+        testLaws(MonadLaws.laws(WriterTMonad(NonEmptyList, IntMonoid), Eq.any()))
 
         "tell should accumulate write" {
             forAll { a: Int ->

diff --git a/kategory/src/test/kotlin/kategory/effects/IOTest.kt b/kategory/src/test/kotlin/kategory/effects/IOTest.kt
@@ -11,10 +11,7 @@ class IOTest : UnitSpec() {
 
     init {
 
-        testLaws(MonadLaws.laws(IO, object : Eq<HK<IO.F, Int>> {
-            override fun eqv(a: HK<IO.F, Int>, b: HK<IO.F, Int>): Boolean =
-                a.ev().unsafeRunSync() == b.ev().unsafeRunSync()
-        }))
+        testLaws(MonadLaws.laws(IO, IOEq()))
 
         "should defer evaluation until run" {
             var run = false

diff --git a/kategory/src/test/kotlin/kategory/free/FreeTest.kt b/kategory/src/test/kotlin/kategory/free/FreeTest.kt
@@ -24,24 +24,21 @@ fun <A> HK<Ops.F, A>.ev(): Ops<A> = this as Ops<A>
 @RunWith(KTestJUnitRunner::class)
 class FreeTest : UnitSpec() {
 
-    val program = Ops.binding {
+    private val program = Ops.binding {
         val added = !Ops.add(10, 10)
         val subtracted = !Ops.subtract(added, 50)
         yields(subtracted)
     }.ev()
 
-    fun stackSafeTestProgram(n: Int, stopAt: Int): Free<Ops.F, Int> = Ops.binding {
+    private fun stackSafeTestProgram(n: Int, stopAt: Int): Free<Ops.F, Int> = Ops.binding {
         val v = !Ops.add(n, 1)
-        val r = !if (v < stopAt) stackSafeTestProgram(v, stopAt) else Free.pure<Ops.F, Int>(v)
+        val r = !if (v < stopAt) stackSafeTestProgram(v, stopAt) else Free.pure(v)
         yields(r)
     }.ev()
 
     init {
 
-        testLaws(MonadLaws.laws(Ops, object : Eq<HK<FreeF<Ops.F>, Int>> {
-            override fun eqv(a: HK<FreeF<Ops.F>, Int>, b: HK<FreeF<Ops.F>, Int>): Boolean =
-                    a.ev().foldMap(idInterpreter, Id) == b.ev().foldMap(idInterpreter, Id)
-        }))
+        testLaws(MonadLaws.laws(Ops, FreeEq(idInterpreter)))
 
         "Can interpret an ADT as Free operations" {
             program.foldMap(optionInterpreter, Option).ev() shouldBe Option.Some(-30)

diff --git a/kategory/src/test/kotlin/kategory/laws/FunctorLaws.kt b/kategory/src/test/kotlin/kategory/laws/FunctorLaws.kt
@@ -11,12 +11,12 @@ object FunctorLaws {
                     Law("Functor: Covariant Composition", { covariantComposition(AP, EQ) })
             )
 
-    inline fun <reified F> covariantIdentity(AP: Applicative<F> = applicative<F>(), EQ: Eq<HK<F, Int>> = Eq()): Unit =
+    inline fun <reified F> covariantIdentity(AP: Applicative<F> = applicative<F>(), EQ: Eq<HK<F, Int>> = Eq.any()): Unit =
             forAll(genApplicative(Gen.int(), AP), { fa: HK<F, Int> ->
                 AP.map(fa, ::identity).equalUnderTheLaw(fa, EQ)
             })
 
-    inline fun <reified F> covariantComposition(AP: Applicative<F> = applicative<F>(), EQ: Eq<HK<F, Int>> = Eq()): Unit =
+    inline fun <reified F> covariantComposition(AP: Applicative<F> = applicative<F>(), EQ: Eq<HK<F, Int>> = Eq.any()): Unit =
             forAll(
                     genApplicative(Gen.int(), AP),
                     genFunctionAToB<Int, Int>(Gen.int()),

diff --git a/kategory/src/test/kotlin/kategory/laws/Law.kt b/kategory/src/test/kotlin/kategory/laws/Law.kt
@@ -2,5 +2,5 @@ package kategory
 
 data class Law(val name: String, val test: () -> Unit)
 
-inline fun <reified A> A.equalUnderTheLaw(b: A, eq: Eq<A> = Eq()): Boolean =
+inline fun <reified A> A.equalUnderTheLaw(b: A, eq: Eq<A> = Eq.any()): Boolean =
         eq.eqv(this, b)