Add more Parallel instances

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

@@ -0,0 +1,35 @@
+package cats.data
+
+import cats.Applicative
+
+import scala.concurrent.{ExecutionContext, Future, Promise}
+import scala.util.{Failure, Success}
+
+class FailFastFuture[A](val value: Future[A]) extends AnyVal
+
+object FailFastFuture {
+
+  def apply[A](value: Future[A]): FailFastFuture[A] = new FailFastFuture(value)
+
+  def catsDataApplicativeForFailFastFuture(implicit ec: ExecutionContext): Applicative[FailFastFuture] =
+    new Applicative[FailFastFuture] {
+      override def pure[A](x: A): FailFastFuture[A] = FailFastFuture(Future.successful(x))
+
+      override def ap[A, B](ff: FailFastFuture[(A) => B])(fa: FailFastFuture[A]): FailFastFuture[B] = {
+        val p = Promise[B]()
+
+        ff.value.onComplete {
+          case Failure(t) => p.tryFailure(t)
+          case Success(_) => ()
+        }
+
+        fa.value.onComplete {
+          case Failure(t) => p.tryFailure(t)
+          case Success(_) => ()
+        }
+
+        p.tryCompleteWith(ff.value.flatMap(f => fa.value.map(f)))
+        FailFastFuture(p.future)
+      }
+    }
+}

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

@@ -1,6 +1,7 @@
 package cats
 package data
 
+import cats.data.NonEmptyList.ZipNonEmptyList
 import cats.instances.list._
 import cats.syntax.order._
 import scala.annotation.tailrec
