Add WriterT instances for supertypes of Monad

core/src/main/scala/cats/data/WriterT.scala

@@ -8,6 +8,12 @@ final case class WriterT[F[_], L, V](run: F[(L, V)]) {
   def value(implicit functorF: Functor[F]): F[V] =
     functorF.map(run)(_._2)
 
+  def ap[Z](f: WriterT[F, L, V => Z])(implicit F: Apply[F], L: Semigroup[L]): WriterT[F, L, Z] =
+    WriterT(
+      F.map2(f.run, run){
+        case ((l1, fvz), (l2, v)) => (L.combine(l1, l2), fvz(v))
+      })
+
   def map[Z](fn: V => Z)(implicit functorF: Functor[F]): WriterT[F, L, Z] =
     WriterT {
       functorF.map(run) { z => (z._1, fn(z._2)) }
@@ -36,21 +42,102 @@ final case class WriterT[F[_], L, V](run: F[(L, V)]) {
 }
 object WriterT extends WriterTInstances with WriterTFunctions
 
-private[data] sealed abstract class WriterTInstances {
-  implicit def writerTMonad[F[_], L](implicit monadF: Monad[F], monoidL: Monoid[L]): Monad[WriterT[F, L, ?]] = {
-    new Monad[WriterT[F, L, ?]] {
-      override def pure[A](a: A): WriterT[F, L, A] =
-        WriterT.value[F, L, A](a)
+private[data] sealed abstract class WriterTInstances extends WriterTInstances0 {
+
+  implicit def writerTIdMonad[L:Monoid]: Monad[WriterT[Id, L, ?]] =
+    writerTMonad[Id, L]
 
-      override def flatMap[A, B](fa: WriterT[F, L, A])(f: A => WriterT[F, L, B]): WriterT[F, L, B] =
-        fa.flatMap(a => f(a))
+  // The Eq[(L, V)] can be derived from an Eq[L] and Eq[V], but we are waiting
+  // on an algebra release that includes https://github.com/non/algebra/pull/82
+  implicit def writerTIdEq[L, V](implicit E: Eq[(L, V)]): Eq[WriterT[Id, L, V]] =
+    writerTEq[Id, L, V]
+}
+
+private[data] sealed abstract class WriterTInstances0 extends WriterTInstances1 {
+  implicit def writerTMonad[F[_], L](implicit F: Monad[F], L: Monoid[L]): Monad[WriterT[F, L, ?]] =
+    new WriterTMonad[F, L] {
+      implicit val F0: Monad[F] = F
+      implicit val L0: Monoid[L] = L
     }
-  }
+
+  implicit def writerTIdFunctor[L]: Functor[WriterT[Id, L, ?]] =
+    writerTFunctor[Id, L]
+
+  implicit def writerTIdFlatMap[L:Semigroup]: FlatMap[WriterT[Id, L, ?]] =
+    writerTFlatMap[Id, L]
 
   implicit def writerTEq[F[_], L, V](implicit F: Eq[F[(L, V)]]): Eq[WriterT[F, L, V]] =
     F.on(_.run)
 }
 
+private[data] sealed abstract class WriterTInstances1 extends WriterTInstances2 {
+  implicit def writerTApplicative[F[_], L](implicit F: Applicative[F], L: Monoid[L]): Applicative[WriterT[F, L, ?]] =
+    new WriterTApplicative[F, L] {
+      implicit val F0: Applicative[F] = F
+      implicit val L0: Monoid[L] = L
+    }
+}
+private[data] sealed abstract class WriterTInstances2 extends WriterTInstances3 {
+  implicit def writerTFlatMap[F[_], L](implicit F: FlatMap[F], L: Semigroup[L]): FlatMap[WriterT[F, L, ?]] =
+    new WriterTFlatMap[F, L] {
+      implicit val F0: FlatMap[F] = F
+      implicit val L0: Semigroup[L] = L
+    }
+}
+
+private[data] sealed abstract class WriterTInstances3 extends WriterTInstances4 {
+  implicit def writerTApply[F[_], L](implicit F: Apply[F], L: Semigroup[L]): Apply[WriterT[F, L, ?]] =
+    new WriterTApply[F, L] {
+      implicit val F0: Apply[F] = F
+      implicit val L0: Semigroup[L] = L
+    }
+}
+
+private[data] sealed abstract class WriterTInstances4 {
+  implicit def writerTFunctor[F[_], L](implicit F: Functor[F]): Functor[WriterT[F, L, ?]] = new WriterTFunctor[F, L] {
+    implicit val F0: Functor[F] = F
+  }
+}
+
+private[data] sealed trait WriterTFunctor[F[_], L] extends Functor[WriterT[F, L, ?]] {
+  implicit def F0: Functor[F]
+
+  def map[A, B](fa: WriterT[F, L, A])(f: A => B): WriterT[F, L, B] =
+    fa.map(f)
+}
+
+private[data] sealed trait WriterTApply[F[_], L] extends WriterTFunctor[F, L] with Apply[WriterT[F, L, ?]] {
+  override implicit def F0: Apply[F]
+  implicit def L0: Semigroup[L]
+
+  def ap[A, B](fa: WriterT[F, L, A])(f: WriterT[F, L, A => B]): WriterT[F, L, B] =
+    fa ap f
+}
+
+private[data] sealed trait WriterTFlatMap[F[_], L] extends WriterTApply[F, L] with FlatMap[WriterT[F, L, ?]] {
+  override implicit def F0: FlatMap[F]
+  implicit def L0: Semigroup[L]
+
+  def flatMap[A, B](fa: WriterT[F, L, A])(f: A => WriterT[F, L, B]): WriterT[F, L, B] =
+    fa flatMap f
+}
+
+private[data] sealed trait WriterTApplicative[F[_], L] extends WriterTApply[F, L] with Applicative[WriterT[F, L, ?]] {
+  override implicit def F0: Applicative[F]
+  override implicit def L0: Monoid[L]
+
+  def pure[A](a: A): WriterT[F, L, A] =
+    WriterT.value[F, L, A](a)
+}
+
+private[data] sealed trait WriterTMonad[F[_], L] extends WriterTApplicative[F, L] with Monad[WriterT[F, L, ?]] {
+  override implicit def F0: Monad[F]
+  override implicit def L0: Monoid[L]
+
+  def flatMap[A, B](fa: WriterT[F, L, A])(f: A => WriterT[F, L, B]): WriterT[F, L, B] =
+    fa.flatMap(f)
+}
+
 trait WriterTFunctions {
   def putT[F[_], L, V](vf: F[V])(l: L)(implicit functorF: Functor[F]): WriterT[F, L, V] =
     WriterT(functorF.map(vf)(v => (l, v)))

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

@@ -9,7 +9,7 @@ import org.scalacheck.Arbitrary.{arbitrary => getArbitrary}
 /**
  * Arbitrary instances for cats.data
  */
-object arbitrary {
+object arbitrary extends ArbitraryInstances0 {
 
   implicit def constArbitrary[A, B](implicit A: Arbitrary[A]): Arbitrary[Const[A, B]] =
     Arbitrary(A.arbitrary.map(Const[A, B]))
@@ -76,10 +76,15 @@ object arbitrary {
       as <- Gen.listOf(A.arbitrary).map(_.take(8))
     } yield StreamingT.fromList(as))
 
-  implicit def writerTArbitrary[F[_], L, V](implicit F: Arbitrary[F[(L, V)]]): Arbitrary[WriterT[F, L, V]] =
-    Arbitrary(F.arbitrary.map(WriterT(_)))
+  implicit def writerArbitrary[L:Arbitrary, V:Arbitrary]: Arbitrary[Writer[L, V]] =
+    writerTArbitrary[Id, L, V]
 
   // until this is provided by scalacheck
   implicit def partialFunctionArbitrary[A, B](implicit F: Arbitrary[A => Option[B]]): Arbitrary[PartialFunction[A, B]] =
     Arbitrary(F.arbitrary.map(Function.unlift))
 }
+
+private[discipline] sealed trait ArbitraryInstances0 {
+  implicit def writerTArbitrary[F[_], L, V](implicit F: Arbitrary[F[(L, V)]]): Arbitrary[WriterT[F, L, V]] =
+    Arbitrary(F.arbitrary.map(WriterT(_)))
+}

tests/src/test/scala/cats/tests/WriterTTests.scala

@@ -1,33 +1,160 @@
 package cats
 package tests
 
-import cats.data.WriterT
+import cats.data.{Writer, WriterT}
 import cats.laws.discipline._
 import cats.laws.discipline.eq._
 import cats.laws.discipline.arbitrary._
 
+import algebra.laws.OrderLaws
 import org.scalacheck.Prop.forAll
 
 class WriterTTests extends CatsSuite {
-  checkAll("WriterT[List, String, Int]", MonadTests[WriterT[List, String, ?]].monad[String, Int, Int])
+  type Logged[A] = Writer[ListWrapper[Int], A]
+
+  // we have a lot of generated lists of lists in these tests. We have to tell
+  // Scalacheck to calm down a bit so we don't hit memory and test duration
+  // issues.
+  implicit override val generatorDrivenConfig: PropertyCheckConfiguration =
+    PropertyCheckConfig(maxSize = 5, minSuccessful = 20)
+
+  checkAll("WriterT[List, Int, Int]", OrderLaws[WriterT[List, Int, Int]].eqv)
+  checkAll("Eq[WriterT[List, Int, Int]]", SerializableTests.serializable(Eq[WriterT[List, Int, Int]]))
+  // check that this resolves
+  Eq[Writer[Int, Int]]
 
   test("double swap is a noop"){
-    forAll { w: WriterT[List, String, Int] =>
+    forAll { w: WriterT[List, Int, Int] =>
       w.swap.swap should === (w)
     }
   }
 
   test("reset on pure is a noop"){
     forAll { i: Int =>
-      val w = Monad[WriterT[List, String, ?]].pure(i)
+      val w = Monad[WriterT[List, Int, ?]].pure(i)
       w should === (w.reset)
     }
   }
 
   test("reset consistencey"){
-    forAll { (i: Int, w1: WriterT[Id, String, Int], w2: WriterT[Id, String, Int]) =>
+    forAll { (i: Int, w1: WriterT[Id, Int, Int], w2: WriterT[Id, Int, Int]) =>
       // if the value is the same, everything should be the same
       w1.map(_ => i).reset should === (w2.map(_ => i).reset)
     }
   }
+
+  {
+    // F has a Functor and L has no Semigroup
+    implicit val F: Functor[ListWrapper] = ListWrapper.functor
+
+    checkAll("WriterT[ListWrapper, ListWrapper[Int], ?]", FunctorTests[WriterT[ListWrapper, ListWrapper[Int], ?]].functor[Int, Int, Int])
+    checkAll("Functor[WriterT[ListWrapper, ListWrapper[Int], ?]]", SerializableTests.serializable(Functor[WriterT[ListWrapper, ListWrapper[Int], ?]]))
+
+    // just making sure this resolves; it's tested above
+    Functor[WriterT[Id, ListWrapper[Int], ?]]
+
+    Functor[Writer[ListWrapper[Int], ?]]
+
+    Functor[Logged]
+  }
+
+  // We have varying instances available depending on `F` and `L`.
+  // We also battle some inference issues with `Id`.
+  // Below we go through some gymnastics in order to test both the implicit
+  // resolution and the laws of these various instances.
+  {
+    // F has an Apply and L has a Semigroup
+    implicit val F: Apply[ListWrapper] = ListWrapper.monadCombine
+    implicit val L: Semigroup[ListWrapper[Int]] = ListWrapper.semigroupK.algebra[Int]
+
+    Functor[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    checkAll("WriterT[ListWrapper, ListWrapper[Int], ?]", ApplyTests[WriterT[ListWrapper, ListWrapper[Int], ?]].apply[Int, Int, Int])
+    checkAll("Apply[WriterT[ListWrapper, ListWrapper[Int], ?]]", SerializableTests.serializable(Apply[WriterT[ListWrapper, ListWrapper[Int], ?]]))
+
+    Functor[WriterT[Id, ListWrapper[Int], ?]]
+    Apply[WriterT[Id, ListWrapper[Int], ?]]
+
+    Functor[Writer[ListWrapper[Int], ?]]
+    Apply[Writer[ListWrapper[Int], ?]]
+
+    Functor[Logged]
+    Apply[Logged]
+  }
+
+  {
+    // F has a FlatMap and L has a Semigroup
+    implicit val F: FlatMap[ListWrapper] = ListWrapper.monadCombine
+    implicit val L: Semigroup[ListWrapper[Int]] = ListWrapper.semigroupK.algebra[Int]
+
+    Functor[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    Apply[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    checkAll("WriterT[ListWrapper, ListWrapper[Int], ?]", FlatMapTests[WriterT[ListWrapper, ListWrapper[Int], ?]].flatMap[Int, Int, Int])
+    checkAll("FlatMap[WriterT[ListWrapper, ListWrapper[Int], ?]]", SerializableTests.serializable(FlatMap[WriterT[ListWrapper, ListWrapper[Int], ?]]))
+
+    Functor[WriterT[Id, ListWrapper[Int], ?]]
+    Apply[WriterT[Id, ListWrapper[Int], ?]]
+    FlatMap[WriterT[Id, ListWrapper[Int], ?]]
+
+    Functor[Writer[ListWrapper[Int], ?]]
+    Apply[Writer[ListWrapper[Int], ?]]
+    FlatMap[Writer[ListWrapper[Int], ?]]
+
+    Functor[Logged]
+    Apply[Logged]
+    FlatMap[Logged]
+  }
+
+  {
+    // F has an Applicative and L has a Monoid
+    implicit val F: Applicative[ListWrapper] = ListWrapper.monadCombine
+    implicit val L: Monoid[ListWrapper[Int]] = ListWrapper.monadCombine.algebra[Int]
+
+    Functor[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    Apply[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    checkAll("WriterT[ListWrapper, ListWrapper[Int], ?]", ApplicativeTests[WriterT[ListWrapper, ListWrapper[Int], ?]].applicative[Int, Int, Int])
+    checkAll("Applicative[WriterT[ListWrapper, ListWrapper[Int], ?]]", SerializableTests.serializable(Applicative[WriterT[ListWrapper, ListWrapper[Int], ?]]))
+
+    Functor[WriterT[Id, ListWrapper[Int], ?]]
+    Apply[WriterT[Id, ListWrapper[Int], ?]]
+    Applicative[WriterT[Id, ListWrapper[Int], ?]]
+
+    Functor[Writer[ListWrapper[Int], ?]]
+    Apply[Writer[ListWrapper[Int], ?]]
+    Applicative[Writer[ListWrapper[Int], ?]]
+
+    Functor[Logged]
+    Apply[Logged]
+    Applicative[Logged]
+  }
+
+  {
+    // F has a Monad and L has a Monoid
+    implicit val F: Monad[ListWrapper] = ListWrapper.monadCombine
+    implicit val L: Monoid[ListWrapper[Int]] = ListWrapper.monadCombine.algebra[Int]
+
+    Functor[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    Apply[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    Applicative[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    FlatMap[WriterT[ListWrapper, ListWrapper[Int], ?]]
+    checkAll("WriterT[ListWrapper, ListWrapper[Int], ?]", MonadTests[WriterT[ListWrapper, ListWrapper[Int], ?]].monad[Int, Int, Int])
+    checkAll("Monad[WriterT[ListWrapper, ListWrapper[Int], ?]]", SerializableTests.serializable(Monad[WriterT[ListWrapper, ListWrapper[Int], ?]]))
+
+    Functor[WriterT[Id, ListWrapper[Int], ?]]
+    Apply[WriterT[Id, ListWrapper[Int], ?]]
+    Applicative[WriterT[Id, ListWrapper[Int], ?]]
+    FlatMap[WriterT[Id, ListWrapper[Int], ?]]
+    Monad[WriterT[Id, ListWrapper[Int], ?]]
+
+    Functor[Writer[ListWrapper[Int], ?]]
+    Apply[Writer[ListWrapper[Int], ?]]
+    Applicative[Writer[ListWrapper[Int], ?]]
+    FlatMap[Writer[ListWrapper[Int], ?]]
+    Monad[Writer[ListWrapper[Int], ?]]
+
+    Functor[Logged]
+    Apply[Logged]
+    Applicative[Logged]
+    FlatMap[Logged]
+    Monad[Logged]
+  }
 }