Change MonadState from F[_,_] to F[_]

core/src/main/scala/cats/MonadState.scala

@@ -6,7 +6,7 @@ package cats
   * dealing with large monad transformer stacks. For instance:
   *
   * {{{
-  * val M = MonadState[StateT[List, ?, ?], Int]
+  * val M = MonadState[StateT[List, Int, ?], Int]
   * import M._
   *
   * for {
@@ -16,16 +16,16 @@ package cats
   * } yield r
   * }}}
   */
-trait MonadState[F[_, _], S] extends Monad[F[S, ?]] {
-  def get: F[S, S]
+trait MonadState[F[_], S] extends Monad[F] {
+  def get: F[S]
 
-  def set(s: S): F[S, Unit]
+  def set(s: S): F[Unit]
 
-  def modify(f: S => S): F[S, Unit] = flatMap(get)(s => set(f(s)))
+  def modify(f: S => S): F[Unit] = flatMap(get)(s => set(f(s)))
 
-  def inspect[A](f: S => A): F[S, A] = map(get)(f)
+  def inspect[A](f: S => A): F[A] = map(get)(f)
 }
 
 object MonadState {
-  def apply[F[_, _], S](implicit F: MonadState[F, S]): MonadState[F, S] = F
+  def apply[F[_], S](implicit F: MonadState[F, S]): MonadState[F, S] = F
 }

laws/src/main/scala/cats/laws/MonadStateLaws.scala

@@ -2,23 +2,23 @@ package cats
 package laws
 
 // Taken from http://functorial.com/psc-pages/docs/Control/Monad/State/Class/index.html
-trait MonadStateLaws[F[_, _], S] extends MonadLaws[F[S, ?]] {
+trait MonadStateLaws[F[_], S] extends MonadLaws[F] {
   implicit override def F: MonadState[F, S]
 
-  val monadStateGetIdempotent: IsEq[F[S, S]] =
+  val monadStateGetIdempotent: IsEq[F[S]] =
     F.flatMap(F.get)(_ => F.get) <-> F.get
 
-  def monadStateSetTwice(s: S, t: S): IsEq[F[S, Unit]] =
+  def monadStateSetTwice(s: S, t: S): IsEq[F[Unit]] =
     F.flatMap(F.set(s))(_ => F.set(t)) <-> F.set(t)
 
-  def monadStateSetGet(s: S): IsEq[F[S, S]] =
+  def monadStateSetGet(s: S): IsEq[F[S]] =
     F.flatMap(F.set(s))(_ => F.get) <-> F.flatMap(F.set(s))(_ => F.pure(s))
 
-  val monadStateGetSet: IsEq[F[S, Unit]] =
+  val monadStateGetSet: IsEq[F[Unit]] =
     F.flatMap(F.get)(F.set) <-> F.pure(())
 }
 
 object MonadStateLaws {
-  def apply[F[_, _], S](implicit FS: MonadState[F, S]): MonadStateLaws[F, S] =
+  def apply[F[_], S](implicit FS: MonadState[F, S]): MonadStateLaws[F, S] =
     new MonadStateLaws[F, S] { def F: MonadState[F, S] = FS }
 }

laws/src/main/scala/cats/laws/discipline/Eq.scala

@@ -41,4 +41,8 @@ object eq {
       eqSA.eqv(f, g) && eqA.eqv(f.empty, g.empty)
     }
   }
+
+  implicit val unitEq: Eq[Unit] = new Eq[Unit] {
+    def eqv(a: Unit, b: Unit): Boolean = true
+  }
 }

laws/src/main/scala/cats/laws/discipline/MonadStateTests.scala

@@ -2,26 +2,27 @@ package cats
 package laws
 package discipline
 
+import eq.unitEq
 import org.scalacheck.{Arbitrary, Prop}
 import org.scalacheck.Prop.forAll
 
