fix rebase conflicts and add StateT instances under new system

Author: JorgeCastilloPrz

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

@@ -13,8 +13,7 @@ package kategory
         Monad::class,
         Foldable::class,
         Traverse::class,
-        MonadFilter::class,
-        MonadCombine::class)
+        MonadFilter::class)
 sealed class Option<out A> : OptionKind<A> {
 
     companion object {

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

@@ -15,6 +15,8 @@ class StateT<F, S, A>(
 
         fun <F, S, A> invokeF(runF: StateTFunKind<F, S, A>): StateT<F, S, A> = StateT(runF)
 
+        fun <F, S, A> lift(fa: HK<F, A>, MF: Monad<F>): StateT<F, S, A> = StateT(MF.pure({ s -> MF.map(fa, { a -> Tuple2(s, a) }) }))
+
         inline fun <reified F, S> functor(FF: Functor<F> = functor<F>()): StateTFunctorInstance<F, S> =
                 StateTFunctorInstanceImplicits.instance(FF)
 
@@ -30,6 +32,12 @@ class StateT<F, S, A>(
         inline fun <reified F, S> semigroupK(MF: Monad<F> = monad<F>(), SF: SemigroupK<F> = semigroupK<F>()): StateTSemigroupKInstance<F, S> =
                 StateTSemigroupKInstanceImplicits.instance(MF, SF)
 
+        inline fun <reified F, S> monadCombine(MCF: MonadCombine<F> = monadCombine<F>()): StateTMonadCombineInstance<F, S> =
+                StateTMonadCombineInstanceImplicits.instance(MCF)
+
+        inline fun <reified F, S, reified E> monadError(ME: MonadError<F, E> = monadError<F, E>()) : StateTMonadErrorInstance<F, S, E> =
+                StateTMonadErrorImplicits.instance(ME)
+
         fun <F, S> get(AF: Applicative<F>): StateT<F, S, S> = StateT(AF.pure({ s: S -> AF.pure(Tuple2(s, s)) }))
 
         fun <F, S> set(s: S, AF: Applicative<F>): StateT<F, S, Unit> = StateT(AF.pure({ _: S -> AF.pure(Tuple2(s, Unit)) }))

kategory-core/src/main/kotlin/kategory/instances/StateTInstances.kt

@@ -95,20 +95,39 @@ object StateTSemigroupKInstanceImplicits {
     }
 }
 
-interface StateTMonadCombine<F, S> : MonadCombine<StateTKindPartial<F, S>>, StateTMonad<F, S>, StateTSemigroupK<F, S> {
-    override fun F(): MonadCombine<F>
-    override fun G(): MonadCombine<F> = F()
+interface StateTMonadCombineInstance<F, S> : MonadCombine<StateTKindPartial<F, S>>, StateTMonadInstance<F, S>, StateTSemigroupKInstance<F, S> {
 
-    override fun <A> empty(): StateT<F, S, A> = liftT(F().empty())
+    override fun MF(): MonadCombine<F>
+    override fun SF(): SemigroupK<F> = MF()
 
-    fun <A> liftT(ma: HK<F, A>): StateT<F, S, A> = StateT(F(), F().pure({ s: S -> F().map(ma, { a: A -> s toT a }) }))
+    override fun <A> empty(): HK<StateTKindPartial<F, S>, A> = liftT(MF().empty())
+
+    fun <A> liftT(ma: HK<F, A>): StateT<F, S, A> = StateT(MF().pure({ s: S -> MF().map(ma, { a: A -> s toT a }) }))
+}
+
+object StateTMonadCombineInstanceImplicits {
+    @JvmStatic
+    fun <F, S> instance(MCF: MonadCombine<F>): StateTMonadCombineInstance<F, S> = object : StateTMonadCombineInstance<F, S> {
+        override fun FF(): Functor<F> = MCF
+        override fun MF(): MonadCombine<F> = MCF
+
+    }
 }
 
-interface StateTMonadError<F, S, E> : StateTMonad<F, S>, MonadError<StateTKindPartial<F, S>, E> {
-    override fun F(): MonadError<F, E>
+interface StateTMonadErrorInstance<F, S, E> : StateTMonadInstance<F, S>, MonadError<StateTKindPartial<F, S>, E> {
+    override fun MF(): MonadError<F, E>
 
-    override fun <A> raiseError(e: E): StateT<F, S, A> = StateT.lift(F().raiseError(e), F())
+    override fun <A> raiseError(e: E): HK<StateTKindPartial<F, S>, A> = StateT.lift(MF().raiseError(e), MF())
 
     override fun <A> handleErrorWith(fa: HK<StateTKindPartial<F, S>, A>, f: (E) -> HK<StateTKindPartial<F, S>, A>): StateT<F, S, A> =
-            StateT(F(), F().pure({ s -> F().handleErrorWith(fa.runM(s), { e -> f(e).runM(s) }) }))
+            StateT(MF().pure({ s -> MF().handleErrorWith(fa.runM(s, MF()), { e -> f(e).runM(s, MF()) }) }))
 }
+
+object StateTMonadErrorImplicits {
+    @JvmStatic
+    fun <F, S, E> instance(ME: MonadError<F, E>): StateTMonadErrorInstance<F, S, E> = object : StateTMonadErrorInstance<F, S, E> {
+        override fun FF(): Functor<F> = ME
+        override fun MF(): MonadError<F, E> = ME
+    }
+}
+

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

@@ -42,7 +42,6 @@ class OptionTest : UnitSpec() {
         //testLaws(MonadErrorLaws.laws(monadError<OptionHK, Unit>(), Eq.any(), EQ_EITHER)) TODO reenable once the MonadErrorLaws are parametric to `E`
         testLaws(TraverseLaws.laws(Option.traverse(), Option.monad(), ::Some, Eq.any()))
         testLaws(MonadFilterLaws.laws(Option.monadFilter(), ::Some, Eq.any()))
-        testLaws(MonadCombineLaws.laws(Option.monadCombine(), ::Some, { Some({ a: Int -> a * 2 }) }, Eq.any(), Eq.any()))
 
         "fromNullable should work for both null and non-null values of nullable types" {
             forAll { a: Int? ->

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

@@ -44,7 +44,7 @@ class StateTTests : UnitSpec() {
                 { 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) == b.runM(1)
+                            a.runM(1, ListKW.monad()) == b.runM(1, ListKW.monad())
                 }))
 
     }

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

@@ -2,8 +2,6 @@ package kategory
 
 import io.kotlintest.KTestJUnitRunner
 import io.kotlintest.matchers.shouldNotBe
-import kategory.laws.FunctorFilterLaws
-import kategory.laws.MonadFilterLaws
 import org.junit.runner.RunWith
 
 @RunWith(KTestJUnitRunner::class)

kategory-core/src/test/kotlin/kategory/instances/StringInstancesTest.kt

@@ -3,7 +3,6 @@ package kategory.instances
 import io.kotlintest.KTestJUnitRunner
 import io.kotlintest.matchers.shouldNotBe
 import kategory.*
-import kategory.laws.FunctorFilterLaws
 import org.junit.runner.RunWith
 
 @RunWith(KTestJUnitRunner::class)
@@ -14,4 +13,4 @@ class StringInstancesTest : UnitSpec() {
             monoid<String>() shouldNotBe null
         }
     }
-}
+}