object Parallel extends ParallelArityFunctions2 with Serializable
- Source
- Parallel.scala
- Grouped
- Alphabetic
- By Inheritance
- Parallel
- Serializable
- ParallelArityFunctions2
- ParallelArityFunctions
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- 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 aParallel.Aux[M, F]
and aMonadError[M, E]
instance.Provides an
ApplicativeError[F, E]
instance for any F, that has aParallel.Aux[M, F]
and aMonadError[M, E]
instance. I.e. if you have a type M[_], that supports parallel composition through type F[_], then you can getApplicativeError[F, E]
fromMonadError[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(classOf[java.lang.CloneNotSupportedException]) @native()
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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 givingParallel
instances to types that do not support parallel composition, but are required to have an instance ofParallel
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()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- 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.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 parReduceMapA[T[_], M[_], A, B](ta: T[A])(f: (A) => M[B])(implicit T: Reducible[T], P: NonEmptyParallel[M], B: Semigroup[B]): M[B]
Like
Reducible[A].reduceMapA
, but uses the apply instance corresponding to theNonEmptyParallel
instance instead. - def parReplicateA[M[_], A](n: Int, ma: M[A])(implicit P: Parallel[M]): M[List[A]]
Like
Applicative[F].replicateA
, but uses the apply instance corresponding to the Parallel instance instead. - def parReplicateA_[M[_], A](n: Int, ma: M[A])(implicit P: Parallel[M]): M[Unit]
Like
Applicative[F].replicateA_
, but uses the apply 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.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.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(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Inherited from Serializable
Inherited from ParallelArityFunctions2
Inherited from ParallelArityFunctions
Inherited from AnyRef
Inherited from Any
Ungrouped
parMap arity
Higher-arity parMap methods
parTuple arity
Higher-arity parTuple methods