final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def applicativeError[M[_], E](implicit P: Parallel[M], E: MonadError[M, E]): ApplicativeError[Parallel.F, E]

Provides an ApplicativeError[F, E] instance for any F, that has a Parallel.Aux[M, F] and a MonadError[M, E] instance.

Provides an ApplicativeError[F, E] instance for any F, that has a Parallel.Aux[M, F] and a MonadError[M, E] instance. I.e. if you have a type M[_], that supports parallel composition through type F[_], then you can get ApplicativeError[F, E] from MonadError[M, E].

def apply[M[_]](implicit P: Parallel[M], D: DummyImplicit): Aux[M, Parallel.F]

def apply[M[_], F[_]](implicit P: Aux[M, F]): Aux[M, F]

final def asInstanceOf[T0]: T0

Definition Classes: Any

def clone(): AnyRef

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( ... ) @native() @IntrinsicCandidate()

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native() @IntrinsicCandidate()

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native() @IntrinsicCandidate()

def identity[M[_]](implicit arg0: Monad[M]): Aux[M, M]

A Parallel instance for any type M[_] that supports parallel composition through itself.

A Parallel instance for any type M[_] that supports parallel composition through itself. Can also be used for giving Parallel instances to types that do not support parallel composition, but are required to have an instance of Parallel defined, in which case parallel composition will actually be sequential.

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native() @IntrinsicCandidate()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native() @IntrinsicCandidate()

def parAp[M[_], A, B](mf: M[(A) ⇒ B])(ma: M[A])(implicit P: NonEmptyParallel[M]): M[B]

Like Applicative[F].ap, but uses the applicative instance corresponding to the Parallel instance instead.

def parAp2[M[_], A, B, Z](ff: M[(A, B) ⇒ Z])(ma: M[A], mb: M[B])(implicit P: NonEmptyParallel[M]): M[Z]

Like Applicative[F].ap2, but uses the applicative instance corresponding to the Parallel instance instead.

def parBisequence[T[_, _], M[_], A, B](tmamb: T[M[A], M[B]])(implicit arg0: Bitraverse[T], P: Parallel[M]): M[T[A, B]]

Like Bitraverse[A].bisequence, but uses the applicative instance corresponding to the Parallel instance instead.

def parBitraverse[T[_, _], M[_], A, B, C, D](tab: T[A, B])(f: (A) ⇒ M[C], g: (B) ⇒ M[D])(implicit arg0: Bitraverse[T], P: Parallel[M]): M[T[C, D]]

Like Bitraverse[A].bitraverse, but uses the applicative instance corresponding to the Parallel instance instead.

def parFilterA[T[_], M[_], A](ta: T[A])(f: (A) ⇒ M[Boolean])(implicit T: TraverseFilter[T], P: Parallel[M]): M[T[A]]

Like TraverseFilter#filterA, but uses the applicative instance corresponding to the Parallel instance instead.

Example:

scala> import cats.implicits._
scala> import cats.data._
scala> val list: List[Int] = List(1, 2, 3, 4)
scala> def validate(n: Int): EitherNec[String, Boolean] =
     | if (n > 100) Left(NonEmptyChain.one("Too large"))
     | else Right(n % 3 =!= 0)
scala> list.parFilterA(validate)
res0: EitherNec[String, List[Int]] = Right(List(1, 2, 4))

def parFlatSequence[T[_], M[_], A](tma: T[M[T[A]]])(implicit arg0: Traverse[T], arg1: FlatMap[T], P: Parallel[M]): M[T[A]]

Like Traverse[A].flatSequence, but uses the applicative instance corresponding to the Parallel instance instead.

def parFlatTraverse[T[_], M[_], A, B](ta: T[A])(f: (A) ⇒ M[T[B]])(implicit arg0: Traverse[T], arg1: FlatMap[T], P: Parallel[M]): M[T[B]]

Like Traverse[A].flatTraverse, but uses the applicative instance corresponding to the Parallel instance instead.

def parFoldMapA[T[_], M[_], A, B](ta: T[A])(f: (A) ⇒ M[B])(implicit T: Foldable[T], P: Parallel[M], B: Monoid[B]): M[B]

Like Foldable[A].foldMapA, but uses the applicative instance corresponding to the Parallel instance instead.

def parLeftSequence[T[_, _], M[_], A, B](tmab: T[M[A], B])(implicit arg0: Bitraverse[T], P: Parallel[M]): M[T[A, B]]

Like Bitraverse[A].leftSequence, but uses the applicative instance corresponding to the Parallel instance instead.

def parLeftTraverse[T[_, _], M[_], A, B, C](tab: T[A, B])(f: (A) ⇒ M[C])(implicit arg0: Bitraverse[T], P: Parallel[M]): M[T[C, B]]

Like Bitraverse[A].leftTraverse, but uses the applicative instance corresponding to the Parallel instance instead.

def parMap10[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap11[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap12[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap13[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap14[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap15[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap16[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap17[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap18[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap19[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17], m18: M[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap2[M[_], A0, A1, Z](m0: M[A0], m1: M[A1])(f: (A0, A1) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap20[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17], m18: M[A18], m19: M[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap21[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17], m18: M[A18], m19: M[A19], m20: M[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap22[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17], m18: M[A18], m19: M[A19], m20: M[A20], m21: M[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap3[M[_], A0, A1, A2, Z](m0: M[A0], m1: M[A1], m2: M[A2])(f: (A0, A1, A2) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap4[M[_], A0, A1, A2, A3, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3])(f: (A0, A1, A2, A3) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap5[M[_], A0, A1, A2, A3, A4, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4])(f: (A0, A1, A2, A3, A4) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap6[M[_], A0, A1, A2, A3, A4, A5, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5])(f: (A0, A1, A2, A3, A4, A5) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap7[M[_], A0, A1, A2, A3, A4, A5, A6, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6])(f: (A0, A1, A2, A3, A4, A5, A6) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap8[M[_], A0, A1, A2, A3, A4, A5, A6, A7, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parMap9[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ Z)(implicit p: NonEmptyParallel[M]): M[Z]

Definition Classes: ParallelArityFunctions

def parNonEmptyFlatSequence[T[_], M[_], A](tma: T[M[T[A]]])(implicit arg0: NonEmptyTraverse[T], arg1: FlatMap[T], P: NonEmptyParallel[M]): M[T[A]]

Like NonEmptyTraverse[A].nonEmptyFlatSequence, but uses the apply instance corresponding to the Parallel instance instead.

def parNonEmptyFlatTraverse[T[_], M[_], A, B](ta: T[A])(f: (A) ⇒ M[T[B]])(implicit arg0: NonEmptyTraverse[T], arg1: FlatMap[T], P: NonEmptyParallel[M]): M[T[B]]

Like NonEmptyTraverse[A].nonEmptyFlatTraverse, but uses the apply instance corresponding to the Parallel instance instead.

def parNonEmptySequence[T[_], M[_], A](tma: T[M[A]])(implicit arg0: NonEmptyTraverse[T], P: NonEmptyParallel[M]): M[T[A]]

Like NonEmptyTraverse[A].nonEmptySequence, but uses the apply instance corresponding to the Parallel instance instead.

def parNonEmptySequence_[T[_], M[_], A](tma: T[M[A]])(implicit arg0: Reducible[T], P: NonEmptyParallel[M]): M[Unit]

Like Reducible[A].nonEmptySequence_, but uses the apply instance corresponding to the Parallel instance instead.

def parNonEmptyTraverse[T[_], M[_], A, B](ta: T[A])(f: (A) ⇒ M[B])(implicit arg0: NonEmptyTraverse[T], P: NonEmptyParallel[M]): M[T[B]]

Like NonEmptyTraverse[A].nonEmptyTraverse, but uses the apply instance corresponding to the Parallel instance instead.

def parNonEmptyTraverse_[T[_], M[_], A, B](ta: T[A])(f: (A) ⇒ M[B])(implicit arg0: Reducible[T], P: NonEmptyParallel[M]): M[Unit]

Like Reducible[A].nonEmptyTraverse_, but uses the apply instance corresponding to the Parallel instance instead.

def parProduct[M[_], A, B](ma: M[A], mb: M[B])(implicit P: NonEmptyParallel[M]): M[(A, B)]

Like Applicative[F].product, but uses the applicative instance corresponding to the Parallel instance instead.

def parSequence[T[_], M[_], A](tma: T[M[A]])(implicit arg0: Traverse[T], P: Parallel[M]): M[T[A]]

Like Traverse[A].sequence, but uses the applicative instance corresponding to the Parallel instance instead.

def parSequenceFilter[T[_], M[_], A](ta: T[M[Option[A]]])(implicit T: TraverseFilter[T], P: Parallel[M]): M[T[A]]

Like TraverseFilter#sequenceFilter, but uses the applicative instance corresponding to the Parallel instance instead.

Example:

scala> import cats.implicits._
scala> import cats.data._
scala> val list: List[EitherNec[String, Option[Int]]] = List(Left(NonEmptyChain.one("Error")), Left(NonEmptyChain.one("Warning!")))
scala> list.parSequenceFilter
res0: EitherNec[String, List[Int]] = Left(Chain(Error, Warning!))

def parSequence_[T[_], M[_], A](tma: T[M[A]])(implicit arg0: Foldable[T], P: Parallel[M]): M[Unit]

Like Foldable[A].sequence_, but uses the applicative instance corresponding to the Parallel instance instead.

def parTraverse[T[_], M[_], A, B](ta: T[A])(f: (A) ⇒ M[B])(implicit arg0: Traverse[T], P: Parallel[M]): M[T[B]]

Like Traverse[A].traverse, but uses the applicative instance corresponding to the Parallel instance instead.

def parTraverseFilter[T[_], M[_], A, B](ta: T[A])(f: (A) ⇒ M[Option[B]])(implicit T: TraverseFilter[T], P: Parallel[M]): M[T[B]]

Like TraverseFilter#traverseFilter, but uses the applicative instance corresponding to the Parallel instance instead.

Example:

scala> import cats.implicits._
scala> import cats.data._
scala> val list: List[Int] = List(1, 2, 3, 4)
scala> def validate(n: Int): EitherNec[String, Option[Int]] =
     | if (n > 100) Left(NonEmptyChain.one("Too large"))
     | else if (n % 3 =!= 0) Right(Some(n))
     | else Right(None)
scala> list.parTraverseFilter(validate)
res0: EitherNec[String, List[Int]] = Right(List(1, 2, 4))

def parTraverse_[T[_], M[_], A, B](ta: T[A])(f: (A) ⇒ M[B])(implicit arg0: Foldable[T], P: Parallel[M]): M[Unit]

Like Foldable[A].traverse_, but uses the applicative instance corresponding to the Parallel instance instead.

def parTuple10[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]

Definition Classes: ParallelArityFunctions2

def parTuple11[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]

Definition Classes: ParallelArityFunctions2

def parTuple12[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]

Definition Classes: ParallelArityFunctions2

def parTuple13[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]

Definition Classes: ParallelArityFunctions2

def parTuple14[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]

Definition Classes: ParallelArityFunctions2

def parTuple15[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]

Definition Classes: ParallelArityFunctions2

def parTuple16[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]

Definition Classes: ParallelArityFunctions2

def parTuple17[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]

Definition Classes: ParallelArityFunctions2

def parTuple18[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]

Definition Classes: ParallelArityFunctions2

def parTuple19[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17], m18: M[A18])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]

Definition Classes: ParallelArityFunctions2

def parTuple2[M[_], A0, A1](m0: M[A0], m1: M[A1])(implicit p: NonEmptyParallel[M]): M[(A0, A1)]

Definition Classes: ParallelArityFunctions2

def parTuple20[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17], m18: M[A18], m19: M[A19])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]

Definition Classes: ParallelArityFunctions2

def parTuple21[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17], m18: M[A18], m19: M[A19], m20: M[A20])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]

Definition Classes: ParallelArityFunctions2

def parTuple22[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8], m9: M[A9], m10: M[A10], m11: M[A11], m12: M[A12], m13: M[A13], m14: M[A14], m15: M[A15], m16: M[A16], m17: M[A17], m18: M[A18], m19: M[A19], m20: M[A20], m21: M[A21])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]

Definition Classes: ParallelArityFunctions2

def parTuple3[M[_], A0, A1, A2](m0: M[A0], m1: M[A1], m2: M[A2])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2)]

Definition Classes: ParallelArityFunctions2

def parTuple4[M[_], A0, A1, A2, A3](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3)]

Definition Classes: ParallelArityFunctions2

def parTuple5[M[_], A0, A1, A2, A3, A4](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4)]

Definition Classes: ParallelArityFunctions2

def parTuple6[M[_], A0, A1, A2, A3, A4, A5](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5)]

Definition Classes: ParallelArityFunctions2

def parTuple7[M[_], A0, A1, A2, A3, A4, A5, A6](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6)]

Definition Classes: ParallelArityFunctions2

def parTuple8[M[_], A0, A1, A2, A3, A4, A5, A6, A7](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7)]

Definition Classes: ParallelArityFunctions2

def parTuple9[M[_], A0, A1, A2, A3, A4, A5, A6, A7, A8](m0: M[A0], m1: M[A1], m2: M[A2], m3: M[A3], m4: M[A4], m5: M[A5], m6: M[A6], m7: M[A7], m8: M[A8])(implicit p: NonEmptyParallel[M]): M[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]

Definition Classes: ParallelArityFunctions2

def parUnorderedFlatSequence[T[_], M[_], F[_], A](ta: T[M[T[A]]])(implicit arg0: UnorderedTraverse[T], arg1: FlatMap[T], arg2: CommutativeApplicative[F], P: Aux[M, F]): M[T[A]]

def parUnorderedFlatTraverse[T[_], M[_], F[_], A, B](ta: T[A])(f: (A) ⇒ M[T[B]])(implicit arg0: UnorderedTraverse[T], arg1: FlatMap[T], arg2: CommutativeApplicative[F], P: Aux[M, F]): M[T[B]]

def parUnorderedSequence[T[_], M[_], F[_], A](ta: T[M[A]])(implicit arg0: UnorderedTraverse[T], arg1: CommutativeApplicative[F], P: Aux[M, F]): M[T[A]]

def parUnorderedTraverse[T[_], M[_], F[_], A, B](ta: T[A])(f: (A) ⇒ M[B])(implicit arg0: UnorderedTraverse[T], arg1: CommutativeApplicative[F], P: Aux[M, F]): M[T[B]]

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def toString(): String

Definition Classes: AnyRef → Any

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws( ... ) @native()

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

Packages

Parallel

Companion trait Parallel

object Parallel extends ParallelArityFunctions2 with Serializable

Type Members

Value Members

Deprecated Value Members

Inherited from Serializable

Inherited from Serializable

Inherited from ParallelArityFunctions2

Inherited from ParallelArityFunctions

Inherited from AnyRef

Inherited from Any

Ungrouped

parMap arity

parTuple arity

Packages

Parallel 

Companion trait Parallel

object Parallel extends ParallelArityFunctions2 with Serializable

Type Members

Value Members

Deprecated Value Members

Inherited from Serializable

Inherited from Serializable

Inherited from ParallelArityFunctions2

Inherited from ParallelArityFunctions

Inherited from AnyRef

Inherited from Any

Ungrouped

parMap arity

parTuple arity

Parallel