Packages

object Parallel extends ParallelArityFunctions2 with Serializable

Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. Parallel
  2. Serializable
  3. Serializable
  4. ParallelArityFunctions2
  5. ParallelArityFunctions
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type Aux[M[_], F0[_]] = Parallel[M] { type F[x] = F0[x] }

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. 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].

  5. def apply[M[_]](implicit P: Parallel[M], D: DummyImplicit): Aux[M, Parallel.F]
  6. def apply[M[_], F[_]](implicit P: Aux[M, F]): Aux[M, F]
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  9. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  10. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  11. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  12. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  13. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  14. 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.

  15. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  16. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  17. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  18. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  19. 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.

  20. 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.

  21. 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.

  22. 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.

  23. 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))
  24. 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.

  25. 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.

  26. 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.

  27. 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.

  28. 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.

  29. 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
  30. 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
  31. 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
  32. 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
  33. 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
  34. 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
  35. 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
  36. 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
  37. 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
  38. 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
  39. 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
  40. 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
  41. 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
  42. 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
  43. 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
  44. 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
  45. 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
  46. 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
  47. 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
  48. 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
  49. 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
  50. 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.

  51. 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.

  52. 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.

  53. 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.

  54. 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.

  55. 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.

  56. 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.

  57. 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.

  58. 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!))
  59. 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.

  60. 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.

  61. 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))
  62. 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.

  63. 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
  64. 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
  65. 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
  66. 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
  67. 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
  68. 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
  69. 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
  70. 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
  71. 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
  72. 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
  73. def parTuple2[M[_], A0, A1](m0: M[A0], m1: M[A1])(implicit p: NonEmptyParallel[M]): M[(A0, A1)]

    Definition Classes
    ParallelArityFunctions2
  74. 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
  75. 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
  76. 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
  77. 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
  78. 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
  79. 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
  80. 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
  81. 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
  82. 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
  83. 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
  84. 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]]
  85. 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]]
  86. def parUnorderedSequence[T[_], M[_], F[_], A](ta: T[M[A]])(implicit arg0: UnorderedTraverse[T], arg1: CommutativeApplicative[F], P: Aux[M, F]): M[T[A]]
  87. 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]]
  88. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  89. def toString(): String
    Definition Classes
    AnyRef → Any
  90. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  91. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  92. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Inherited from Serializable

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