@@ -408,6 +409,27 @@ object NonEmptyList extends NonEmptyListInstances {
   def fromReducible[F[_], A](fa: F[A])(implicit F: Reducible[F]): NonEmptyList[A] =
     F.toNonEmptyList(fa)
 
+  class ZipNonEmptyList[A](val value: NonEmptyList[A]) extends AnyVal
+
+  object ZipNonEmptyList {
+
+    def apply[A](nev: NonEmptyList[A]): ZipNonEmptyList[A] =
+      new ZipNonEmptyList(nev)
+
+    implicit val catsDataCommutativeApplyForZipNonEmptyList: CommutativeApply[ZipNonEmptyList] =
+      new CommutativeApply[ZipNonEmptyList] {
+        def ap[A, B](ff: ZipNonEmptyList[A => B])(fa: ZipNonEmptyList[A]): ZipNonEmptyList[B] =
+          ZipNonEmptyList(ff.value.zipWith(fa.value)(_ apply _))
+
+        override def map[A, B](fa: ZipNonEmptyList[A])(f: (A) => B): ZipNonEmptyList[B] =
+          ZipNonEmptyList(fa.value.map(f))
+
+        override def product[A, B](fa: ZipNonEmptyList[A], fb: ZipNonEmptyList[B]): ZipNonEmptyList[(A, B)] =
+          ZipNonEmptyList(fa.value.zipWith(fb.value){ case (a, b) => (a, b) })
+      }
+
+    implicit def zipNelEq[A: Eq]: Eq[ZipNonEmptyList[A]] = Eq.by(_.value)
+  }
 }
 
 private[data] sealed abstract class NonEmptyListInstances extends NonEmptyListInstances0 {
@@ -521,6 +543,20 @@ private[data] sealed abstract class NonEmptyListInstances extends NonEmptyListIn
     new NonEmptyListOrder[A] {
       val A0 = A
     }
+
+  implicit def catsDataNonEmptyParallelForNonEmptyList[A]: NonEmptyParallel[NonEmptyList, ZipNonEmptyList] =
+    new NonEmptyParallel[NonEmptyList, ZipNonEmptyList] {
+
+      def flatMap: FlatMap[NonEmptyList] = NonEmptyList.catsDataInstancesForNonEmptyList
+
+      def apply: Apply[ZipNonEmptyList] = ZipNonEmptyList.catsDataCommutativeApplyForZipNonEmptyList
+
+      def sequential: ZipNonEmptyList ~> NonEmptyList =
+        λ[ZipNonEmptyList ~> NonEmptyList](_.value)
+
+      def parallel: NonEmptyList ~> ZipNonEmptyList =
+        λ[NonEmptyList ~> ZipNonEmptyList](nel => new ZipNonEmptyList(nel))
+    }
 }
 
 private[data] sealed abstract class NonEmptyListInstances0 extends NonEmptyListInstances1 {

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

@@ -1,6 +1,7 @@
 package cats
 package data
 
+import cats.data.NonEmptyVector.ZipNonEmptyVector
 import scala.annotation.tailrec
 import scala.collection.immutable.{TreeSet, VectorBuilder}
 import cats.instances.vector._
@@ -338,6 +339,18 @@ private[data] sealed abstract class NonEmptyVectorInstances {
   implicit def catsDataSemigroupForNonEmptyVector[A]: Semigroup[NonEmptyVector[A]] =
     catsDataInstancesForNonEmptyVector.algebra
 
+  implicit def catsDataParallelForNonEmptyVector[A]: NonEmptyParallel[NonEmptyVector, ZipNonEmptyVector] =
+    new NonEmptyParallel[NonEmptyVector, ZipNonEmptyVector] {
+
+      def apply: Apply[ZipNonEmptyVector] = ZipNonEmptyVector.catsDataCommutativeApplyForZipNonEmptyVector
+      def flatMap: FlatMap[NonEmptyVector] = NonEmptyVector.catsDataInstancesForNonEmptyVector
+
+      def sequential: ZipNonEmptyVector ~> NonEmptyVector =
+        λ[ZipNonEmptyVector ~> NonEmptyVector](_.value)
+
+      def parallel: NonEmptyVector ~> ZipNonEmptyVector =
+        λ[NonEmptyVector ~> ZipNonEmptyVector](nev => new ZipNonEmptyVector(nev))
+    }
 
 }
 
@@ -364,5 +377,25 @@ object NonEmptyVector extends NonEmptyVectorInstances with Serializable {
     if (vector.nonEmpty) new NonEmptyVector(vector)
     else throw new IllegalArgumentException("Cannot create NonEmptyVector from empty vector")
 
+  class ZipNonEmptyVector[A](val value: NonEmptyVector[A]) extends Serializable
+
+  object ZipNonEmptyVector {
+
+    def apply[A](nev: NonEmptyVector[A]): ZipNonEmptyVector[A] =
+      new ZipNonEmptyVector(nev)
 
+    implicit val catsDataCommutativeApplyForZipNonEmptyVector: CommutativeApply[ZipNonEmptyVector] =
+      new CommutativeApply[ZipNonEmptyVector] {
+        def ap[A, B](ff: ZipNonEmptyVector[A => B])(fa: ZipNonEmptyVector[A]): ZipNonEmptyVector[B] =
+          ZipNonEmptyVector(ff.value.zipWith(fa.value)(_ apply _))
+
+        override def map[A, B](fa: ZipNonEmptyVector[A])(f: (A) => B): ZipNonEmptyVector[B] =
+          ZipNonEmptyVector(fa.value.map(f))
+
+        override def product[A, B](fa: ZipNonEmptyVector[A], fb: ZipNonEmptyVector[B]): ZipNonEmptyVector[(A, B)] =
+          ZipNonEmptyVector(fa.value.zipWith(fb.value){ case (a, b) => (a, b) })
+      }
+
+    implicit def zipNevEq[A: Eq]: Eq[ZipNonEmptyVector[A]] = Eq.by(_.value)
+  }
 }

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

@@ -99,8 +99,22 @@ final case class OneAnd[F[_], A](head: A, tail: F[A]) {
 }
 
 
-private[data] sealed abstract class OneAndInstances extends OneAndLowPriority3 {
+private[data] sealed abstract class OneAndInstances extends OneAndLowPriority0 {
 
+  implicit def catsDataParallelForOneAnd[A, M[_] : Alternative, F[_] : Alternative]
+  (implicit P: Parallel[M, F]): Parallel[OneAnd[M, ?], OneAnd[F, ?]] =
+    new Parallel[OneAnd[M, ?], OneAnd[F, ?]] {
+      def monad: Monad[OneAnd[M, ?]] = catsDataMonadForOneAnd(P.monad, Alternative[M])
+
+      def applicative: Applicative[OneAnd[F, ?]] = catsDataApplicativeForOneAnd(Alternative[F])
+
+      def sequential: OneAnd[F, ?] ~> OneAnd[M, ?] =
+        λ[OneAnd[F, ?] ~> OneAnd[M, ?]](ofa => OneAnd(ofa.head, P.sequential(ofa.tail)))
+
+      def parallel: OneAnd[M, ?] ~> OneAnd[F, ?] =
+        λ[OneAnd[M, ?] ~> OneAnd[F, ?]](ofa => OneAnd(ofa.head, P.parallel(ofa.tail)))
+
+    }
 
   implicit def catsDataEqForOneAnd[A, F[_]](implicit A: Eq[A], FA: Eq[F[A]]): Eq[OneAnd[F, A]] =
     new Eq[OneAnd[F, A]]{
@@ -180,7 +194,7 @@ private[data] sealed abstract class OneAndInstances extends OneAndLowPriority3 {
     }
 }
 
-private[data] sealed abstract class OneAndLowPriority0 {
+private[data] sealed abstract class OneAndLowPriority4 {
   implicit val catsDataComonadForNonEmptyStream: Comonad[OneAnd[Stream, ?]] =
     new Comonad[OneAnd[Stream, ?]] {
       def coflatMap[A, B](fa: OneAnd[Stream, A])(f: OneAnd[Stream, A] => B): OneAnd[Stream, B] = {
@@ -201,8 +215,7 @@ private[data] sealed abstract class OneAndLowPriority0 {
     }
 }
 
-
-private[data] sealed abstract class OneAndLowPriority1 extends OneAndLowPriority0 {
+private[data] sealed abstract class OneAndLowPriority3 extends OneAndLowPriority4 {
 
   implicit def catsDataFunctorForOneAnd[F[_]](implicit F: Functor[F]): Functor[OneAnd[F, ?]] =
     new Functor[OneAnd[F, ?]] {
@@ -212,7 +225,27 @@ private[data] sealed abstract class OneAndLowPriority1 extends OneAndLowPriority
 
 }
 
-private[data] sealed abstract class OneAndLowPriority2 extends OneAndLowPriority1 {
+private[data] sealed abstract class OneAndLowPriority2 extends OneAndLowPriority3 {
+
+  implicit def catsDataApplicativeForOneAnd[F[_]](implicit F: Alternative[F]): Applicative[OneAnd[F, ?]] =
+    new Applicative[OneAnd[F, ?]] {
+      override def map[A, B](fa: OneAnd[F, A])(f: A => B): OneAnd[F, B] =
+        fa.map(f)
+
+      def pure[A](x: A): OneAnd[F, A] =
+        OneAnd(x, F.empty)
+
+      override def ap[A, B](ff: OneAnd[F, A => B])(fa: OneAnd[F, A]): OneAnd[F, B] = {
+        val (f, tf) = (ff.head, ff.tail)
+        val (a, ta) = (fa.head, fa.tail)
+        val fb = F.ap(tf)(F.combineK(F.pure(a), ta))
+        OneAnd(f(a), F.combineK(F.map(ta)(f), fb))
+      }
+    }
+
+}
+
+private[data] sealed abstract class OneAndLowPriority1 extends OneAndLowPriority2 {
 
   implicit def catsDataTraverseForOneAnd[F[_]](implicit F: Traverse[F]): Traverse[OneAnd[F, ?]] =
     new Traverse[OneAnd[F, ?]] {
@@ -231,7 +264,7 @@ private[data] sealed abstract class OneAndLowPriority2 extends OneAndLowPriority
 }
 
 
-private[data] sealed abstract class OneAndLowPriority3 extends OneAndLowPriority2 {
+private[data] sealed abstract class OneAndLowPriority0 extends OneAndLowPriority1 {
 
   implicit def catsDataNonEmptyTraverseForOneAnd[F[_]](implicit F: Traverse[F], F2: Alternative[F]): NonEmptyTraverse[OneAnd[F, ?]] =
     new NonEmptyReducible[OneAnd[F, ?], F] with NonEmptyTraverse[OneAnd[F, ?]] {

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

@@ -0,0 +1,26 @@
+package cats.data
+
+import cats.{CommutativeApply, Eq}
+import cats.instances.list.catsKernelStdEqForList
+
+class ZipList[A](val value: List[A]) extends AnyVal
+
+object ZipList {
+
+  def apply[A](value: List[A]): ZipList[A] = new ZipList(value)
+
+  implicit val catsDataCommutativeApplyForZipList: CommutativeApply[ZipList] = new CommutativeApply[ZipList] {
+
+    override def map[A, B](fa: ZipList[A])(f: (A) => B): ZipList[B] =
+      ZipList(fa.value.map(f))
+
+    def ap[A, B](ff: ZipList[A => B])(fa: ZipList[A]): ZipList[B] =
+      ZipList((ff.value, fa.value).zipped.map(_ apply _))
+
+    override def product[A, B](fa: ZipList[A], fb: ZipList[B]): ZipList[(A, B)] =
+      ZipList(fa.value.zip(fb.value))
+
+  }
+
+  implicit def catsDataEqForZipList[A: Eq]: Eq[ZipList[A]] = Eq.by(_.value)
+}

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

@@ -0,0 +1,32 @@
+package cats.data
+
+import cats.{Alternative, CommutativeApplicative, Eq}
+import cats.instances.stream._
+
+class ZipStream[A](val value: Stream[A]) extends AnyVal
+
+object ZipStream {
+
+  def apply[A](value: Stream[A]): ZipStream[A] = new ZipStream(value)
+
+  implicit val catsDataAlternativeForZipStream: Alternative[ZipStream] with CommutativeApplicative[ZipStream] =
+    new Alternative[ZipStream] with CommutativeApplicative[ZipStream] {
+      def pure[A](x: A): ZipStream[A] = new ZipStream(Stream.continually(x))
+
+      override def map[A, B](fa: ZipStream[A])(f: (A) => B): ZipStream[B] =
+        ZipStream(fa.value.map(f))
+
+      def ap[A, B](ff: ZipStream[A => B])(fa: ZipStream[A]): ZipStream[B] =
+        ZipStream((ff.value, fa.value).zipped.map(_ apply _))
+
+      override def product[A, B](fa: ZipStream[A], fb: ZipStream[B]): ZipStream[(A, B)] =
+        ZipStream(fa.value.zip(fb.value))
+
+      def empty[A]: ZipStream[A] = ZipStream(Stream.empty[A])
+
+      def combineK[A](x: ZipStream[A], y: ZipStream[A]): ZipStream[A] =
+        ZipStream(Alternative[Stream].combineK(x.value, y.value))
+    }
+
+  implicit def catsDataEqForZipStream[A: Eq]: Eq[ZipStream[A]] = Eq.by(_.value)
+}

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

@@ -0,0 +1,22 @@
+package cats.data
+
+import cats.{CommutativeApply, Eq}
+import cats.instances.vector._
+
+class ZipVector[A](val value: Vector[A]) extends AnyVal
+
+object ZipVector {
+
+  def apply[A](value: Vector[A]): ZipVector[A] = new ZipVector(value)
+
+  implicit val catsDataCommutativeApplyForZipVector: CommutativeApply[ZipVector] = new CommutativeApply[ZipVector] {
+
+    override def map[A, B](fa: ZipVector[A])(f: (A) => B): ZipVector[B] =
+      ZipVector(fa.value.map(f))
+    def ap[A, B](ff: ZipVector[A => B])(fa: ZipVector[A]): ZipVector[B] =
+      ZipVector((ff.value, fa.value).zipped.map(_ apply _))
+
+  }
+
+  implicit def catsDataEqForZipVector[A: Eq]: Eq[ZipVector[A]] = Eq.by(_.value)
+}

core/src/main/scala/cats/instances/parallel.scala

@@ -3,7 +3,9 @@ package cats.instances
 import cats.data._
 import cats.kernel.Semigroup
 import cats.syntax.either._
-import cats.{Applicative, Functor, Monad, Parallel, ~>}
+import cats.{Applicative, Apply, FlatMap, Functor, Monad, NonEmptyParallel, Parallel, ~>}
+
+import scala.concurrent.{ExecutionContext, Future}
 
 trait ParallelInstances extends ParallelInstances1 {
   implicit def catsParallelForEitherValidated[E: Semigroup]: Parallel[Either[E, ?], Validated[E, ?]] = new Parallel[Either[E, ?], Validated[E, ?]] {
@@ -36,6 +38,58 @@ trait ParallelInstances extends ParallelInstances1 {
       λ[OptionT[M, ?] ~> Nested[F, Option, ?]](optT => Nested(P.parallel(optT.value)))
   }
 
+  implicit def catsStdNonEmptyParallelForZipList[A]: NonEmptyParallel[List, ZipList] =
+    new NonEmptyParallel[List, ZipList] {
+
+      def flatMap: FlatMap[List] = cats.instances.list.catsStdInstancesForList
+      def apply: Apply[ZipList] = ZipList.catsDataCommutativeApplyForZipList
+
+      def sequential: ZipList ~> List =
+        λ[ZipList ~> List](_.value)
+
+      def parallel: List ~> ZipList =
+        λ[List ~> ZipList](v => new ZipList(v))
+    }
+
+  implicit def catsStdNonEmptyParallelForZipVector[A]: NonEmptyParallel[Vector, ZipVector] =
+    new NonEmptyParallel[Vector, ZipVector] {
+
+      def flatMap: FlatMap[Vector] = cats.instances.vector.catsStdInstancesForVector
+      def apply: Apply[ZipVector] = ZipVector.catsDataCommutativeApplyForZipVector
+
+      def sequential: ZipVector ~> Vector =
+        λ[ZipVector ~> Vector](_.value)
+
+      def parallel: Vector ~> ZipVector =
+        λ[Vector ~> ZipVector](v => new ZipVector(v))
+    }
+
+  implicit def catsStdParallelForZipStream[A]: Parallel[Stream, ZipStream] =
+    new Parallel[Stream, ZipStream] {
+
+      def monad: Monad[Stream] = cats.instances.stream.catsStdInstancesForStream
+      def applicative: Applicative[ZipStream] = ZipStream.catsDataAlternativeForZipStream
+
+      def sequential: ZipStream ~> Stream =
+        λ[ZipStream ~> Stream](_.value)
+
+      def parallel: Stream ~> ZipStream =
+        λ[Stream ~> ZipStream](v => new ZipStream(v))
+    }
+
+  implicit def catsStdParallelForFailFastFuture[A](implicit ec: ExecutionContext): Parallel[Future, FailFastFuture] =
+    new Parallel[Future, FailFastFuture] {
+
+      def monad: Monad[Future] = cats.instances.future.catsStdInstancesForFuture
+      def applicative: Applicative[FailFastFuture] = FailFastFuture.catsDataApplicativeForFailFastFuture
+
+      def sequential: FailFastFuture ~> Future =
+        λ[FailFastFuture ~> Future](_.value)
+
+      def parallel: Future ~> FailFastFuture =
+        λ[Future ~> FailFastFuture](f => FailFastFuture(f))
+    }
+
 
   implicit def catsParallelForEitherTNestedParallelValidated[F[_], M[_], E: Semigroup]
   (implicit P: Parallel[M, F]): Parallel[EitherT[M, E, ?], Nested[F, Validated[E, ?], ?]] =