Packages

trait Sync[F[_]] extends MonadCancel[F, Throwable] with Clock[F] with Unique[F] with Defer[F]

A typeclass that encodes the notion of suspending synchronous side effects in the F[_] context

Source
Sync.scala
Linear Supertypes
Defer[F], Unique[F], Clock[F], ClockPlatform[F], MonadCancel[F, Throwable], MonadError[F, Throwable], Monad[F], FlatMap[F], ApplicativeError[F, Throwable], Applicative[F], InvariantMonoidal[F], Apply[F], ApplyArityFunctions[F], InvariantSemigroupal[F], Semigroupal[F], Functor[F], Invariant[F], Serializable, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Sync
  2. Defer
  3. Unique
  4. Clock
  5. ClockPlatform
  6. MonadCancel
  7. MonadError
  8. Monad
  9. FlatMap
  10. ApplicativeError
  11. Applicative
  12. InvariantMonoidal
  13. Apply
  14. ApplyArityFunctions
  15. InvariantSemigroupal
  16. Semigroupal
  17. Functor
  18. Invariant
  19. Serializable
  20. AnyRef
  21. 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 flatMap[A, B](fa: F[A])(f: (A) => F[B]): F[B]
    Definition Classes
    FlatMap
  3. 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
  4. abstract def handleErrorWith[A](fa: F[A])(f: (Throwable) => F[A]): F[A]
    Definition Classes
    ApplicativeError
  5. 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
  6. 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
  7. abstract def pure[A](x: A): F[A]
    Definition Classes
    Applicative
  8. abstract def raiseError[A](e: Throwable): F[A]
    Definition Classes
    ApplicativeError
  9. 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
  10. abstract 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
    MonadCancel
  11. abstract def suspend[A](hint: Type)(thunk: => A): F[A]
  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

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[Throwable, Throwable]): 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
    SyncUniqueClock
  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[Throwable, A]]
    Definition Classes
    ApplicativeError
  34. def attemptNarrow[EE <: Throwable, A](fa: F[A])(implicit tag: ClassTag[EE], ev: <:<[EE, Throwable]): F[Either[EE, A]]
    Definition Classes
    ApplicativeError
  35. def attemptT[A](fa: F[A]): EitherT[F, Throwable, A]
    Definition Classes
    ApplicativeError
  36. def attemptTap[A, B](fa: F[A])(f: (Either[Throwable, A]) => F[B]): F[A]
    Definition Classes
    MonadError
  37. def blocking[A](thunk: => A): F[A]

    Like Sync.delay but intended for thread blocking operations.

    Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

    Sync[F].blocking(scala.io.Source.fromFile("path").mkString)
    thunk

    The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

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

  39. def bracketCase[A, B](acquire: F[A])(use: (A) => F[B])(release: (A, Outcome[F, Throwable, 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

  40. def bracketFull[A, B](acquire: (Poll[F]) => F[A])(use: (A) => F[B])(release: (A, Outcome[F, Throwable, 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
  41. def catchNonFatal[A](a: => A)(implicit ev: <:<[Throwable, Throwable]): F[A]
    Definition Classes
    ApplicativeError
  42. def catchNonFatalEval[A](a: Eval[A])(implicit ev: <:<[Throwable, Throwable]): F[A]
    Definition Classes
    ApplicativeError
  43. def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, F, Throwable]
    Definition Classes
    ApplicativeError
  44. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  45. def compose[G[_]](implicit arg0: Applicative[G]): Applicative[[α]F[G[α]]]
    Definition Classes
    Applicative
  46. def compose[G[_]](implicit arg0: Apply[G]): Apply[[α]F[G[α]]]
    Definition Classes
    Apply
  47. def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
    Definition Classes
    Functor
  48. def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[G[α]]]
    Definition Classes
    Invariant
  49. def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]F[G[α]]]
    Definition Classes
    InvariantSemigroupal
  50. def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[G[α]]]
    Definition Classes
    Functor → Invariant
  51. def composeContravariantMonoidal[G[_]](implicit arg0: ContravariantMonoidal[G]): ContravariantMonoidal[[α]F[G[α]]]
    Definition Classes
    Applicative
  52. def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[G[α]]]
    Definition Classes
    Invariant
  53. def defer[A](thunk: => F[A]): F[A]

    Suspends the evaluation of an F[_] reference.

    Suspends the evaluation of an F[_] reference.

    Equivalent to FlatMap.flatten for pure expressions, the purpose of this function is to suspend side effects in F[_].

    Definition Classes
    Sync → Defer
  54. def delay[A](thunk: => A): F[A]

    The synchronous FFI - lifts any by-name parameter into the F[_] context.

    The synchronous FFI - lifts any by-name parameter into the F[_] context.

    Equivalent to Applicative.pure for pure expressions, the purpose of this function is to suspend side effects in F. Use Sync.delay if your side effect is not thread-blocking; otherwise you should use Sync.blocking (uncancelable) or Sync.interruptible (cancelable).

    thunk

    The side effect which is to be suspended in F[_]

  55. def ensure[A](fa: F[A])(error: => Throwable)(predicate: (A) => Boolean): F[A]
    Definition Classes
    MonadError
  56. def ensureOr[A](fa: F[A])(error: (A) => Throwable)(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 fix[A](fn: (F[A]) => F[A]): F[A]
    Definition Classes
    Defer
  61. def flatTap[A, B](fa: F[A])(f: (A) => F[B]): F[A]
    Definition Classes
    FlatMap
  62. def flatten[A](ffa: F[F[A]]): F[A]
    Definition Classes
    FlatMap
  63. final def fmap[A, B](fa: F[A])(f: (A) => B): F[B]
    Definition Classes
    Functor
  64. def foreverM[A, B](fa: F[A]): F[B]
    Definition Classes
    FlatMap
  65. def fproduct[A, B](fa: F[A])(f: (A) => B): F[(A, B)]
    Definition Classes
    Functor
  66. def fproductLeft[A, B](fa: F[A])(f: (A) => B): F[(B, A)]
    Definition Classes
    Functor
  67. def fromEither[A](x: Either[Throwable, A]): F[A]
    Definition Classes
    ApplicativeError
  68. def fromOption[A](oa: Option[A], ifEmpty: => Throwable): F[A]
    Definition Classes
    ApplicativeError
  69. def fromTry[A](t: Try[A])(implicit ev: <:<[Throwable, Throwable]): F[A]
    Definition Classes
    ApplicativeError
  70. def fromValidated[A](x: Validated[Throwable, A]): F[A]
    Definition Classes
    ApplicativeError
  71. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  72. 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

  73. def guaranteeCase[A](fa: F[A])(fin: (Outcome[F, Throwable, 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

  74. def handleError[A](fa: F[A])(f: (Throwable) => A): F[A]
    Definition Classes
    ApplicativeError
  75. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  76. def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
    Definition Classes
    Monad
  77. def ifF[A](fb: F[Boolean])(ifTrue: => A, ifFalse: => A): F[A]
    Definition Classes
    Functor
  78. def ifM[B](fa: F[Boolean])(ifTrue: => F[B], ifFalse: => F[B]): F[B]
    Definition Classes
    FlatMap
  79. def imap[A, B](fa: F[A])(f: (A) => B)(g: (B) => A): F[B]
    Definition Classes
    Functor → Invariant
  80. def interruptible[A](thunk: => A): F[A]

    Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation.

    Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

    thunk

    The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

  81. def interruptibleMany[A](thunk: => A): F[A]

    Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation.

    Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.

    thunk

    The side effect which is to be suspended in F[_] and evaluated on a blocking execution context

    Note

    that this _really_ means what it says - it will throw exceptions in a tight loop until the offending blocking operation exits. This is extremely expensive if it happens on a hot path and the blocking operation is badly behaved and doesn't exit immediately.

  82. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  83. def iterateForeverM[A, B](a: A)(f: (A) => F[A]): F[B]
    Definition Classes
    FlatMap
  84. def iterateUntil[A](f: F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  85. def iterateUntilM[A](init: A)(f: (A) => F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  86. def iterateWhile[A](f: F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  87. def iterateWhileM[A](init: A)(f: (A) => F[A])(p: (A) => Boolean): F[A]
    Definition Classes
    Monad
  88. def lift[A, B](f: (A) => B): (F[A]) => F[B]
    Definition Classes
    Functor
  89. def map[A, B](fa: F[A])(f: (A) => B): F[B]
    Definition Classes
    Monad → Applicative → Functor
  90. 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
  91. 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
  92. 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
  93. 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
  94. 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
  95. 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
  96. 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
  97. 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
  98. 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
  99. 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
  100. def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z]
    Definition Classes
    FlatMap → Apply
  101. 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
  102. 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
  103. 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
  104. def map2Eval[A, B, Z](fa: F[A], fb: Eval[F[B]])(f: (A, B) => Z): Eval[F[Z]]
    Definition Classes
    FlatMap → Apply
  105. 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
  106. 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
  107. 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
  108. 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
  109. 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
  110. 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
  111. 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
  112. def mproduct[A, B](fa: F[A])(f: (A) => F[B]): F[(A, B)]
    Definition Classes
    FlatMap
  113. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  114. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  115. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  116. def onError[A](fa: F[A])(pf: PartialFunction[Throwable, F[Unit]]): F[A]
    Definition Classes
    ApplicativeError
  117. def point[A](a: A): F[A]
    Definition Classes
    InvariantMonoidal
  118. def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
    Definition Classes
    FlatMap → Apply → Semigroupal
  119. def productL[A, B](fa: F[A])(fb: F[B]): F[A]
    Definition Classes
    FlatMap → Apply
  120. def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A]
    Definition Classes
    FlatMap
  121. def productR[A, B](fa: F[A])(fb: F[B]): F[B]
    Definition Classes
    FlatMap → Apply
  122. def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B]
    Definition Classes
    FlatMap
  123. def raiseUnless(cond: Boolean)(e: => Throwable): F[Unit]
    Definition Classes
    ApplicativeError
  124. def raiseWhen(cond: Boolean)(e: => Throwable): F[Unit]
    Definition Classes
    ApplicativeError
  125. def realTimeInstant: F[Instant]
    Definition Classes
    ClockPlatform
  126. def recover[A](fa: F[A])(pf: PartialFunction[Throwable, A]): F[A]
    Definition Classes
    ApplicativeError
  127. def recoverWith[A](fa: F[A])(pf: PartialFunction[Throwable, F[A]]): F[A]
    Definition Classes
    ApplicativeError
  128. def redeem[A, B](fa: F[A])(recover: (Throwable) => B, f: (A) => B): F[B]
    Definition Classes
    ApplicativeError
  129. def redeemWith[A, B](fa: F[A])(recover: (Throwable) => F[B], bind: (A) => F[B]): F[B]
    Definition Classes
    MonadError
  130. def replicateA[A](n: Int, fa: F[A]): F[List[A]]
    Definition Classes
    Applicative
  131. def rethrow[A, EE <: Throwable](fa: F[Either[EE, A]]): F[A]
    Definition Classes
    MonadError
  132. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  133. 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
  134. def toString(): String
    Definition Classes
    AnyRef → Any
  135. 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
  136. 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
  137. 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
  138. 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
  139. 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
  140. 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
  141. 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
  142. 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
  143. 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
  144. 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
  145. def tuple2[A, B](f1: F[A], f2: F[B]): F[(A, B)]
    Definition Classes
    ApplyArityFunctions
  146. 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
  147. 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
  148. 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
  149. def tuple3[A0, A1, A2, Z](f0: F[A0], f1: F[A1], f2: F[A2]): F[(A0, A1, A2)]
    Definition Classes
    ApplyArityFunctions
  150. 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
  151. 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
  152. 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
  153. 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
  154. 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
  155. 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
  156. def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
    Definition Classes
    Functor
  157. def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
    Definition Classes
    Functor
  158. def unique: F[Token]

    Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

    Yields a value that is guaranteed to be unique ie (F.unique, F.unique).mapN(_ =!= _)

    Definition Classes
    SyncUnique
  159. def unit: F[Unit]
    Definition Classes
    Applicative → InvariantMonoidal
  160. def unlessA[A](cond: Boolean)(f: => F[A]): F[Unit]
    Definition Classes
    Applicative
  161. def untilDefinedM[A](foa: F[Option[A]]): F[A]
    Definition Classes
    FlatMap
  162. def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
    Definition Classes
    Monad
  163. def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
    Definition Classes
    Monad
  164. def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
    Definition Classes
    Functor
  165. def void[A](fa: F[A]): F[Unit]
    Definition Classes
    Functor
  166. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  167. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  168. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  169. def whenA[A](cond: Boolean)(f: => F[A]): F[Unit]
    Definition Classes
    Applicative
  170. def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
    Definition Classes
    Monad
  171. def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
    Definition Classes
    Monad
  172. 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 Defer[F]

Inherited from Unique[F]

Inherited from Clock[F]

Inherited from ClockPlatform[F]

Inherited from MonadCancel[F, Throwable]

Inherited from MonadError[F, Throwable]

Inherited from Monad[F]

Inherited from FlatMap[F]

Inherited from ApplicativeError[F, Throwable]

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