Add Traverse1 typeclass (#1577)

core/src/main/scala/cats/Traverse1.scala

@@ -0,0 +1,133 @@
+package cats
+
+import cats.data.NonEmptyList
+import simulacrum.typeclass
+
+@typeclass trait Traverse1[F[_]] extends Traverse[F] with Reducible[F] {
+
+  def traverse1[G[_]: Apply, A, B](fa: F[A])(f: A => G[B]): G[F[B]]
+
+  def sequence1[G[_]: Apply, A](fga: F[G[A]]): G[F[A]] =
+    traverse1(fga)(identity)
+
+  def flatTraverse1[G[_], A, B](fa: F[A])(f: A => G[F[B]])(implicit G: Apply[G], F: FlatMap[F]): G[F[B]] =
+    G.map(traverse1(fa)(f))(F.flatten)
+
+  def flatSequence[G[_], A](fgfa: F[G[F[A]]])(implicit G: Apply[G], F: FlatMap[F]): G[F[A]] =
+    G.map(traverse1(fgfa)(identity))(F.flatten)
+
+
+  override def traverse[G[_] : Applicative, A, B](fa: F[A])(f: (A) => G[B]): G[F[B]] =
+    traverse1(fa)(f)
+
+  override def sequence[G[_] : Applicative, A](fga: F[G[A]]): G[F[A]] =
+    traverse1(fga)(identity)
+
+
+
+  def traverse1U[A, GB](fa: F[A])(f: A => GB)(implicit G: Unapply[Apply, GB]): G.M[F[G.A]] =
+    traverse1(fa)(G.subst.compose(f))(G.TC)
+
+  def sequenceU1[GA](fga: F[GA])(implicit U: Unapply[Apply, GA]): U.M[F[U.A]] =
+    traverse1(fga)(U.subst)(U.TC)
+
+  override def reduceMap[A, B](fa: F[A])(f: (A) => B)(implicit B: Semigroup[B]): B =
+    reduceLeft(traverse1[Id, A, B](fa)(f))(B.combine)
+
+  override def map[A, B](fa: F[A])(f: A => B): F[B] =
+    traverse1[Id, A, B](fa)(f)
+
+}
+
+/**
+  * This class defines a `Reducible[F]` in terms of a `Foldable[G]`
+  * together with a `split` method, `F[A]` => `(A, G[A])`.
+  *
+  * This class can be used on any type where the first value (`A`) and
+  * the "rest" of the values (`G[A]`) can be easily found.
+  */
+abstract class NonEmptyTraverse1[F[_], G[_]](implicit G: Foldable[G] with Traverse[G]) extends Traverse1[F] {
+  def split[A](fa: F[A]): (A, G[A])
+
+  def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) => B): B = {
+    val (a, ga) = split(fa)
+    G.foldLeft(ga, f(b, a))(f)
+  }
+
+  def foldRight[A, B](fa: F[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
+    Always(split(fa)).flatMap { case (a, ga) =>
+      f(a, G.foldRight(ga, lb)(f))
+    }
+
+  def reduceLeftTo[A, B](fa: F[A])(f: A => B)(g: (B, A) => B): B = {
+    val (a, ga) = split(fa)
+    G.foldLeft(ga, f(a))((b, a) => g(b, a))
+  }
+
+  def reduceRightTo[A, B](fa: F[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[B] =
+    Always(split(fa)).flatMap { case (a, ga) =>
+      G.reduceRightToOption(ga)(f)(g).flatMap {
+        case Some(b) => g(a, Now(b))
+        case None => Later(f(a))
+      }
+    }
+
+  override def size[A](fa: F[A]): Long = {
+    val (_, tail) = split(fa)
+    1 + G.size(tail)
+  }
+
+  override def fold[A](fa: F[A])(implicit A: Monoid[A]): A = {
+    val (a, ga) = split(fa)
+    A.combine(a, G.fold(ga))
+  }
+
+  override def foldM[H[_], A, B](fa: F[A], z: B)(f: (B, A) => H[B])(implicit H: Monad[H]): H[B] = {
+    val (a, ga) = split(fa)
+    H.flatMap(f(z, a))(G.foldM(ga, _)(f))
+  }
+
+  override def find[A](fa: F[A])(f: A => Boolean): Option[A] = {
+    val (a, ga) = split(fa)
+    if (f(a)) Some(a) else G.find(ga)(f)
+  }
+
+  override def exists[A](fa: F[A])(p: A => Boolean): Boolean = {
+    val (a, ga) = split(fa)
+    p(a) || G.exists(ga)(p)
+  }
+
+  override def forall[A](fa: F[A])(p: A => Boolean): Boolean = {
+    val (a, ga) = split(fa)
+    p(a) && G.forall(ga)(p)
+  }
+
+  override def toList[A](fa: F[A]): List[A] = {
+    val (a, ga) = split(fa)
+    a :: G.toList(ga)
+  }
+
+  override def toNonEmptyList[A](fa: F[A]): NonEmptyList[A] = {
+    val (a, ga) = split(fa)
+    NonEmptyList(a, G.toList(ga))
+  }
+
+  override def filter_[A](fa: F[A])(p: A => Boolean): List[A] = {
+    val (a, ga) = split(fa)
+    val filteredTail = G.filter_(ga)(p)
+    if (p(a)) a :: filteredTail else filteredTail
+  }
+
+  override def takeWhile_[A](fa: F[A])(p: A => Boolean): List[A] = {
+    val (a, ga) = split(fa)
+    if (p(a)) a :: G.takeWhile_(ga)(p) else Nil
+  }
+
+  override def dropWhile_[A](fa: F[A])(p: A => Boolean): List[A] = {
+    val (a, ga) = split(fa)
+    if (p(a)) G.dropWhile_(ga)(p) else a :: G.toList(ga)
+  }
+
+
+
+}

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

@@ -3,6 +3,8 @@ package data
 
 import cats.instances.list._
 import cats.syntax.order._
+import cats.syntax.semigroup._
+import cats.syntax.cartesian._
 
 import scala.annotation.tailrec
 import scala.collection.immutable.TreeSet
@@ -323,9 +325,9 @@ object NonEmptyList extends NonEmptyListInstances {
 private[data] sealed trait NonEmptyListInstances extends NonEmptyListInstances0 {
 
   implicit val catsDataInstancesForNonEmptyList: SemigroupK[NonEmptyList] with Reducible[NonEmptyList]
-      with Comonad[NonEmptyList] with Traverse[NonEmptyList] with Monad[NonEmptyList] =
+      with Comonad[NonEmptyList] with Traverse1[NonEmptyList] with Monad[NonEmptyList] =
     new NonEmptyReducible[NonEmptyList, List] with SemigroupK[NonEmptyList] with Comonad[NonEmptyList]
-      with Traverse[NonEmptyList] with Monad[NonEmptyList] {
+      with Traverse1[NonEmptyList] with Monad[NonEmptyList] {
 
       def combineK[A](a: NonEmptyList[A], b: NonEmptyList[A]): NonEmptyList[A] =
         a concat b
@@ -352,7 +354,12 @@ private[data] sealed trait NonEmptyListInstances extends NonEmptyListInstances0
 
       def extract[A](fa: NonEmptyList[A]): A = fa.head
 
-      def traverse[G[_], A, B](fa: NonEmptyList[A])(f: A => G[B])(implicit G: Applicative[G]): G[NonEmptyList[B]] =
+      def traverse1[G[_] : Apply, A, B](as: NonEmptyList[A])(f: A => G[B]): G[NonEmptyList[B]] = {
+        as.map(a => Apply[G].map(f(a))(NonEmptyList.of(_)))
+          .reduceLeft((acc, a) => (acc |@| a).map( _ |+| _ ))
+      }
+
+      override def traverse[G[_], A, B](fa: NonEmptyList[A])(f: A => G[B])(implicit G: Applicative[G]): G[NonEmptyList[B]] =
         fa traverse f
 
       override def foldLeft[A, B](fa: NonEmptyList[A], b: B)(f: (B, A) => B): B =

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

@@ -54,6 +54,10 @@ final case class OneAnd[F[_], A](head: A, tail: F[A]) {
   def forall(p: A => Boolean)(implicit F: Foldable[F]): Boolean =
     p(head) && F.forall(tail)(p)
 
+
+  def reduceLeft(f: (A, A) => A)(implicit F: Foldable[F]): A =
+    F.foldLeft(tail, head)(f)
+
   /**
    * Left-associative fold on the structure using f.
    */
@@ -202,10 +206,22 @@ private[data] trait OneAndLowPriority1 extends OneAndLowPriority0 {
 }
 
 private[data] trait OneAndLowPriority2 extends OneAndLowPriority1 {
-  implicit def catsDataTraverseForOneAnd[F[_]](implicit F: Traverse[F]): Traverse[OneAnd[F, ?]] =
-    new Traverse[OneAnd[F, ?]] {
-      def traverse[G[_], A, B](fa: OneAnd[F, A])(f: (A) => G[B])(implicit G: Applicative[G]): G[OneAnd[F, B]] = {
-        G.map2Eval(f(fa.head), Always(F.traverse(fa.tail)(f)))(OneAnd(_, _)).value
+  implicit def catsDataTraverseForOneAnd[F[_]](implicit F: Traverse[F], F2: MonadCombine[F]): Traverse1[OneAnd[F, ?]] =
+    new Traverse1[OneAnd[F, ?]] {
+
+      override def traverse1[G[_], A, B](fa: OneAnd[F, A])(f: (A) => G[B])(implicit G: Apply[G]): G[OneAnd[F, B]] = {
+        import cats.syntax.cartesian._
+
+         fa.map(a => Apply[G].map(f(a))(OneAnd(_, F2.empty[B])))(F)
+           .reduceLeft(((acc, a) => (acc |@| a).map((x: OneAnd[F, B], y: OneAnd[F, B]) => x.combine(y))))
+      }
+
+      def reduceLeftTo[A, B](fa: OneAnd[F, A])(f: A => B)(g: (B, A) => B): B = {
+        fa.foldLeft(f(fa.head))(g)
+      }
+
+      def reduceRightTo[A, B](fa: OneAnd[F, A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[B] = {
+        fa.foldRight(Always(f(fa.head)))(g)
       }
 
       def foldLeft[A, B](fa: OneAnd[F, A], b: B)(f: (B, A) => B): B = {

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

@@ -32,8 +32,8 @@ package object cats {
  * encodes pure unary function application.
  */
   type Id[A] = A
-  implicit val catsInstancesForId: Bimonad[Id] with Monad[Id] with Traverse[Id] with Reducible[Id] =
-    new Bimonad[Id] with Monad[Id] with Traverse[Id] with Reducible[Id] {
+  implicit val catsInstancesForId: Bimonad[Id] with Monad[Id] with Traverse1[Id] =
+    new Bimonad[Id] with Monad[Id] with Traverse1[Id] {
       def pure[A](a: A): A = a
       def extract[A](a: A): A = a
       def flatMap[A, B](a: A)(f: A => B): B = f(a)
@@ -51,7 +51,7 @@ package object cats {
       def foldLeft[A, B](a: A, b: B)(f: (B, A) => B) = f(b, a)
       def foldRight[A, B](a: A, lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
         f(a, lb)
-      def traverse[G[_], A, B](a: A)(f: A => G[B])(implicit G: Applicative[G]): G[B] =
+      def traverse1[G[_], A, B](a: A)(f: A => G[B])(implicit G: Apply[G]): G[B] =
         f(a)
       override def foldMap[A, B](fa: Id[A])(f: A => B)(implicit B: Monoid[B]): B = f(fa)
       override def reduce[A](fa: Id[A])(implicit A: Semigroup[A]): A =

core/src/main/scala/cats/syntax/all.scala

@@ -42,6 +42,7 @@ trait AllSyntax
     with TransLiftSyntax
     with TraverseFilterSyntax
     with TraverseSyntax
+    with Traverse1Syntax
     with TupleSyntax
     with ValidatedSyntax
     with VectorSyntax

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

@@ -41,6 +41,7 @@ package object syntax {
   object strong extends StrongSyntax
   object transLift extends TransLiftSyntax
   object traverse extends TraverseSyntax
+  object traverse1 extends Traverse1Syntax
   object traverseFilter extends TraverseFilterSyntax
   object tuple extends TupleSyntax
   object validated extends ValidatedSyntax

core/src/main/scala/cats/syntax/reducible.scala

@@ -1,11 +1,12 @@
 package cats
 package syntax
 
-trait ReducibleSyntax extends Reducible.ToReducibleOps {
-  implicit final def catsSyntaxNestedReducible[F[_]: Reducible, G[_], A](fga: F[G[A]]): NestedReducibleOps[F, G, A] =
-    new NestedReducibleOps[F, G, A](fga)
+private[syntax] trait ReducibleSyntax1 {
+  implicit def catsSyntaxUReducible[FA](fa: FA)(implicit U: Unapply[Reducible, FA]): Reducible.Ops[U.M, U.A] =
+    new Reducible.Ops[U.M, U.A] {
+      val self = U.subst(fa)
+      val typeClassInstance = U.TC
+    }
 }
 
-final class NestedReducibleOps[F[_], G[_], A](val fga: F[G[A]]) extends AnyVal {
-  def reduceK(implicit F: Reducible[F], G: SemigroupK[G]): G[A] = F.reduceK(fga)
-}
+trait ReducibleSyntax extends Reducible.ToReducibleOps with ReducibleSyntax1

core/src/main/scala/cats/syntax/traverse1.scala

@@ -0,0 +1,19 @@
+package cats
+package syntax
+
+private[syntax] trait Traverse1Syntax1 {
+  implicit def catsSyntaxUTraverse1[FA](fa: FA)(implicit U: Unapply[Traverse1, FA]): Traverse1.Ops[U.M, U.A] =
+    new Traverse1.Ops[U.M, U.A] {
+      val self = U.subst(fa)
+      val typeClassInstance = U.TC
+    }
+}
+
+trait Traverse1Syntax extends Traverse1.ToTraverse1Ops with Traverse1Syntax1 {
+  implicit def catsSyntaxNestedTraverse1[F[_]: Traverse1, G[_], A](fga: F[G[A]]): NestedTraverse1Ops[F, G, A] =
+    new NestedTraverse1Ops[F, G, A](fga)
+}
+
+final class NestedTraverse1Ops[F[_], G[_], A](fga: F[G[A]])(implicit F: Traverse1[F]) {
+  def reduceK(implicit G: SemigroupK[G]): G[A] = F.reduceK(fga)
+}

docs/src/main/tut/typeclasses/typeclasses.md

@@ -267,6 +267,8 @@ type class instances easy.
     Foldable -> Traverse
     Functor -> Traverse
     Foldable -> Reducible
+    Reducible -> Traverse1
+    Traverse -> Traverse1
   }
 )
 

laws/src/main/scala/cats/laws/Traverse1Laws.scala

@@ -0,0 +1,73 @@
+package cats.laws
+
+
+import cats.{Apply, Id, Semigroup, Traverse1}
+import cats.data.{Const, Nested}
+import cats.syntax.traverse1._
+import cats.syntax.reducible._
+
+trait Traverse1Laws[F[_]] extends TraverseLaws[F] with ReducibleLaws[F] {
+  implicit override def F: Traverse1[F]
+
+  def traverse1Identity[A, B](fa: F[A], f: A => B): IsEq[F[B]] = {
+    fa.traverse1[Id, B](f) <-> F.map(fa)(f)
+  }
+
+  def traverse1SequentialComposition[A, B, C, M[_], N[_]](
+                                                          fa: F[A],
+                                                          f: A => M[B],
+                                                          g: B => N[C]
+                                                        )(implicit
+                                                          N: Apply[N],
+                                                          M: Apply[M]
+                                                        ): IsEq[Nested[M, N, F[C]]] = {
+
+    val lhs = Nested(M.map(fa.traverse1(f))(fb => fb.traverse1(g)))
+    val rhs = fa.traverse1[Nested[M, N, ?], C](a => Nested(M.map(f(a))(g)))
+    lhs <-> rhs
+  }
+
+  def traverse1ParallelComposition[A, B, M[_], N[_]](
+                                                     fa: F[A],
+                                                     f: A => M[B],
+                                                     g: A => N[B]
+                                                   )(implicit
+                                                     N: Apply[N],
+                                                     M: Apply[M]
+                                                   ): IsEq[(M[F[B]], N[F[B]])] = {
+    type MN[Z] = (M[Z], N[Z])
+    implicit val MN = new Apply[MN] {
+      def ap[X, Y](f: MN[X => Y])(fa: MN[X]): MN[Y] = {
+        val (fam, fan) = fa
+        val (fm, fn) = f
+        (M.ap(fm)(fam), N.ap(fn)(fan))
+      }
+      override def map[X, Y](fx: MN[X])(f: X => Y): MN[Y] = {
+        val (mx, nx) = fx
+        (M.map(mx)(f), N.map(nx)(f))
+      }
+      override def product[X, Y](fx: MN[X], fy: MN[Y]): MN[(X, Y)] = {
+        val (mx, nx) = fx
+        val (my, ny) = fy
+        (M.product(mx, my), N.product(nx, ny))
+      }
+    }
+    val lhs: MN[F[B]] = fa.traverse1[MN, B](a => (f(a), g(a)))
+    val rhs: MN[F[B]] = (fa.traverse1(f), fa.traverse1(g))
+    lhs <-> rhs
+  }
+
+  def reduceMapDerived[A, B](
+                            fa: F[A],
+                            f: A => B
+                          )(implicit B: Semigroup[B]): IsEq[B] = {
+    val lhs: B = fa.traverse1[Const[B, ?], B](a => Const(f(a))).getConst
+    val rhs: B = fa.reduceMap(f)
+    lhs <-> rhs
+  }
+}
+
+object Traverse1Laws {
+  def apply[F[_]](implicit ev: Traverse1[F]): Traverse1Laws[F] =
+    new Traverse1Laws[F] { def F: Traverse1[F] = ev }
+}