-trait MonadStateTests[F[_, _], S] extends MonadTests[F[S, ?]] {
+trait MonadStateTests[F[_], S] extends MonadTests[F] {
   def laws: MonadStateLaws[F, S]
 
-  implicit def arbitraryK: ArbitraryK[F[S, ?]]
-  implicit def eqK: EqK[F[S, ?]]
+  implicit def arbitraryK: ArbitraryK[F]
+  implicit def eqK: EqK[F]
 
   def monadState[A: Arbitrary: Eq, B: Arbitrary: Eq, C: Arbitrary: Eq](implicit
-    ArbF: ArbitraryK[F[S, ?]],
-    EqFA: Eq[F[S, A]],
-    EqFB: Eq[F[S, B]],
-    EqFC: Eq[F[S, C]],
-    EqFS: Eq[F[S, S]],
-    EqFU: Eq[F[S, Unit]],
+    EqS: Eq[S],
     ArbS: Arbitrary[S]
   ): RuleSet = {
-    implicit def ArbFEA: Arbitrary[F[S, A]] = ArbF.synthesize[A]
-    implicit def ArbFEB: Arbitrary[F[S, B]] = ArbF.synthesize[B]
+    implicit def ArbFEA: Arbitrary[F[A]] = arbitraryK.synthesize[A]
+    implicit def ArbFEB: Arbitrary[F[B]] = arbitraryK.synthesize[B]
+    implicit def EqFA: Eq[F[A]] = eqK.synthesize[A]
+    implicit def EqFB: Eq[F[B]] = eqK.synthesize[B]
+    implicit def EqFC: Eq[F[C]] = eqK.synthesize[C]
+    implicit def EqFS: Eq[F[S]] = eqK.synthesize[S]
+    implicit def EqFUnit: Eq[F[Unit]] = eqK.synthesize[Unit]
 
     new RuleSet {
       def name: String = "monadState"
@@ -38,10 +39,10 @@ trait MonadStateTests[F[_, _], S] extends MonadTests[F[S, ?]] {
 }
 
 object MonadStateTests {
-  def apply[F[_, _], S](implicit FS: MonadState[F, S], arbKFS: ArbitraryK[F[S, ?]], eqKFS: EqK[F[S, ?]]): MonadStateTests[F, S] =
+  def apply[F[_], S](implicit FS: MonadState[F, S], arbKFS: ArbitraryK[F], eqKFS: EqK[F]): MonadStateTests[F, S] =
     new MonadStateTests[F, S] {
-      def arbitraryK: ArbitraryK[F[S, ?]] = arbKFS
-      def eqK: EqK[F[S, ?]] = eqKFS
+      def arbitraryK: ArbitraryK[F] = arbKFS
+      def eqK: EqK[F] = eqKFS
       def laws: MonadStateLaws[F, S] = MonadStateLaws[F, S]
     }
 }

state/src/main/scala/cats/state/StateT.scala

@@ -99,8 +99,8 @@ object StateT extends StateTInstances {
 }
 
 sealed abstract class StateTInstances extends StateTInstances0 {
-  implicit def stateTMonadState[F[_], S](implicit F: Monad[F]): MonadState[StateT[F, ?, ?], S] =
-    new MonadState[StateT[F, ?, ?], S] {
+  implicit def stateTMonadState[F[_], S](implicit F: Monad[F]): MonadState[StateT[F, S, ?], S] =
+    new MonadState[StateT[F, S, ?], S] {
       def pure[A](a: A): StateT[F, S, A] =
         StateT.pure(a)
 
@@ -117,7 +117,7 @@ sealed abstract class StateTInstances extends StateTInstances0 {
 }
 
 sealed abstract class StateTInstances0 {
-  implicit def stateMonadState[S]: MonadState[State[?, ?], S] =
+  implicit def stateMonadState[S]: MonadState[State[S, ?], S] =
     StateT.stateTMonadState[Trampoline, S]
 }
 

state/src/test/scala/cats/state/StateTTests.scala

@@ -39,8 +39,8 @@ class StateTTests extends CatsSuite {
     }
   })
 
-  checkAll("StateT[Option, Int, Int]", MonadStateTests[StateT[Option, ?, ?], Int].monadState[Int, Int, Int])
-  checkAll("MonadState[StateT[Option, ?, ?], Int]", SerializableTests.serializable(MonadState[StateT[Option, ?, ?], Int]))
+  checkAll("StateT[Option, Int, Int]", MonadStateTests[StateT[Option, Int, ?], Int].monadState[Int, Int, Int])
+  checkAll("MonadState[StateT[Option, ?, ?], Int]", SerializableTests.serializable(MonadState[StateT[Option, Int, ?], Int]))
 }
 
 object StateTTests {