Merge pull request #15 from denisrosca/master

Migrate to cats 1.0.0-RC1

core/src/main/scala/cats/mtl/instances/empty.scala

@@ -4,6 +4,8 @@ package instances
 
 import cats.data.{Const, EitherT, Nested, OptionT}
 
+import scala.collection.immutable.SortedMap
+
 object empty extends EmptyInstances
 
 import cats.syntax.functor._
@@ -198,38 +200,63 @@ trait EmptyInstances extends EmptyInstances1 {
     } with NestedTraverseEmpty[F, G]
   }
 
-  implicit def mapTraverseEmpty[K]: TraverseEmpty[MapC[K]#l] = {
-    new TraverseEmpty[MapC[K]#l] {
-      override def traverseFilter[G[_], A, B](fa: Map[K, A])(f: A => G[Option[B]])(implicit G: Applicative[G]): G[Map[K, B]] = {
-        val gba: Eval[G[Map[K, B]]] = Always(G.pure(Map.empty))
-        val gbb = Foldable.iterateRight(fa.iterator, gba) { (kv, lbuf) =>
+  implicit def mapFunctorEmpty[K]: FunctorEmpty[MapC[K]#l] = {
+    new FunctorEmpty[MapC[K]#l] {
+
+      override val functor: Functor[MapC[K]#l] = cats.instances.map.catsStdInstancesForMap[K]
+
+      override def mapFilter[A, B](fa: Map[K, A])(f: A => Option[B]) = {
+        fa.collect(scala.Function.unlift(t => f(t._2).map(t._1 -> _)))
+      }
+
+      override def collect[A, B](fa: Map[K, A])(f: PartialFunction[A, B]) = {
+        fa.collect(scala.Function.unlift(t => f.lift(t._2).map(t._1 -> _)))
+      }
+
+      override def flattenOption[A](fa: Map[K, Option[A]]) = {
+        fa.collect(scala.Function.unlift(t => t._2.map(t._1 -> _)))
+      }
+
+      override def filter[A](fa: Map[K, A])(f: A => Boolean) = {
+        fa.filter { case (_, v) => f(v) }
+      }
+    }
+  }
+
+  implicit def sortedMapTraverseEmpty[K: Order]: TraverseEmpty[SortedMapC[K]#l] = {
+    new TraverseEmpty[SortedMapC[K]#l] {
+
+      implicit val ordering: Ordering[K] = Order[K].toOrdering
+
+      override def traverseFilter[G[_], A, B](fa: SortedMap[K, A])(f: A => G[Option[B]])(implicit G: Applicative[G]): G[SortedMap[K, B]] = {
+        val gba: Eval[G[SortedMap[K, B]]] = Always(G.pure(SortedMap.empty))
+        Foldable.iterateRight(fa, gba) { (kv, lbuf) =>
           G.map2Eval(f(kv._2), lbuf)({ (ob, buf) => ob.fold(buf)(b => buf + (kv._1 -> b)) })
         }.value
-        G.map(gbb)(_.toMap)
       }
 
-      override val traverse: Traverse[MapC[K]#l] = cats.instances.map.catsStdInstancesForMap[K]
-      override val functorEmpty: FunctorEmpty[MapC[K]#l] = new FunctorEmpty[MapC[K]#l] {
-        override val functor: Functor[MapC[K]#l] = traverse
+      override val traverse: Traverse[SortedMapC[K]#l] = cats.instances.sortedMap.catsStdInstancesForSortedMap[K]
+      override val functorEmpty: FunctorEmpty[SortedMapC[K]#l] = new FunctorEmpty[SortedMapC[K]#l] {
+        override val functor: Functor[SortedMapC[K]#l] = traverse
 
-        override def mapFilter[A, B](fa: Map[K, A])(f: (A) => Option[B]): Map[K, B] = {
+        override def mapFilter[A, B](fa: SortedMap[K, A])(f: (A) => Option[B]): SortedMap[K, B] = {
           fa.collect(scala.Function.unlift(t => f(t._2).map(t._1 -> _)))
         }
 
-        override def collect[A, B](fa: Map[K, A])(f: PartialFunction[A, B]): Map[K, B] = {
+        override def collect[A, B](fa: SortedMap[K, A])(f: PartialFunction[A, B]): SortedMap[K, B] = {
           fa.collect(scala.Function.unlift(t => f.lift(t._2).map(t._1 -> _)))
         }
 
-        override def flattenOption[A](fa: Map[K, Option[A]]): Map[K, A] = {
+        override def flattenOption[A](fa: SortedMap[K, Option[A]]): SortedMap[K, A] = {
           fa.collect(scala.Function.unlift(t => t._2.map(t._1 -> _)))
         }
 
-        override def filter[A](fa: Map[K, A])(f: (A) => Boolean): Map[K, A] = {
+        override def filter[A](fa: SortedMap[K, A])(f: (A) => Boolean): SortedMap[K, A] = {
           fa.filter { case (_, v) => f(v) }
         }
       }
 
-      override def filterA[G[_], A](fa: Map[K, A])(f: (A) => G[Boolean])(implicit G: Applicative[G]): G[Map[K, A]] = {
+      override def filterA[G[_], A](fa: SortedMap[K, A])(f: (A) => G[Boolean])(implicit G: Applicative[G]): G[SortedMap[K, A]] = {
         traverseFilter(fa)(a => G.map(f(a))(if (_) Some(a) else None))
       }
     }

core/src/main/scala/cats/mtl/instances/readert.scala

@@ -8,7 +8,7 @@ trait ReaderTInstances extends ReaderTInstances1 {
   implicit def readerFunctorLayerFunctor[M[_], E]
   (implicit M: Functor[M]): FunctorLayerFunctor[ReaderTC[M, E]#l, M] = {
     new FunctorLayerFunctor[ReaderTC[M, E]#l, M] {
-      def layerMapK[A](ma: ReaderT[M, E, A])(trans: M ~> M): ReaderT[M, E, A] = ma.transform(trans)
+      def layerMapK[A](ma: ReaderT[M, E, A])(trans: M ~> M): ReaderT[M, E, A] = ma.mapK(trans)
 
       val outerInstance: Functor[ReaderTC[M, E]#l] = Kleisli.catsDataFunctorForKleisli(M)
       val innerInstance: Functor[M] = M
@@ -22,7 +22,7 @@ trait ReaderTInstances1 extends ReaderTInstances2 {
   implicit def readerApplicativeLayerFunctor[M[_], E]
   (implicit M: Applicative[M]): ApplicativeLayerFunctor[ReaderTC[M, E]#l, M] = {
     new ApplicativeLayerFunctor[ReaderTC[M, E]#l, M] {
-      def layerMapK[A](ma: ReaderT[M, E, A])(trans: M ~> M): ReaderT[M, E, A] = ma.transform(trans)
+      def layerMapK[A](ma: ReaderT[M, E, A])(trans: M ~> M): ReaderT[M, E, A] = ma.mapK(trans)
 
       val outerInstance: Applicative[ReaderTC[M, E]#l] = Kleisli.catsDataApplicativeForKleisli(M)
       val innerInstance: Applicative[M] = M
@@ -43,7 +43,7 @@ trait ReaderTInstances2 {
 
       val innerInstance: Monad[M] = M
 
-      def layerMapK[A](ma: ReaderT[M, E, A])(trans: M ~> M): ReaderT[M, E, A] = ma.transform(trans)
+      def layerMapK[A](ma: ReaderT[M, E, A])(trans: M ~> M): ReaderT[M, E, A] = ma.mapK(trans)
 
       def layer[A](inner: M[A]): ReaderT[M, E, A] = ReaderT.lift(inner)
 

core/src/main/scala/cats/mtl/instances/state.scala

@@ -2,7 +2,7 @@ package cats
 package mtl
 package instances
 
-import data.StateT
+import data.{IndexedStateT, StateT}
 
 trait StateInstances extends StateInstancesLowPriority1 {
   // this dependency on LayerFunctor is required because non-`LayerFunctor`s may not be lawful
@@ -31,7 +31,7 @@ trait StateInstances extends StateInstancesLowPriority1 {
 private[instances] trait StateInstancesLowPriority1 {
   implicit final def stateState[M[_], S](implicit M: Monad[M]): MonadState[StateTC[M, S]#l, S] = {
     new MonadState[StateTC[M, S]#l, S] {
-      val monad: Monad[StateTC[M, S]#l] = StateT.catsDataMonadForStateT
+      val monad: Monad[StateTC[M, S]#l] = IndexedStateT.catsDataMonadForIndexedStateT
 
       def get: StateT[M, S, S] = StateT.get
 

core/src/main/scala/cats/mtl/instances/statet.scala

@@ -2,7 +2,7 @@ package cats
 package mtl
 package instances
 
-import cats.data.StateT
+import cats.data.{IndexedStateT, StateT}
 import cats.syntax.functor._
 
 trait StateTInstances {
@@ -12,7 +12,7 @@ trait StateTInstances {
       type State[A] = (S, A)
 
       val outerInstance: Monad[StateTC[M, S]#l] =
-        StateT.catsDataMonadForStateT
+        IndexedStateT.catsDataMonadForIndexedStateT
 
       val innerInstance: Monad[M] = M
 

core/src/main/scala/cats/mtl/package.scala

@@ -2,6 +2,8 @@ package cats
 
 import cats.data._
 
+import scala.collection.immutable.SortedMap
+
 package object mtl {
 
   private[mtl] type CurryT[T[_[_], _], M[_]] = {type l[A] = T[M, A]}
@@ -25,5 +27,6 @@ package object mtl {
   private[mtl] type of[F[_], G[_]] = {type l[A] = F[G[A]]}
   private[mtl] type NestedC[F[_], G[_]] = {type l[A] = Nested[F, G, A]}
   private[mtl] type MapC[K] = {type l[V] = Map[K, V]}
+  private[mtl] type SortedMapC[K] = {type l[V] = SortedMap[K, V]}
 
 }

laws/src/main/scala/cats/mtl/laws/ApplicativeAskLaws.scala

@@ -2,7 +2,9 @@ package cats
 package mtl
 package laws
 
-import cats.syntax.cartesian._
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
+import cats.syntax.apply._
 import cats.syntax.functor._
 
 trait ApplicativeAskLaws[F[_], E] {
@@ -12,7 +14,7 @@ trait ApplicativeAskLaws[F[_], E] {
 
   // external law:
   def askAddsNoEffects[A](fa: F[A]): IsEq[F[A]] = {
-    (ask *> fa) <-> fa
+    ask *> fa <-> fa
   }
 
   // internal law:

laws/src/main/scala/cats/mtl/laws/ApplicativeLayerLaws.scala

@@ -2,6 +2,8 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
 import cats.syntax.applicative._
 import cats.syntax.apply._
 

laws/src/main/scala/cats/mtl/laws/ApplicativeLocalLaws.scala

@@ -2,6 +2,9 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
+
 trait ApplicativeLocalLaws[F[_], E] extends ApplicativeAskLaws[F, E] {
   implicit val localInstance: ApplicativeLocal[F, E]
 

laws/src/main/scala/cats/mtl/laws/FunctorEmptyLaws.scala

@@ -2,6 +2,9 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
+
 trait FunctorEmptyLaws[F[_]] {
   val functorEmptyInstance: FunctorEmpty[F]
 

laws/src/main/scala/cats/mtl/laws/FunctorLayerFunctorLaws.scala

@@ -2,6 +2,9 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
+
 trait FunctorLayerFunctorLaws[M[_], Inner[_]] extends FunctorLayerLaws[M, Inner] {
   val functorLayerFunctorInstance: FunctorLayerFunctor[M, Inner]
   import functorLayerFunctorInstance._

laws/src/main/scala/cats/mtl/laws/FunctorLayerLaws.scala

@@ -2,6 +2,9 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
+
 trait FunctorLayerLaws[M[_], Inner[_]] {
   implicit val functorLayerInstance: FunctorLayer[M, Inner]
 

laws/src/main/scala/cats/mtl/laws/FunctorListenLaws.scala

@@ -2,12 +2,14 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
 import cats.syntax.functor._
 
 trait FunctorListenLaws[F[_], L] extends FunctorTellLaws[F, L] {
   implicit val listenInstance: FunctorListen[F, L]
-  import listenInstance.{listen, listens}
   import listenInstance.tell._
+  import listenInstance.{listen, listens}
 
   // external laws:
   def listenRespectsTell(l: L): IsEq[F[(Unit, L)]] = {

laws/src/main/scala/cats/mtl/laws/FunctorTellLaws.scala

@@ -2,6 +2,8 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
 import cats.syntax.functor._
 
 trait FunctorTellLaws[F[_], L] {

laws/src/main/scala/cats/mtl/laws/MonadLayerControlLaws.scala

@@ -2,6 +2,9 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
+
 trait MonadLayerControlLaws[M[_], Inner[_], State0[_]] extends MonadLayerFunctorLaws[M, Inner] {
 
   implicit val monadLayerControlInstance: MonadLayerControl.Aux[M, Inner, State0]

laws/src/main/scala/cats/mtl/laws/MonadLayerLaws.scala

@@ -2,6 +2,8 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
 import cats.syntax.flatMap._
 
 trait MonadLayerLaws[M[_], Inner[_]] extends ApplicativeLayerLaws[M, Inner] {

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

@@ -2,9 +2,11 @@ package cats
 package mtl
 package laws
 
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
 import cats.syntax.functor._
 import cats.syntax.flatMap._
-import cats.syntax.cartesian._
+import cats.syntax.apply._
 
 trait MonadStateLaws[F[_], S] {
   implicit val stateInstance: MonadState[F, S]

laws/src/main/scala/cats/mtl/laws/TraverseEmptyLaws.scala

@@ -3,6 +3,8 @@ package mtl
 package laws
 
 import cats.data.Nested
+import cats.laws.IsEq
+import cats.laws.IsEqArrow
 import cats.syntax.all._
 import cats.mtl.syntax.empty._
 

laws/src/main/scala/cats/mtl/laws/discipline/ApplicativeAskTests.scala

@@ -6,6 +6,7 @@ package discipline
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.{Arbitrary, Cogen}
 import org.typelevel.discipline.Laws
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait ApplicativeAskTests[F[_], E] extends Laws {
   implicit val askInstance: ApplicativeAsk[F, E]

laws/src/main/scala/cats/mtl/laws/discipline/ApplicativeLayerTests.scala

@@ -5,6 +5,7 @@ package discipline
 
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.Arbitrary
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait ApplicativeLayerTests[M[_], Inner[_]] extends FunctorLayerTests[M, Inner] {
   implicit val applicativeLayerInstance: ApplicativeLayer[M, Inner]

laws/src/main/scala/cats/mtl/laws/discipline/ApplicativeLocalTests.scala

@@ -5,6 +5,7 @@ package discipline
 
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.{Arbitrary, Cogen}
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait ApplicativeLocalTests[F[_], E] extends ApplicativeAskTests[F, E] {
   implicit val localInstance: ApplicativeLocal[F, E]

laws/src/main/scala/cats/mtl/laws/discipline/FunctorEmptyTests.scala

@@ -6,6 +6,7 @@ package discipline
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.Arbitrary
 import org.typelevel.discipline.Laws
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait FunctorEmptyTests[F[_]] extends Laws {
   implicit val functorEmptyInstance: FunctorEmpty[F]

laws/src/main/scala/cats/mtl/laws/discipline/FunctorLayerFunctorTests.scala

@@ -6,6 +6,7 @@ package discipline
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.Arbitrary
 import org.typelevel.discipline.Laws
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait FunctorLayerFunctorTests[M[_], Inner[_]] extends FunctorLayerTests[M, Inner] {
   implicit val functorLayerFunctorInstance: FunctorLayerFunctor[M, Inner]

laws/src/main/scala/cats/mtl/laws/discipline/FunctorLayerTests.scala

@@ -6,6 +6,7 @@ package discipline
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.Arbitrary
 import org.typelevel.discipline.Laws
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait FunctorLayerTests[M[_], Inner[_]] extends Laws {
   implicit val functorLayer: FunctorLayer[M, Inner]

laws/src/main/scala/cats/mtl/laws/discipline/FunctorListenTests.scala

@@ -6,6 +6,7 @@ package discipline
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.{Arbitrary, Cogen}
 import org.typelevel.discipline.Laws
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait FunctorListenTests[F[_], L] extends FunctorTellTests[F, L] {
   implicit val listenInstance: FunctorListen[F, L]

laws/src/main/scala/cats/mtl/laws/discipline/FunctorTellTests.scala

@@ -6,6 +6,7 @@ package discipline
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.{Arbitrary, Cogen}
 import org.typelevel.discipline.Laws
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait FunctorTellTests[F[_], L] extends Laws {
   implicit val tellInstance: FunctorTell[F, L]

laws/src/main/scala/cats/mtl/laws/discipline/MonadLayerControlTests.scala

@@ -6,6 +6,7 @@ package discipline
 import org.scalacheck.Prop.{forAll => ∀}
 import org.scalacheck.Arbitrary
 import org.typelevel.discipline.Laws
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait MonadLayerControlTests[M[_], Inner[_], State[_]] extends MonadLayerFunctorTests[M, Inner] {
   implicit val monadLayerControlInstance: MonadLayerControl.Aux[M, Inner, State]

laws/src/main/scala/cats/mtl/laws/discipline/MonadLayerFunctorTests.scala

@@ -5,6 +5,7 @@ package discipline
 
 import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.{forAll => ∀}
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait MonadLayerFunctorTests[M[_], Inner[_]] extends MonadLayerTests[M, Inner] with ApplicativeLayerFunctorTests[M, Inner] {
   implicit val monadLayerFunctorInstance: MonadLayerFunctor[M, Inner]

laws/src/main/scala/cats/mtl/laws/discipline/MonadLayerTests.scala

@@ -5,6 +5,7 @@ package discipline
 
 import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.{forAll => ∀}
+import cats.kernel.laws.discipline.catsLawsIsEqToProp
 
 trait MonadLayerTests[M[_], Inner[_]] extends ApplicativeLayerTests[M, Inner] {
   implicit val monadLayerInstance: MonadLayer[M, Inner]