Packages

trait GenTemporal[F[_], E] extends GenConcurrent[F, E] with Clock[F]

A typeclass that encodes the notion of suspending fibers for a given duration. Analogous to Thread.sleep but is only fiber blocking rather than blocking an underlying OS pthread.

Source
GenTemporal.scala
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. GenTemporal
  2. Clock
  3. ClockPlatform
  4. GenConcurrent
  5. GenSpawn
  6. Unique
  7. MonadCancel
  8. MonadError
  9. Monad
  10. FlatMap
  11. FlatMapArityFunctions
  12. ApplicativeError
  13. Applicative
  14. InvariantMonoidal
  15. Apply
  16. ApplyArityFunctions
  17. InvariantSemigroupal
  18. Semigroupal
  19. Functor
  20. Invariant
  21. Serializable
  22. AnyRef
  23. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Abstract Value Members

  1. abstract def canceled: F[Unit]

    An effect that requests self-cancelation on the current fiber.

    An effect that requests self-cancelation on the current fiber.

    canceled has a return type of F[Unit] instead of F[Nothing] due to execution continuing in a masked region. In the following example, the fiber requests self-cancelation in a masked region, so cancelation is suppressed until the fiber is completely unmasked. fa will run but fb will not. If canceled had a return type of F[Nothing], then it would not be possible to continue execution to fa (there would be no Nothing value to pass to the flatMap).

    F.uncancelable { _ =>
      F.canceled *> fa
    } *> fb
    Definition Classes
    MonadCancel
  2. abstract def cede: F[Unit]

    Introduces a fairness boundary that yields control back to the scheduler of the runtime system.

    Introduces a fairness boundary that yields control back to the scheduler of the runtime system. This allows the carrier thread to resume execution of another waiting fiber.

    This function is primarily useful when performing long-running computation that is outside of the monadic context. For example:

    fa.map(data => expensiveWork(data))

    In the above, we're assuming that expensiveWork is a function which is entirely compute-bound but very long-running. A good rule of thumb is to consider a function "expensive" when its runtime is around three or more orders of magnitude higher than the overhead of the map function itself (which runs in around 5 nanoseconds on modern hardware). Thus, any expensiveWork function which requires around 10 microseconds or longer to execute should be considered "long-running".

    The danger is that these types of long-running actions outside of the monadic context can result in degraded fairness properties. The solution is to add an explicit cede both before and after the expensive operation:

    (fa <* F.cede).map(data => expensiveWork(data)).guarantee(F.cede)

    Note that extremely long-running expensiveWork functions can still cause fairness issues, even when used with cede. This problem is somewhat fundamental to the nature of scheduling such computation on carrier threads. Whenever possible, it is best to break apart any such functions into multiple pieces invoked independently (e.g. via chained map calls) whenever the execution time exceeds five or six orders of magnitude beyond the overhead of map itself (around 1 millisecond on most hardware).

    Note that cede is merely a hint to the runtime system; implementations have the liberty to interpret this method to their liking as long as it obeys the respective laws. For example, a lawful, but atypical, implementation of this function is F.unit, in which case the fairness boundary is a no-op.

    Definition Classes
    GenSpawn
  3. abstract def deferred[A]: F[Deferred[F, A]]
    Definition Classes
    GenConcurrent
  4. abstract def flatMap[A, B](fa: F[A])(f: (A) => F[B]): F[B]
    Definition Classes
    FlatMap
  5. abstract def forceR[A, B](fa: F[A])(fb: F[B]): F[B]

    Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

    Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

    Definition Classes
    MonadCancel
  6. abstract def handleErrorWith[A](fa: F[A])(f: (E) => F[A]): F[A]
    Definition Classes
    ApplicativeError
  7. abstract def monotonic: F[FiniteDuration]

    Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

    Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

    Analogous to java.lang.System.nanoTime.

    Definition Classes
    Clock
  8. abstract def never[A]: F[A]

    A non-terminating effect that never completes, which causes a fiber to semantically block indefinitely.

    A non-terminating effect that never completes, which causes a fiber to semantically block indefinitely. This is the purely functional, asynchronous equivalent of an infinite while loop in Java, but no native threads are blocked.

    A fiber that is suspended in never can be canceled if it is completely unmasked before it suspends:

    // ignoring race conditions between `start` and `cancel`
    F.never.start.flatMap(_.cancel) <-> F.unit

    However, if the fiber is masked, cancellers will be semantically blocked forever:

    // ignoring race conditions between `start` and `cancel`
    F.uncancelable(_ => F.never).start.flatMap(_.cancel) <-> F.never
    Definition Classes
    GenSpawn
  9. abstract def onCancel[A](fa: F[A], fin: F[Unit]): F[A]

    Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa.

    Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

    During finalization, all actively registered finalizers are run exactly once. The order by which finalizers are run is dictated by nesting: innermost finalizers are run before outermost finalizers. For example, in the following program, the finalizer f1 is run before the finalizer f2:

    F.onCancel(F.onCancel(F.canceled, f1), f2)

    If a finalizer throws an error during evaluation, the error is suppressed, and implementations may choose to report it via a side channel. Finalizers are always uncancelable, so cannot otherwise be interrupted.

    fa

    The effect that is evaluated after fin is registered.

    fin

    The finalizer to register before evaluating fa.

    Definition Classes
    MonadCancel
  10. abstract def pure[A](x: A): F[A]
    Definition Classes
    Applicative
  11. abstract def raiseError[A](e: E): F[A]
    Definition Classes
    ApplicativeError
  12. abstract def realTime: F[FiniteDuration]

    A representation of the current system time

    A representation of the current system time

    Analogous to java.lang.System.currentTimeMillis.

    Definition Classes
    Clock
  13. abstract def ref[A](a: A): F[Ref[F, A]]
    Definition Classes
    GenConcurrent
  14. abstract def sleep(time: FiniteDuration): F[Unit]
    Attributes
    protected
  15. abstract def start[A](fa: F[A]): F[Fiber[F, E, A]]

    A low-level primitive for starting the concurrent evaluation of a fiber.

    A low-level primitive for starting the concurrent evaluation of a fiber. Returns a Fiber that can be used to wait for a fiber or cancel it.

    start is a cancelation-unsafe function; it is recommended to use the safer variant, background, to spawn fibers.

    fa

    the effect for the fiber

    Definition Classes
    GenSpawn
    See also

    background for the safer, recommended variant

  16. abstract def tailRecM[A, B](a: A)(f: (A) => F[Either[A, B]]): F[B]
    Definition Classes
    FlatMap
  17. abstract def uncancelable[A](body: (Poll[F]) => F[A]): F[A]

    Masks cancelation on the current fiber.

    Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

    In the following example, cancelation can be observed only within fb and nowhere else:

    F.uncancelable { poll =>
      fa *> poll(fb) *> fc
    }

    If a fiber is canceled while it is masked, the cancelation is suppressed for as long as the fiber remains masked. Whenever the fiber is completely unmasked again, the cancelation will be respected.

    Masks can also be stacked or nested within each other. If multiple masks are active, all masks must be undone so that cancelation can be observed. In order to completely unmask within a multi-masked region the poll corresponding to each mask must be applied to the effect, outermost-first.

    F.uncancelable { p1 =>
      F.uncancelable { p2 =>
        fa *> p2(p1(fb)) *> fc
      }
    }

    The following operations are no-ops:

    1. Polling in the wrong order
    2. Subsequent polls when applying the same poll more than once: poll(poll(fa)) is equivalent to poll(fa)
    3. Applying a poll bound to one fiber within another fiber
    body

    A function which takes a Poll and returns the effect that we wish to make uncancelable.

    Definition Classes
    MonadCancel
  18. abstract def unique: F[Token]
    Definition Classes
    Unique

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def *>[A, B](fa: F[A])(fb: F[B]): F[B]
    Definition Classes
    Apply
    Annotations
    @inline()
  4. final def <*[A, B](fa: F[A])(fb: F[B]): F[A]
    Definition Classes
    Apply
    Annotations
    @inline()
  5. final def <*>[A, B](ff: F[(A) => B])(fa: F[A]): F[B]
    Definition Classes
    Apply
    Annotations
    @inline()
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. def adaptError[A](fa: F[A])(pf: PartialFunction[E, E]): F[A]
    Definition Classes
    MonadError → ApplicativeError
  8. def andWait[A](fa: F[A], time: FiniteDuration): F[A]
    Attributes
    protected
  9. def andWait[A](fa: F[A], time: Duration): F[A]

    Wait for the specified duration after the execution of fa before returning the result.

    Wait for the specified duration after the execution of fa before returning the result.

    fa

    The effect to execute

    time

    The duration to wait after executing fa

  10. def ap[A, B](ff: F[(A) => B])(fa: F[A]): F[B]
    Definition Classes
    FlatMap → Apply
  11. def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[Z]
    Definition Classes
    ApplyArityFunctions
  12. def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[Z]
    Definition Classes
    ApplyArityFunctions
  13. def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[Z]
    Definition Classes
    ApplyArityFunctions
  14. def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[Z]
    Definition Classes
    ApplyArityFunctions
  15. def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[Z]
    Definition Classes
    ApplyArityFunctions
  16. def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[Z]
    Definition Classes
    ApplyArityFunctions
  17. def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[Z]
    Definition Classes
    ApplyArityFunctions
  18. def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[Z]
    Definition Classes
    ApplyArityFunctions
  19. def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[Z]
    Definition Classes
    ApplyArityFunctions
  20. def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[Z]
    Definition Classes
    ApplyArityFunctions
  21. def ap2[A, B, Z](ff: F[(A, B) => Z])(fa: F[A], fb: F[B]): F[Z]
    Definition Classes
    FlatMap → Apply
  22. def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[Z]
    Definition Classes
    ApplyArityFunctions
  23. def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[Z]
    Definition Classes
    ApplyArityFunctions
  24. def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[Z]
    Definition Classes
    ApplyArityFunctions
  25. def ap3[A0, A1, A2, Z](f: F[(A0, A1, A2) => Z])(f0: F[A0], f1: F[A1], f2: F[A2]): F[Z]
    Definition Classes
    ApplyArityFunctions
  26. def ap4[A0, A1, A2, A3, Z](f: F[(A0, A1, A2, A3) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[Z]
    Definition Classes
    ApplyArityFunctions
  27. def ap5[A0, A1, A2, A3, A4, Z](f: F[(A0, A1, A2, A3, A4) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[Z]
    Definition Classes
    ApplyArityFunctions
  28. def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[(A0, A1, A2, A3, A4, A5) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[Z]
    Definition Classes
    ApplyArityFunctions
  29. def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[Z]
    Definition Classes
    ApplyArityFunctions
  30. def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[Z]
    Definition Classes
    ApplyArityFunctions
  31. def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[Z]
    Definition Classes
    ApplyArityFunctions
  32. def applicative: Applicative[F]
    Definition Classes
    GenTemporalClockGenSpawnUnique
  33. def as[A, B](fa: F[A], b: B): F[B]
    Definition Classes
    Functor
  34. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  35. def attempt[A](fa: F[A]): F[Either[E, A]]
    Definition Classes
    ApplicativeError
  36. def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: <:<[EE, E]): F[Either[EE, A]]
    Definition Classes
    ApplicativeError
  37. def attemptT[A](fa: F[A]): EitherT[F, E, A]
    Definition Classes
    ApplicativeError
  38. def attemptTap[A, B](fa: F[A])(f: (Either[E, A]) => F[B]): F[A]
    Definition Classes
    MonadError
  39. def background[A](fa: F[A]): Resource[F, F[Outcome[F, E, A]]]

    Returns a Resource that manages the concurrent execution of a fiber.

    Returns a Resource that manages the concurrent execution of a fiber. The inner effect can be used to wait on the outcome of the child fiber; it is effectively a join.

    The child fiber is canceled in two cases: either the resource goes out of scope or the parent fiber is canceled. If the child fiber terminates before one of these cases occurs, then cancelation is a no-op. This avoids fiber leaks because the child fiber is always canceled before the parent fiber drops the reference to it.

    // Starts a fiber that continously prints "A".
    // After 10 seconds, the resource scope exits so the fiber is canceled.
    F.background(F.delay(println("A")).foreverM).use { _ =>
      F.sleep(10.seconds)
    }
    fa

    the effect for the spawned fiber

    Definition Classes
    GenSpawn
  40. def both[A, B](fa: F[A], fb: F[B]): F[(A, B)]

    Races the evaluation of two fibers and returns the result of both.

    Races the evaluation of two fibers and returns the result of both.

    The following rules describe the semantics of both:

    1. If the winner completes with Outcome.Succeeded, the race waits for the loser to complete. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled. 3. If the winner completes with Outcome.Canceled, the loser and the race are canceled as well. 4. If the loser completes with Outcome.Succeeded, the race returns the successful value of both fibers. 5. If the loser completes with Outcome.Errored, the race returns the error. 6. If the loser completes with Outcome.Canceled, the race is canceled. 7. If the race is canceled before one or both participants complete, then whichever ones are incomplete are canceled. 8. If the race is masked and is canceled because one or both participants canceled, the fiber will block indefinitely.
    fa

    the effect for the first racing fiber

    fb

    the effect for the second racing fiber

    Definition Classes
    GenSpawn
    See also

    bothOutcome for a variant that returns the Outcome of both fibers.

  41. def bothOutcome[A, B](fa: F[A], fb: F[B]): F[(Outcome[F, E, A], Outcome[F, E, B])]

    Races the evaluation of two fibers and returns the Outcome of both.

    Races the evaluation of two fibers and returns the Outcome of both. If the race is canceled before one or both participants complete, then then whichever ones are incomplete are canceled.

    fa

    the effect for the first racing fiber

    fb

    the effect for the second racing fiber

    Definition Classes
    GenSpawn
    See also

    both for a simpler variant that returns the results of both fibers.

  42. def bracket[A, B](acquire: F[A])(use: (A) => F[B])(release: (A) => F[Unit]): F[B]

    A pattern for safely interacting with effectful lifecycles.

    A pattern for safely interacting with effectful lifecycles.

    If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

    acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

    acquire

    the lifecycle acquisition action

    use

    the effect to which the lifecycle is scoped, whose result is the return value of this function

    release

    the lifecycle release action

    Definition Classes
    MonadCancel
    See also

    bracketCase for a more powerful variant

    Resource for a composable datatype encoding of effectful lifecycles

  43. def bracketCase[A, B](acquire: F[A])(use: (A) => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]

    A pattern for safely interacting with effectful lifecycles.

    A pattern for safely interacting with effectful lifecycles.

    If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

    acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

    acquire

    the lifecycle acquisition action

    use

    the effect to which the lifecycle is scoped, whose result is the return value of this function

    release

    the lifecycle release action which depends on the outcome of use

    Definition Classes
    MonadCancel
    See also

    bracketFull for a more powerful variant

    Resource for a composable datatype encoding of effectful lifecycles

  44. def bracketFull[A, B](acquire: (Poll[F]) => F[A])(use: (A) => F[B])(release: (A, Outcome[F, E, B]) => F[Unit]): F[B]

    A pattern for safely interacting with effectful lifecycles.

    A pattern for safely interacting with effectful lifecycles.

    If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

    If use succeeds the returned value B is returned. If use returns an exception, the exception is returned.

    acquire is uncancelable by default, but can be unmasked. release is uncancelable. use is cancelable by default, but can be masked.

    acquire

    the lifecycle acquisition action which can be canceled

    use

    the effect to which the lifecycle is scoped, whose result is the return value of this function

    release

    the lifecycle release action which depends on the outcome of use

    Definition Classes
    MonadCancel
  45. def cachedRealTime(ttl: Duration): F[F[FiniteDuration]]

    Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime.

    Returns a nested effect which returns the time in a much faster way than Clock[F]#realTime. This is achieved by caching the real time when the outer effect is run and, when the inner effect is run, the offset is used in combination with Clock[F]#monotonic to give an approximation of the real time. The practical benefit of this is a reduction in the number of syscalls, since realTime will only be sequenced once per ttl window, and it tends to be (on most platforms) multiple orders of magnitude slower than monotonic.

    This should generally be used in situations where precise "to the millisecond" alignment to the system real clock is not needed. In particular, if the system clock is updated (e.g. via an NTP sync), the inner effect will not observe that update until up to ttl. This is an acceptable tradeoff in most practical scenarios, particularly with frequent sequencing of the inner effect.

    ttl

    The period of time after which the cached real time will be refreshed. Note that it will only be refreshed upon execution of the nested effect

  46. def catchNonFatal[A](a: => A)(implicit ev: <:<[Throwable, E]): F[A]
    Definition Classes
    ApplicativeError
  47. def catchNonFatalEval[A](a: Eval[A])(implicit ev: <:<[Throwable, E]): F[A]
    Definition Classes
    ApplicativeError
  48. def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
    Definition Classes
    ApplicativeError
  49. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  50. def compose[G[_]](implicit arg0: Applicative[G]): Applicative[[α]F[G[α]]]
    Definition Classes
    Applicative
  51. def compose[G[_]](implicit arg0: Apply[G]): Apply[[α]F[G[α]]]
    Definition Classes
    Apply
  52. def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
    Definition Classes
    Functor
  53. def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[G[α]]]
    Definition Classes
    Invariant
  54. def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]F[G[α]]]
    Definition Classes
    InvariantSemigroupal
  55. def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[G[α]]]
    Definition Classes
    Functor → Invariant
  56. def composeContravariantMonoidal[G[_]](implicit arg0: ContravariantMonoidal[G]): ContravariantMonoidal[[α]F[G[α]]]
    Definition Classes
    Applicative
  57. def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[G[α]]]
    Definition Classes
    Invariant
  58. def delayBy[A](fa: F[A], time: FiniteDuration): F[A]
    Attributes
    protected
  59. def delayBy[A](fa: F[A], time: Duration): F[A]

    Delay the execution of fa by a given duration.

    Delay the execution of fa by a given duration.

    fa

    The effect to execute

    time

    The duration to wait before executing fa

  60. def ensure[A](fa: F[A])(error: => E)(predicate: (A) => Boolean): F[A]
    Definition Classes
    MonadError
  61. def ensureOr[A](fa: F[A])(error: (A) => E)(predicate: (A) => Boolean): F[A]
    Definition Classes
    MonadError
  62. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  63. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  64. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  65. def flatMap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  66. def flatMap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  67. def flatMap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  68. def flatMap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  69. def flatMap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  70. def flatMap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  71. def flatMap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  72. def flatMap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  73. def flatMap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  74. def flatMap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  75. def flatMap2[A0, A1, Z](f0: F[A0], f1: F[A1])(f: (A0, A1) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  76. def flatMap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  77. def flatMap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  78. def flatMap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  79. def flatMap3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  80. def flatMap4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  81. def flatMap5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  82. def flatMap6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  83. def flatMap7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  84. def flatMap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  85. def flatMap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => F[Z]): F[Z]
    Definition Classes
    FlatMapArityFunctions
  86. def flatTap[A, B](fa: F[A])(f: (A) => F[B]): F[A]
    Definition Classes
    FlatMap
  87. def flatten[A](ffa: F[F[A]]): F[A]
    Definition Classes
    FlatMap
  88. final def fmap[A, B](fa: F[A])(f: (A) => B): F[B]
    Definition Classes
    Functor
  89. def foreverM[A, B](fa: F[A]): F[B]
    Definition Classes
    FlatMap
  90. def fproduct[A, B](fa: F[A])(f: (A) => B): F[(A, B)]
    Definition Classes
    Functor
  91. def fproductLeft[A, B](fa: F[A])(f: (A) => B): F[(B, A)]
    Definition Classes
    Functor
  92. def fromEither[A](x: Either[E, A]): F[A]
    Definition Classes
    ApplicativeError
  93. def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
    Definition Classes
    ApplicativeError
  94. def fromTry[A](t: Try[A])(implicit ev: <:<[Throwable, E]): F[A]
    Definition Classes
    ApplicativeError
  95. def fromValidated[A](x: Validated[E, A]): F[A]
    Definition Classes
    ApplicativeError
  96. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  97. def guarantee[A](fa: F[A], fin: F[Unit]): F[A]

    Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

    Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

    This function can be thought of as a combination of flatTap, onError, and onCancel.

    fa

    The effect that is run after fin is registered.

    fin

    The effect to run in the event of a cancelation or error.

    Definition Classes
    MonadCancel
    See also

    guaranteeCase for a more powerful variant

    Outcome for the various outcomes of evaluation

  98. def guaranteeCase[A](fa: F[A])(fin: (Outcome[F, E, A]) => F[Unit]): F[A]

    Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

    Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

    This function can be thought of as a combination of flatTap, onError, and onCancel.

    fa

    The effect that is run after fin is registered.

    fin

    A function that returns the effect to run based on the outcome.

    Definition Classes
    MonadCancel
    See also

    bracketCase for a more powerful variant

    Outcome for the various outcomes of evaluation

  99. def handleError[A](fa: F[A])(f: (E) => A): F[A]
    Definition Classes
    ApplicativeError
  100. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  101. def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
    Definition Classes
    Monad
  102. def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
    Definition Classes
    Functor
  103. def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
    Definition Classes
    FlatMap
  104. def imap[A, B](fa: F[A])(f: (A) => B)(g: (B) => A): F[B]
    Definition Classes
    Functor → Invariant
  105. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  106. def iterateForeverM[A, B](a: A)(f: (A) => F[A]): F[B]
    Definition Classes
    FlatMap
  107. def iterateUntil[A](f: F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  108. def iterateUntilM[A](init: A)(f: (A) => F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  109. def iterateWhile[A](f: F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  110. def iterateWhileM[A](init: A)(f: (A) => F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  111. def lift[A, B](f: (A) => B): (F[A]) => F[B]
    Definition Classes
    Functor
  112. def map[A, B](fa: F[A])(f: (A) => B): F[B]
    Definition Classes
    Monad → Applicative → Functor
  113. def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  114. def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  115. def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  116. def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  117. def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  118. def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  119. def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  120. def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  121. def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  122. def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  123. def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z]
    Definition Classes
    FlatMap → Apply
  124. def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  125. def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  126. def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[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): F[Z]
    Definition Classes
    ApplyArityFunctions
  127. def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
    Definition Classes
    FlatMap → Apply
  128. def map3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2])(f: (A0, A1, A2) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  129. def map4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3])(f: (A0, A1, A2, A3) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  130. def map5[A0, A1, A2, A3, A4, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4])(f: (A0, A1, A2, A3, A4) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  131. def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  132. def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  133. def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  134. def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Z]
    Definition Classes
    ApplyArityFunctions
  135. def memoize[A](fa: F[A]): F[F[A]]

    Caches the result of fa.

    Caches the result of fa.

    The returned inner effect, hence referred to as get, when sequenced, will evaluate fa and cache the result. If get is sequenced multiple times fa will only be evaluated once.

    If all gets are canceled prior to fa completing, it will be canceled and evaluated again the next time get is sequenced.

    Definition Classes
    GenConcurrent
  136. def mproduct[A, B](fa: F[A])(f: (A) => F[B]): F[(A, B)]
    Definition Classes
    FlatMap
  137. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  138. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  139. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  140. def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
    Definition Classes
    ApplicativeError
  141. def parReplicateAN[A](n: Int)(replicas: Int, ma: F[A]): F[List[A]]

    Like Parallel.parReplicateA, but limits the degree of parallelism.

    Like Parallel.parReplicateA, but limits the degree of parallelism.

    Definition Classes
    GenConcurrent
  142. def parSequenceN[T[_], A](n: Int)(tma: T[F[A]])(implicit arg0: Traverse[T]): F[T[A]]

    Like Parallel.parSequence, but limits the degree of parallelism.

    Like Parallel.parSequence, but limits the degree of parallelism.

    Definition Classes
    GenConcurrent
  143. def parTraverseN[T[_], A, B](n: Int)(ta: T[A])(f: (A) => F[B])(implicit arg0: Traverse[T]): F[T[B]]

    Like Parallel.parTraverse, but limits the degree of parallelism.

    Like Parallel.parTraverse, but limits the degree of parallelism. Note that the semantics of this operation aim to maximise fairness: when a spot to execute becomes available, every task has a chance to claim it, and not only the next n tasks in ta

    Definition Classes
    GenConcurrent
  144. def point[A](a: A): F[A]
    Definition Classes
    InvariantMonoidal
  145. def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
    Definition Classes
    FlatMap → Apply → Semigroupal
  146. def productL[A, B](fa: F[A])(fb: F[B]): F[A]
    Definition Classes
    FlatMap → Apply
  147. def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
    Definition Classes
    FlatMap
  148. def productR[A, B](fa: F[A])(fb: F[B]): F[B]
    Definition Classes
    FlatMap → Apply
  149. def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
    Definition Classes
    FlatMap
  150. def race[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]

    Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

    Races the evaluation of two fibers that returns the result of the winner, except in the case of cancelation.

    The semantics of race are described by the following rules:

    1. If the winner completes with Outcome.Succeeded, the race returns the successful value. The loser is canceled before returning. 2. If the winner completes with Outcome.Errored, the race raises the error. The loser is canceled before returning. 3. If the winner completes with Outcome.Canceled, the race returns the result of the loser, consistent with the first two rules. 4. If both the winner and loser complete with Outcome.Canceled, the race is canceled. 8. If the race is masked and is canceled because both participants canceled, the fiber will block indefinitely.
    fa

    the effect for the first racing fiber

    fb

    the effect for the second racing fiber

    Definition Classes
    GenSpawn
    See also

    raceOutcome for a variant that returns the outcome of the winner.

  151. def raceOutcome[A, B](fa: F[A], fb: F[B]): F[Either[Outcome[F, E, A], Outcome[F, E, B]]]

    Races the evaluation of two fibers that returns the Outcome of the winner.

    Races the evaluation of two fibers that returns the Outcome of the winner. The winner of the race is considered to be the first fiber that completes with an outcome. The loser of the race is canceled before returning.

    fa

    the effect for the first racing fiber

    fb

    the effect for the second racing fiber

    Definition Classes
    GenSpawn
    See also

    race for a simpler variant that returns the successful outcome.

  152. def racePair[A, B](fa: F[A], fb: F[B]): F[Either[(Outcome[F, E, A], Fiber[F, E, B]), (Fiber[F, E, A], Outcome[F, E, B])]]

    A low-level primitive for racing the evaluation of two fibers that returns the Outcome of the winner and the Fiber of the loser.

    A low-level primitive for racing the evaluation of two fibers that returns the Outcome of the winner and the Fiber of the loser. The winner of the race is considered to be the first fiber that completes with an outcome.

    racePair is a cancelation-unsafe function; it is recommended to use the safer variants.

    fa

    the effect for the first racing fiber

    fb

    the effect for the second racing fiber

    Definition Classes
    GenConcurrentGenSpawn
    See also

    raceOutcome and race for safer race variants.

  153. def raiseUnless(cond: Boolean)(e: => E): F[Unit]
    Definition Classes
    ApplicativeError
  154. def raiseWhen(cond: Boolean)(e: => E): F[Unit]
    Definition Classes
    ApplicativeError
  155. def realTimeInstant: F[Instant]
    Definition Classes
    ClockPlatform
  156. def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
    Definition Classes
    ApplicativeError
  157. def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
    Definition Classes
    ApplicativeError
  158. def redeem[A, B](fa: F[A])(recover: (E) => B, f: (A) => B): F[B]
    Definition Classes
    ApplicativeError
  159. def redeemWith[A, B](fa: F[A])(recover: (E) => F[B], bind: (A) => F[B]): F[B]
    Definition Classes
    MonadError
  160. def replicateA[A](n: Int, fa: F[A]): F[List[A]]
    Definition Classes
    Applicative
  161. def replicateA_[A](n: Int, fa: F[A]): F[Unit]
    Definition Classes
    Applicative
  162. def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
    Definition Classes
    MonadError
  163. final def rootCancelScope: CancelScope

    Indicates the default "root scope" semantics of the F in question.

    Indicates the default "root scope" semantics of the F in question. For types which do not implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

    Definition Classes
    GenSpawnMonadCancel
  164. def sleep(time: Duration): F[Unit]

    Semantically block the fiber for the specified duration.

    Semantically block the fiber for the specified duration.

    time

    The duration to semantically block for

  165. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  166. def timed[A](fa: F[A]): F[(FiniteDuration, A)]

    Returns an effect that completes with the result of the source together with the duration that it took to complete.

    Returns an effect that completes with the result of the source together with the duration that it took to complete.

    fa

    The effect which we wish to time the execution of

    Definition Classes
    Clock
  167. def timeout[A](fa: F[A], duration: FiniteDuration)(implicit ev: <:<[TimeoutException, E]): F[A]
    Attributes
    protected
  168. def timeout[A](fa: F[A], duration: Duration)(implicit ev: <:<[TimeoutException, E]): F[A]

    Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

    Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

    The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the TimeoutException will be raised. If the source is uncancelable, the resulting effect will wait for it to complete before raising the exception.

    duration

    The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

  169. def timeoutAndForget[A](fa: F[A], duration: FiniteDuration)(implicit ev: <:<[TimeoutException, E]): F[A]
    Attributes
    protected
  170. def timeoutAndForget[A](fa: F[A], duration: Duration)(implicit ev: <:<[TimeoutException, E]): F[A]

    Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

    Returns an effect that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

    The source is canceled in the event that it takes longer than the specified time duration to complete. Unlike timeout, the cancelation of the source will be requested but not awaited, and the exception will be raised immediately upon the completion of the timer. This may more closely match intuitions about timeouts, but it also violates backpressure guarantees and intentionally leaks fibers.

    This combinator should be applied very carefully.

    duration

    The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

    See also

    timeout for a variant which respects backpressure and does not leak fibers

  171. def timeoutTo[A](fa: F[A], duration: FiniteDuration, fallback: F[A]): F[A]
    Attributes
    protected
  172. def timeoutTo[A](fa: F[A], duration: Duration, fallback: F[A]): F[A]

    Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

    Returns an effect that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

    The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the fallback will be sequenced. If the source is uncancelable, the resulting effect will wait for it to complete before evaluating the fallback.

    duration

    The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, the fallback gets evaluated

    fallback

    The task evaluated after the duration has passed and the source canceled

  173. def toString(): String
    Definition Classes
    AnyRef → Any
  174. def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
    Definition Classes
    ApplyArityFunctions
  175. def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
    Definition Classes
    ApplyArityFunctions
  176. def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
    Definition Classes
    ApplyArityFunctions
  177. def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
    Definition Classes
    ApplyArityFunctions
  178. def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
    Definition Classes
    ApplyArityFunctions
  179. def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
    Definition Classes
    ApplyArityFunctions
  180. def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
    Definition Classes
    ApplyArityFunctions
  181. def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
    Definition Classes
    ApplyArityFunctions
  182. def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
    Definition Classes
    ApplyArityFunctions
  183. def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
    Definition Classes
    ApplyArityFunctions
  184. def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
    Definition Classes
    ApplyArityFunctions
  185. def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
    Definition Classes
    ApplyArityFunctions
  186. def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
    Definition Classes
    ApplyArityFunctions
  187. def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8], f9: F[A9], f10: F[A10], f11: F[A11], f12: F[A12], f13: F[A13], f14: F[A14], f15: F[A15], f16: F[A16], f17: F[A17], f18: F[A18], f19: F[A19], f20: F[A20], f21: F[A21]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
    Definition Classes
    ApplyArityFunctions
  188. def tuple3[A0, A1, A2](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
    Definition Classes
    ApplyArityFunctions
  189. def tuple4[A0, A1, A2, A3](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
    Definition Classes
    ApplyArityFunctions
  190. def tuple5[A0, A1, A2, A3, A4](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4]): F[(A0, A1, A2, A3, A4)]
    Definition Classes
    ApplyArityFunctions
  191. def tuple6[A0, A1, A2, A3, A4, A5](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5]): F[(A0, A1, A2, A3, A4, A5)]
    Definition Classes
    ApplyArityFunctions
  192. def tuple7[A0, A1, A2, A3, A4, A5, A6](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6]): F[(A0, A1, A2, A3, A4, A5, A6)]
    Definition Classes
    ApplyArityFunctions
  193. def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7]): F[(A0, A1, A2, A3, A4, A5, A6, A7)]
    Definition Classes
    ApplyArityFunctions
  194. def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3], f4: F[A4], f5: F[A5], f6: F[A6], f7: F[A7], f8: F[A8]): F[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
    Definition Classes
    ApplyArityFunctions
  195. def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
    Definition Classes
    Functor
  196. def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
    Definition Classes
    Functor
  197. def unit: F[Unit]
    Definition Classes
    Applicative → InvariantMonoidal
  198. def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
    Definition Classes
    Applicative
  199. def untilDefinedM[A](foa: F[Option[A]]): F[A]
    Definition Classes
    FlatMap
  200. def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
    Definition Classes
    Monad
  201. def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
    Definition Classes
    Monad
  202. def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
    Definition Classes
    Functor
  203. def void[A](fa: F[A]): F[Unit]
    Definition Classes
    Functor
  204. def voidError(fu: F[Unit]): F[Unit]
    Definition Classes
    ApplicativeError
  205. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  206. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  207. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  208. def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
    Definition Classes
    Applicative
  209. def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
    Definition Classes
    Monad
  210. def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
    Definition Classes
    Monad
  211. def widen[A, B >: A](fa: F[A]): F[B]
    Definition Classes
    Functor

Deprecated Value Members

  1. def ifA[A](fcond: F[Boolean])(ifTrue: F[A], ifFalse: F[A]): F[A]
    Definition Classes
    Apply
    Annotations
    @deprecated
    Deprecated

    (Since version 2.6.2) Dangerous method, use ifM (a flatMap) or ifF (a map) instead

Inherited from Clock[F]

Inherited from ClockPlatform[F]

Inherited from GenConcurrent[F, E]

Inherited from GenSpawn[F, E]

Inherited from Unique[F]

Inherited from MonadCancel[F, E]

Inherited from MonadError[F, E]

Inherited from Monad[F]

Inherited from FlatMap[F]

Inherited from FlatMapArityFunctions[F]

Inherited from ApplicativeError[F, E]

Inherited from Applicative[F]

Inherited from InvariantMonoidal[F]

Inherited from Apply[F]

Inherited from ApplyArityFunctions[F]

Inherited from InvariantSemigroupal[F]

Inherited from Semigroupal[F]

Inherited from Functor[F]

Inherited from Invariant[F]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped