Packages

trait GenSpawn[F[_], E] extends MonadCancel[F, E] with Unique[F]

A typeclass that characterizes monads which support spawning and racing of fibers. GenSpawn extends the capabilities of MonadCancel, so an instance of this typeclass must also provide a lawful instance for MonadCancel.

This documentation builds upon concepts introduced in the MonadCancel documentation.

Concurrency

GenSpawn introduces a notion of concurrency that enables fibers to safely interact with each other via three special functions. start spawns a fiber that executes concurrently with the spawning fiber. join semantically blocks the joining fiber until the joinee fiber terminates, after which the Outcome of the joinee is returned. cancel requests a fiber to abnormally terminate, and semantically blocks the canceller until the cancellee has completed finalization.

Just like threads, fibers can execute concurrently with respect to each other. This means that the effects of independent fibers may be interleaved nondeterministically. This mode of concurrency reaps benefits for modular program design; fibers that are described separately can execute simultaneously without requiring programmers to explicitly yield back to the runtime system.

The interleaving of effects is illustrated in the following program:

for {
  fa <- (println("A1") *> println("A2")).start
  fb <- (println("B1") *> println("B2")).start
} yield ()

In this program, two fibers A and B are spawned concurrently. There are six possible executions, each of which exhibits a different ordering of effects. The observed output of each execution is shown below:

  1. A1, A2, B1, B2
  2. A1, B1, A2, B2
  3. A1, B1, B2, A2
  4. B1, B2, A1, A2
  5. B1, A1, B2, A2
  6. B1, A1, A2, B3

Notice how every execution preserves sequential consistency of the effects within each fiber: A1 always prints before A2, and B1 always prints before B2. However, there are no guarantees around how the effects of both fibers will be ordered with respect to each other; it is entirely nondeterministic.

Cancelation

MonadCancel introduces a simple means of cancelation, particularly self-cancelation, where a fiber can request the abnormal termination of its own execution. This is achieved by calling canceled.

GenSpawn expands on the cancelation model described by MonadCancel by introducing a means of external cancelation. With external cancelation, a fiber can request the abnormal termination of another fiber by calling Fiber!.cancel.

The cancelation model dictates that external cancelation behaves identically to self-cancelation. To guarantee consistent behavior between the two, the following semantics are shared:

  1. Masking: if a fiber is canceled while it is masked, cancelation is suppressed until it reaches a completely unmasked state. See MonadCancel documentation for more details.
  2. Backpressure: cancel semantically blocks all callers until finalization is complete.
  3. Idempotency: once a fiber's cancelation has been requested, subsequent cancelations have no effect on cancelation status.
  4. Terminal: Cancelation of a fiber that has terminated immediately returns.

External cancelation contrasts with self-cancelation in one aspect: the former may require synchronization between multiple threads to communicate a cancelation request. As a result, cancelation may not be immediately observed by a fiber. Implementations are free to decide how and when this synchronization takes place.

Cancelation safety

A function or effect is considered to be cancelation-safe if it can be run in the absence of masking without violating effectful lifecycles or leaking resources. These functions require extra attention and care from users to ensure safe usage.

start and racePair are both considered to be cancelation-unsafe effects because they return a Fiber, which is a resource that has a lifecycle.

// Start a fiber that continuously prints "A".
// After 10 seconds, cancel the fiber.
F.start(F.delay(println("A")).foreverM).flatMap { fiber =>
  F.sleep(10.seconds) *> fiber.cancel
}

In the above example, imagine the spawning fiber is canceled after it starts the printing fiber, but before the latter is canceled. In this situation, the printing fiber is not canceled and will continue executing forever, contending with other fibers for system resources. Fiber leaks like this typically happen because some fiber that holds a reference to a child fiber is canceled before the child terminates; like threads, fibers will not automatically be cleaned up.

Resource leaks like this are unfavorable when writing applications. In the case of start and racePair, it is recommended not to use these methods; instead, use background and race respectively.

The following example depicts a safer version of the start example above:

// 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)
}

Scheduling

Fibers are commonly referred to as lightweight threads or green threads. This alludes to the nature by which fibers are scheduled by runtime systems: many fibers are multiplexed onto one or more native threads.

For applications running on the JVM, the scheduler typically manages a thread pool onto which fibers are scheduled. These fibers are executed simultaneously by the threads in the pool, achieving both concurrency and parallelism. For applications running on JavaScript platforms, all compute is restricted to a single worker thread, so multiple fibers must share that worker thread (dictated by fairness properties), achieving concurrency without parallelism.

cede is a special function that interacts directly with the underlying scheduler. It is a means of cooperative multitasking by which a fiber signals to the runtime system that it intends to pause execution and resume at some later time at the discretion of the scheduler. This is in contrast to preemptive multitasking, in which threads of control are forcibly yielded after a well-defined time slice.

Preemptive and cooperative multitasking are both features of runtime systems that influence the fairness and throughput properties of an application. These modes of scheduling are not necessarily mutually exclusive: a runtime system may incorporate a blend of the two, where fibers can explicitly yield back to the scheduler, but the runtime preempts a fiber if it has not yielded for some time.

For more details on schedulers, see the following resources:

  1. https://gist.github.com/djspiewak/3ac3f3f55a780e8ab6fa2ca87160ca40
  2. https://gist.github.com/djspiewak/46b543800958cf61af6efa8e072bfd5c
Source
GenSpawn.scala
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. GenSpawn
  2. Unique
  3. MonadCancel
  4. MonadError
  5. Monad
  6. FlatMap
  7. ApplicativeError
  8. Applicative
  9. InvariantMonoidal
  10. Apply
  11. ApplyArityFunctions
  12. InvariantSemigroupal
  13. Semigroupal
  14. Functor
  15. Invariant
  16. Serializable
  17. AnyRef
  18. 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.

    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.

    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)) <* 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.

  3. abstract def flatMap[A, B](fa: F[A])(f: (A) => F[B]): F[B]
    Definition Classes
    FlatMap
  4. 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
  5. abstract def handleErrorWith[A](fa: F[A])(f: (E) => F[A]): F[A]
    Definition Classes
    ApplicativeError
  6. 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
  7. 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
  8. abstract def pure[A](x: A): F[A]
    Definition Classes
    Applicative
  9. abstract 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

    See also

    raceOutcome and race for safer race variants.

  10. abstract def raiseError[A](e: E): F[A]
    Definition Classes
    ApplicativeError
  11. 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

    See also

    background for the safer, recommended variant

  12. abstract def tailRecM[A, B](a: A)(f: (A) => F[Either[A, B]]): F[B]
    Definition Classes
    FlatMap
  13. 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
  14. 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 ap[A, B](ff: F[(A) => B])(fa: F[A]): F[B]
    Definition Classes
    FlatMap → Apply
  9. 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
  10. 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
  11. 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
  12. 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
  13. 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
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. def ap2[A, B, Z](ff: F[(A, B) => Z])(fa: F[A], fb: F[B]): F[Z]
    Definition Classes
    FlatMap → Apply
  20. 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
  21. 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
  22. 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
  23. 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
  24. 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
  25. 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
  26. 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
  27. 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
  28. 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
  29. 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
  30. def applicative: Applicative[F]
    Definition Classes
    GenSpawnUnique
  31. def as[A, B](fa: F[A], b: B): F[B]
    Definition Classes
    Functor
  32. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  33. def attempt[A](fa: F[A]): F[Either[E, A]]
    Definition Classes
    ApplicativeError
  34. def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: <:<[EE, E]): F[Either[EE, A]]
    Definition Classes
    ApplicativeError
  35. def attemptT[A](fa: F[A]): EitherT[F, E, A]
    Definition Classes
    ApplicativeError
  36. def attemptTap[A, B](fa: F[A])(f: (Either[E, A]) => F[B]): F[A]
    Definition Classes
    MonadError
  37. 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

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

    See also

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

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

    See also

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

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

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

  42. 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
  43. def catchNonFatal[A](a: => A)(implicit ev: <:<[Throwable, E]): F[A]
    Definition Classes
    ApplicativeError
  44. def catchNonFatalEval[A](a: Eval[A])(implicit ev: <:<[Throwable, E]): F[A]
    Definition Classes
    ApplicativeError
  45. def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, E]
    Definition Classes
    ApplicativeError
  46. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  47. def compose[G[_]](implicit arg0: Applicative[G]): Applicative[[α]F[G[α]]]
    Definition Classes
    Applicative
  48. def compose[G[_]](implicit arg0: Apply[G]): Apply[[α]F[G[α]]]
    Definition Classes
    Apply
  49. def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
    Definition Classes
    Functor
  50. def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[G[α]]]
    Definition Classes
    Invariant
  51. def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]F[G[α]]]
    Definition Classes
    InvariantSemigroupal
  52. def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[G[α]]]
    Definition Classes
    Functor → Invariant
  53. def composeContravariantMonoidal[G[_]](implicit arg0: ContravariantMonoidal[G]): ContravariantMonoidal[[α]F[G[α]]]
    Definition Classes
    Applicative
  54. def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[G[α]]]
    Definition Classes
    Invariant
  55. def ensure[A](fa: F[A])(error: => E)(predicate: (A) => Boolean): F[A]
    Definition Classes
    MonadError
  56. def ensureOr[A](fa: F[A])(error: (A) => E)(predicate: (A) => Boolean): F[A]
    Definition Classes
    MonadError
  57. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  58. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  59. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  60. def flatTap[A, B](fa: F[A])(f: (A) => F[B]): F[A]
    Definition Classes
    FlatMap
  61. def flatten[A](ffa: F[F[A]]): F[A]
    Definition Classes
    FlatMap
  62. final def fmap[A, B](fa: F[A])(f: (A) => B): F[B]
    Definition Classes
    Functor
  63. def foreverM[A, B](fa: F[A]): F[B]
    Definition Classes
    FlatMap
  64. def fproduct[A, B](fa: F[A])(f: (A) => B): F[(A, B)]
    Definition Classes
    Functor
  65. def fproductLeft[A, B](fa: F[A])(f: (A) => B): F[(B, A)]
    Definition Classes
    Functor
  66. def fromEither[A](x: Either[E, A]): F[A]
    Definition Classes
    ApplicativeError
  67. def fromOption[A](oa: Option[A], ifEmpty: => E): F[A]
    Definition Classes
    ApplicativeError
  68. def fromTry[A](t: Try[A])(implicit ev: <:<[Throwable, E]): F[A]
    Definition Classes
    ApplicativeError
  69. def fromValidated[A](x: Validated[E, A]): F[A]
    Definition Classes
    ApplicativeError
  70. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  71. 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

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

  73. def handleError[A](fa: F[A])(f: (E) => A): F[A]
    Definition Classes
    ApplicativeError
  74. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  75. def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
    Definition Classes
    Monad
  76. def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
    Definition Classes
    Functor
  77. def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
    Definition Classes
    FlatMap
  78. def imap[A, B](fa: F[A])(f: (A) => B)(g: (B) => A): F[B]
    Definition Classes
    Functor → Invariant
  79. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  80. def iterateForeverM[A, B](a: A)(f: (A) => F[A]): F[B]
    Definition Classes
    FlatMap
  81. def iterateUntil[A](f: F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  82. def iterateUntilM[A](init: A)(f: (A) => F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  83. def iterateWhile[A](f: F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  84. def iterateWhileM[A](init: A)(f: (A) => F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  85. def lift[A, B](f: (A) => B): (F[A]) => F[B]
    Definition Classes
    Functor
  86. def map[A, B](fa: F[A])(f: (A) => B): F[B]
    Definition Classes
    Monad → Applicative → Functor
  87. 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
  88. 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
  89. 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
  90. 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
  91. 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
  92. 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
  93. 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
  94. 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
  95. 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
  96. 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
  97. def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z]
    Definition Classes
    FlatMap → Apply
  98. 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
  99. 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
  100. 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
  101. def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
    Definition Classes
    FlatMap → Apply
  102. 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
  103. 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
  104. 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
  105. 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
  106. 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
  107. 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
  108. 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
  109. def mproduct[A, B](fa: F[A])(f: (A) => F[B]): F[(A, B)]
    Definition Classes
    FlatMap
  110. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  111. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  112. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  113. def onError[A](fa: F[A])(pf: PartialFunction[E, F[Unit]]): F[A]
    Definition Classes
    ApplicativeError
  114. def point[A](a: A): F[A]
    Definition Classes
    InvariantMonoidal
  115. def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
    Definition Classes
    FlatMap → Apply → Semigroupal
  116. def productL[A, B](fa: F[A])(fb: F[B]): F[A]
    Definition Classes
    FlatMap → Apply
  117. def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
    Definition Classes
    FlatMap
  118. def productR[A, B](fa: F[A])(fb: F[B]): F[B]
    Definition Classes
    FlatMap → Apply
  119. def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
    Definition Classes
    FlatMap
  120. 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

    See also

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

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

    See also

    race for a simpler variant that returns the successful outcome.

  122. def raiseUnless(cond: Boolean)(e: => E): F[Unit]
    Definition Classes
    ApplicativeError
  123. def raiseWhen(cond: Boolean)(e: => E): F[Unit]
    Definition Classes
    ApplicativeError
  124. def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
    Definition Classes
    ApplicativeError
  125. def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A]
    Definition Classes
    ApplicativeError
  126. def redeem[A, B](fa: F[A])(recover: (E) => B, f: (A) => B): F[B]
    Definition Classes
    ApplicativeError
  127. def redeemWith[A, B](fa: F[A])(recover: (E) => F[B], bind: (A) => F[B]): F[B]
    Definition Classes
    MonadError
  128. def replicateA[A](n: Int, fa: F[A]): F[List[A]]
    Definition Classes
    Applicative
  129. def rethrow[A, EE <: E](fa: F[Either[EE, A]]): F[A]
    Definition Classes
    MonadError
  130. 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
  131. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  132. def toString(): String
    Definition Classes
    AnyRef → Any
  133. def tuple10[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)]
    Definition Classes
    ApplyArityFunctions
  134. def tuple11[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)]
    Definition Classes
    ApplyArityFunctions
  135. def tuple12[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)]
    Definition Classes
    ApplyArityFunctions
  136. def tuple13[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)]
    Definition Classes
    ApplyArityFunctions
  137. def tuple14[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)]
    Definition Classes
    ApplyArityFunctions
  138. def tuple15[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)]
    Definition Classes
    ApplyArityFunctions
  139. def tuple16[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)]
    Definition Classes
    ApplyArityFunctions
  140. def tuple17[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)]
    Definition Classes
    ApplyArityFunctions
  141. def tuple18[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)]
    Definition Classes
    ApplyArityFunctions
  142. def tuple19[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)]
    Definition Classes
    ApplyArityFunctions
  143. def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
    Definition Classes
    ApplyArityFunctions
  144. def tuple20[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)]
    Definition Classes
    ApplyArityFunctions
  145. def tuple21[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)]
    Definition Classes
    ApplyArityFunctions
  146. def tuple22[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)]
    Definition Classes
    ApplyArityFunctions
  147. def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
    Definition Classes
    ApplyArityFunctions
  148. def tuple4[A0, A1, A2, A3, Z](f0: F[A0], f1: F[A1], f2: F[A2], f3: F[A3]): F[(A0, A1, A2, A3)]
    Definition Classes
    ApplyArityFunctions
  149. def tuple5[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)]
    Definition Classes
    ApplyArityFunctions
  150. def tuple6[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)]
    Definition Classes
    ApplyArityFunctions
  151. def tuple7[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)]
    Definition Classes
    ApplyArityFunctions
  152. def tuple8[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)]
    Definition Classes
    ApplyArityFunctions
  153. def tuple9[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)]
    Definition Classes
    ApplyArityFunctions
  154. def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
    Definition Classes
    Functor
  155. def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
    Definition Classes
    Functor
  156. def unit: F[Unit]
    Definition Classes
    Applicative → InvariantMonoidal
  157. def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
    Definition Classes
    Applicative
  158. def untilDefinedM[A](foa: F[Option[A]]): F[A]
    Definition Classes
    FlatMap
  159. def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
    Definition Classes
    Monad
  160. def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
    Definition Classes
    Monad
  161. def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
    Definition Classes
    Functor
  162. def void[A](fa: F[A]): F[Unit]
    Definition Classes
    Functor
  163. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  164. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  165. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  166. def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
    Definition Classes
    Applicative
  167. def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
    Definition Classes
    Monad
  168. def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
    Definition Classes
    Monad
  169. 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 Unique[F]

Inherited from MonadCancel[F, E]

Inherited from MonadError[F, E]

Inherited from Monad[F]

Inherited from FlatMap[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