BIOCatsTemporalImpl

class BIOCatsTemporalImpl[F[+_, +_]] extends BIOCatsSync[F] with BIOCatsTemporal[F]

Linear Supertypes

BIOCatsTemporal[F], BIOCatsConcurrent[F], BIOCatsSpawn[F], GenTemporal[[β$45$]F[Throwable, β$45$], Throwable], GenConcurrent[[β$45$]F[Throwable, β$45$], Throwable], GenSpawn[[β$45$]F[Throwable, β$45$], Throwable], BIOCatsSync[F], Sync[[β$26$]F[Throwable, β$26$]], Defer[[β$26$]F[Throwable, β$26$]], Unique[[β$26$]F[Throwable, β$26$]], BIOCatsClock[F, Throwable], Clock[[β$25$]F[Throwable, β$25$]], ClockPlatform[[β$25$]F[Throwable, β$25$]], BIOCatsMonadCancel[F], MonadCancel[[β$16$]F[Throwable, β$16$], Throwable], BIOCatsMonadError[F, Throwable], MonadError[[β$15$]F[Throwable, β$15$], Throwable], ApplicativeError[[β$15$]F[Throwable, β$15$], Throwable], BIOCatsMonad[F, Throwable], BIOCatsApplicative[F, Throwable], BIOCatsFunctor[F, Throwable], S12, S11, S10, S9, S8, S7, S6, S5, S4, S3, S2, S1, Monad[[β$14$]F[Throwable, β$14$]], Applicative[[β$14$]F[Throwable, β$14$]], InvariantMonoidal[[β$14$]F[Throwable, β$14$]], FlatMap[[β$14$]F[Throwable, β$14$]], FlatMapArityFunctions[[β$14$]F[Throwable, β$14$]], Apply[[β$14$]F[Throwable, β$14$]], ApplyArityFunctions[[β$14$]F[Throwable, β$14$]], InvariantSemigroupal[[β$14$]F[Throwable, β$14$]], Semigroupal[[β$14$]F[Throwable, β$14$]], Functor[[β$14$]F[Throwable, β$14$]], Invariant[[β$14$]F[Throwable, β$14$]], Serializable, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

BIOCatsTemporalImpl
BIOCatsTemporal
BIOCatsConcurrent
BIOCatsSpawn
GenTemporal
GenConcurrent
GenSpawn
BIOCatsSync
Sync
Defer
Unique
BIOCatsClock
Clock
ClockPlatform
BIOCatsMonadCancel
MonadCancel
BIOCatsMonadError
MonadError
ApplicativeError
BIOCatsMonad
BIOCatsApplicative
BIOCatsFunctor
S12
S11
S10
S9
S8
S7
S6
S5
S4
S3
S2
S1
Monad
Applicative
InvariantMonoidal
FlatMap
FlatMapArityFunctions
Apply
ApplyArityFunctions
InvariantSemigroupal
Semigroupal
Functor
Invariant
Serializable
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Instance Constructors

new BIOCatsTemporalImpl(F: IO2[F], FC: Concurrent2[F], FT: Temporal2[F], Fork: Fork2[F], Primitives: Primitives2[F], BlockingIO: BlockingIO2[F], Clock: Clock2[F])

Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def *>[A, B](fa: F[Throwable, A])(fb: F[Throwable, B]): F[Throwable, B]
Definition Classes
Apply
Annotations
@inline()
final def <*[A, B](fa: F[Throwable, A])(fb: F[Throwable, B]): F[Throwable, A]
Definition Classes
Apply
Annotations
@inline()
final def <*>[A, B](ff: F[Throwable, (A) => B])(fa: F[Throwable, A]): F[Throwable, B]
Definition Classes
Apply
Annotations
@inline()
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
val BlockingIO: BlockingIO2[F]
Definition Classes
BIOCatsTemporalImpl → BIOCatsSync
val Clock: Clock2[F]
Definition Classes
BIOCatsTemporalImpl → BIOCatsSync → BIOCatsClock
val F: IO2[F]
Definition Classes
BIOCatsTemporalImpl → BIOCatsTemporal → BIOCatsSpawn → BIOCatsSync → BIOCatsClock → BIOCatsMonadCancel → BIOCatsMonadError → BIOCatsMonad → BIOCatsApplicative → BIOCatsFunctor
val FC: Concurrent2[F]
Definition Classes
BIOCatsTemporalImpl → BIOCatsConcurrent → BIOCatsSpawn
val FT: Temporal2[F]
Definition Classes
BIOCatsTemporalImpl → BIOCatsTemporal
val Fork: Fork2[F]
Definition Classes
BIOCatsTemporalImpl → BIOCatsConcurrent → BIOCatsSpawn
val Primitives: Primitives2[F]
Definition Classes
BIOCatsTemporalImpl → BIOCatsConcurrent
def adaptError[A](fa: F[Throwable, A])(pf: PartialFunction[Throwable, Throwable]): F[Throwable, A]
Definition Classes
MonadError → ApplicativeError
final def andWait[A](fa: F[Throwable, A], time: FiniteDuration): F[Throwable, A]
Definition Classes
BIOCatsTemporal → GenTemporal
def andWait[A](fa: F[Throwable, A], time: Duration): F[Throwable, A]
Definition Classes
GenTemporal
final def ap[A, B](ff: F[Throwable, (A) => B])(fa: F[Throwable, A]): F[Throwable, B]
Definition Classes
BIOCatsApplicative → Apply
Annotations
@inline()
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap2[A, B, Z](ff: F[Throwable, (A, B) => Z])(fa: F[Throwable, A], fb: F[Throwable, B]): F[Throwable, Z]
Definition Classes
FlatMap → Apply
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[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
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[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19], f20: F[Throwable, A20]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
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[Throwable, (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[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19], f20: F[Throwable, A20], f21: F[Throwable, A21]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: F[Throwable, (A0, A1, A2) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: F[Throwable, (A0, A1, A2, A3) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: F[Throwable, (A0, A1, A2, A3, A4) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8]): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def applicative: Applicative[[β$45$]F[Throwable, β$45$]]
Definition Classes
GenTemporal → Clock → GenSpawn → Unique
final def as[A, B](fa: F[Throwable, A], b: B): F[Throwable, B]
Definition Classes
BIOCatsFunctor → Functor
Annotations
@inline()
final def asInstanceOf[T0]: T0
Definition Classes
Any
final def attempt[A](fa: F[Throwable, A]): F[Throwable, Either[Throwable, A]]
Definition Classes
BIOCatsMonadError → ApplicativeError
Annotations
@inline()
def attemptNarrow[EE <: Throwable, A](fa: F[Throwable, A])(implicit tag: ClassTag[EE], ev: <:<[EE, Throwable]): F[Throwable, Either[EE, A]]
Definition Classes
ApplicativeError
def attemptT[A](fa: F[Throwable, A]): EitherT[[β$15$]F[Throwable, β$15$], Throwable, A]
Definition Classes
ApplicativeError
def attemptTap[A, B](fa: F[Throwable, A])(f: (Either[Throwable, A]) => F[Throwable, B]): F[Throwable, A]
Definition Classes
MonadError
def background[A](fa: F[Throwable, A]): Resource[[β$34$]F[Throwable, β$34$], F[Throwable, Outcome[[β$35$]F[Throwable, β$35$], Throwable, A]]]
Definition Classes
BIOCatsSpawn → GenSpawn
final def blocking[A](thunk: => A): F[Throwable, A]
Definition Classes
BIOCatsSync → Sync
Annotations
@inline()
def both[A, B](fa: F[Throwable, A], fb: F[Throwable, B]): F[Throwable, (A, B)]
Definition Classes
BIOCatsSpawn → GenSpawn
def bothOutcome[A, B](fa: F[Throwable, A], fb: F[Throwable, B]): F[Throwable, (Outcome[[β$38$]F[Throwable, β$38$], Throwable, A], Outcome[[β$39$]F[Throwable, β$39$], Throwable, B])]
Definition Classes
BIOCatsSpawn → GenSpawn
final def bracket[A, B](acquire: F[Throwable, A])(use: (A) => F[Throwable, B])(release: (A) => F[Throwable, Unit]): F[Throwable, B]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
final def bracketCase[A, B](acquire: F[Throwable, A])(use: (A) => F[Throwable, B])(release: (A, Outcome[[β$19$]F[Throwable, β$19$], Throwable, B]) => F[Throwable, Unit]): F[Throwable, B]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
final def bracketFull[A, B](acquire: (Poll[[β$17$]F[Throwable, β$17$]]) => F[Throwable, A])(use: (A) => F[Throwable, B])(release: (A, Outcome[[β$18$]F[Throwable, β$18$], Throwable, B]) => F[Throwable, Unit]): F[Throwable, B]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
def cachedRealTime(ttl: Duration): F[Throwable, F[Throwable, FiniteDuration]]
Definition Classes
GenTemporal
def cancelable[A](fa: F[Throwable, A], fin: F[Throwable, Unit]): F[Throwable, A]
Definition Classes
GenSpawn
final def canceled: F[Throwable, Unit]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
def catchNonFatal[A](a: => A)(implicit ev: <:<[Throwable, Throwable]): F[Throwable, A]
Definition Classes
ApplicativeError
def catchNonFatalEval[A](a: Eval[A])(implicit ev: <:<[Throwable, Throwable]): F[Throwable, A]
Definition Classes
ApplicativeError
def catchOnly[T >: Null <: Throwable]: CatchOnlyPartiallyApplied[T, [β$15$]F[Throwable, β$15$], Throwable]
Definition Classes
ApplicativeError
def cede: F[Throwable, Unit]
Definition Classes
BIOCatsSpawn → GenSpawn
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
def compose[G[_]](implicit arg0: Applicative[G]): Applicative[[α]F[Throwable, G[α]]]
Definition Classes
Applicative
def compose[G[_]](implicit arg0: Apply[G]): Apply[[α]F[Throwable, G[α]]]
Definition Classes
Apply
def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[Throwable, G[α]]]
Definition Classes
Functor
def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[Throwable, G[α]]]
Definition Classes
Invariant
def composeApply[G[_]](implicit arg0: Apply[G]): InvariantSemigroupal[[α]F[Throwable, G[α]]]
Definition Classes
InvariantSemigroupal
def composeBifunctor[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[Throwable, G[α, β]]]
Definition Classes
Functor
def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[Throwable, G[α]]]
Definition Classes
Functor → Invariant
def composeContravariantMonoidal[G[_]](implicit arg0: ContravariantMonoidal[G]): ContravariantMonoidal[[α]F[Throwable, G[α]]]
Definition Classes
Applicative
def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[Throwable, G[α]]]
Definition Classes
Invariant
final def defer[A](thunk: => F[Throwable, A]): F[Throwable, A]
Definition Classes
BIOCatsSync → Sync → Defer
Annotations
@inline()
final def deferred[A]: F[Throwable, Deferred[[β$43$]F[Throwable, β$43$], A]]
Definition Classes
BIOCatsConcurrent → GenConcurrent
final def delay[A](thunk: => A): F[Throwable, A]
Definition Classes
BIOCatsSync → Sync
Annotations
@inline()
final def delayBy[A](fa: F[Throwable, A], time: FiniteDuration): F[Throwable, A]
Definition Classes
BIOCatsTemporal → GenTemporal
def delayBy[A](fa: F[Throwable, A], time: Duration): F[Throwable, A]
Definition Classes
GenTemporal
def ensure[A](fa: F[Throwable, A])(error: => Throwable)(predicate: (A) => Boolean): F[Throwable, A]
Definition Classes
MonadError
def ensureOr[A](fa: F[Throwable, A])(error: (A) => Throwable)(predicate: (A) => Boolean): F[Throwable, A]
Definition Classes
MonadError
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
def fix[A](fn: (F[Throwable, A]) => F[Throwable, A]): F[Throwable, A]
Definition Classes
Defer
final def flatMap[A, B](fa: F[Throwable, A])(f: (A) => F[Throwable, B]): F[Throwable, B]
Definition Classes
BIOCatsMonad → FlatMap
Annotations
@inline()
def flatMap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap2[A0, A1, Z](f0: F[Throwable, A0], f1: F[Throwable, A1])(f: (A0, A1) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19], f20: F[Throwable, A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19], f20: F[Throwable, A20], f21: F[Throwable, A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap3[A0, A1, A2, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2])(f: (A0, A1, A2) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap4[A0, A1, A2, A3, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3])(f: (A0, A1, A2, A3) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap5[A0, A1, A2, A3, A4, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4])(f: (A0, A1, A2, A3, A4) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap6[A0, A1, A2, A3, A4, A5, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5])(f: (A0, A1, A2, A3, A4, A5) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6])(f: (A0, A1, A2, A3, A4, A5, A6) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => F[Throwable, Z]): F[Throwable, Z]
Definition Classes
FlatMapArityFunctions
def flatMapOrKeep[A, A1 >: A](fa: F[Throwable, A])(pfa: PartialFunction[A, F[Throwable, A1]]): F[Throwable, A1]
Definition Classes
Monad
def flatTap[A, B](fa: F[Throwable, A])(f: (A) => F[Throwable, B]): F[Throwable, A]
Definition Classes
FlatMap
final def flatten[A](ffa: F[Throwable, F[Throwable, A]]): F[Throwable, A]
Definition Classes
BIOCatsMonad → FlatMap
Annotations
@inline()
final def fmap[A, B](fa: F[Throwable, A])(f: (A) => B): F[Throwable, B]
Definition Classes
Functor
final def forceR[A, B](fa: F[Throwable, A])(fb: F[Throwable, B]): F[Throwable, B]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
def foreverM[A, B](fa: F[Throwable, A]): F[Throwable, B]
Definition Classes
FlatMap
def fproduct[A, B](fa: F[Throwable, A])(f: (A) => B): F[Throwable, (A, B)]
Definition Classes
Functor
def fproductLeft[A, B](fa: F[Throwable, A])(f: (A) => B): F[Throwable, (B, A)]
Definition Classes
Functor
final def fromEither[A](x: Either[Throwable, A]): F[Throwable, A]
Definition Classes
BIOCatsMonadError → ApplicativeError
Annotations
@inline()
def fromOption[A](oa: Option[A], ifEmpty: => Throwable): F[Throwable, A]
Definition Classes
ApplicativeError
def fromTry[A](t: Try[A])(implicit ev: <:<[Throwable, Throwable]): F[Throwable, A]
Definition Classes
ApplicativeError
def fromValidated[A](x: Validated[Throwable, A]): F[Throwable, A]
Definition Classes
ApplicativeError
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
final def guarantee[A](fa: F[Throwable, A], fin: F[Throwable, Unit]): F[Throwable, A]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
final def guaranteeCase[A](fa: F[Throwable, A])(fin: (Outcome[[β$21$]F[Throwable, β$21$], Throwable, A]) => F[Throwable, Unit]): F[Throwable, A]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
def handleError[A](fa: F[Throwable, A])(f: (Throwable) => A): F[Throwable, A]
Definition Classes
ApplicativeError
final def handleErrorWith[A](fa: F[Throwable, A])(f: (Throwable) => F[Throwable, A]): F[Throwable, A]
Definition Classes
BIOCatsMonadError → ApplicativeError
Annotations
@inline()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
def ifElseM[A](branches: (F[Throwable, Boolean], F[Throwable, A])*)(els: F[Throwable, A]): F[Throwable, A]
Definition Classes
Monad
def ifF[A](fb: F[Throwable, Boolean])(ifTrue: => A, ifFalse: => A): F[Throwable, A]
Definition Classes
Functor
def ifM[B](fa: F[Throwable, Boolean])(ifTrue: => F[Throwable, B], ifFalse: => F[Throwable, B]): F[Throwable, B]
Definition Classes
FlatMap
def imap[A, B](fa: F[Throwable, A])(f: (A) => B)(g: (B) => A): F[Throwable, B]
Definition Classes
Functor → Invariant
final def interruptible[A](thunk: => A): F[Throwable, A]
Definition Classes
BIOCatsSync → Sync
Annotations
@inline()
final def interruptibleMany[A](thunk: => A): F[Throwable, A]
Definition Classes
BIOCatsSync → Sync
Annotations
@inline()
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
def iterateForeverM[A, B](a: A)(f: (A) => F[Throwable, A]): F[Throwable, B]
Definition Classes
FlatMap
final def iterateUntil[A](f: F[Throwable, A])(p: (A) => Boolean): F[Throwable, A]
Definition Classes
BIOCatsMonad → Monad
Annotations
@inline()
final def iterateUntilM[A](init: A)(f: (A) => F[Throwable, A])(p: (A) => Boolean): F[Throwable, A]
Definition Classes
BIOCatsMonad → Monad
Annotations
@inline()
final def iterateWhile[A](f: F[Throwable, A])(p: (A) => Boolean): F[Throwable, A]
Definition Classes
BIOCatsMonad → Monad
Annotations
@inline()
final def iterateWhileM[A](init: A)(f: (A) => F[Throwable, A])(p: (A) => Boolean): F[Throwable, A]
Definition Classes
BIOCatsMonad → Monad
Annotations
@inline()
def lift[A, B](f: (A) => B): (F[Throwable, A]) => F[Throwable, B]
Definition Classes
Functor
final def map[A, B](fa: F[Throwable, A])(f: (A) => B): F[Throwable, B]
Definition Classes
BIOCatsFunctor → Functor
Annotations
@inline()
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
final def map2[A, B, Z](fa: F[Throwable, A], fb: F[Throwable, B])(f: (A, B) => Z): F[Throwable, Z]
Definition Classes
BIOCatsApplicative → Apply
Annotations
@inline()
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[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
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[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19], f20: F[Throwable, 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[Throwable, Z]
Definition Classes
ApplyArityFunctions
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[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19], f20: F[Throwable, A20], f21: F[Throwable, 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[Throwable, Z]
Definition Classes
ApplyArityFunctions
final def map2Eval[A, B, Z](fa: F[Throwable, A], fb: Eval[F[Throwable, B]])(f: (A, B) => Z): Eval[F[Throwable, Z]]
Definition Classes
BIOCatsApplicative → Apply
Annotations
@inline()
def map3[A0, A1, A2, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2])(f: (A0, A1, A2) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3])(f: (A0, A1, A2, A3) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4])(f: (A0, A1, A2, A3, A4) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5])(f: (A0, A1, A2, A3, A4, A5) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): F[Throwable, Z]
Definition Classes
ApplyArityFunctions
def mapOrKeep[A, A1 >: A](fa: F[Throwable, A])(pf: PartialFunction[A, A1]): F[Throwable, A1]
Definition Classes
Functor
final def memoize[A](fa: F[Throwable, A]): F[Throwable, F[Throwable, A]]
Definition Classes
BIOCatsConcurrent → GenConcurrent
final def monotonic: F[Throwable, FiniteDuration]
Definition Classes
BIOCatsClock → Clock
def mproduct[A, B](fa: F[Throwable, A])(f: (A) => F[Throwable, B]): F[Throwable, (A, B)]
Definition Classes
FlatMap
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def never[A]: F[Throwable, A]
Definition Classes
BIOCatsSpawn → GenSpawn
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def onCancel[A](fa: F[Throwable, A], fin: F[Throwable, Unit]): F[Throwable, A]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
def onError[A](fa: F[Throwable, A])(pf: PartialFunction[Throwable, F[Throwable, Unit]]): F[Throwable, A]
Definition Classes
ApplicativeError
final def parReplicateAN[A](n: Int)(replicas: Int, ma: F[Throwable, A]): F[Throwable, List[A]]
Definition Classes
BIOCatsConcurrent → GenConcurrent
final def parSequenceN[T[_], A](n: Int)(tma: T[F[Throwable, A]])(implicit arg0: Traverse[T]): F[Throwable, T[A]]
Definition Classes
BIOCatsConcurrent → GenConcurrent
final def parTraverseN[T[_], A, B](n: Int)(ta: T[A])(f: (A) => F[Throwable, B])(implicit arg0: Traverse[T]): F[Throwable, T[B]]
Definition Classes
BIOCatsConcurrent → GenConcurrent
final def point[A](x: A): F[Throwable, A]
Definition Classes
BIOCatsApplicative → InvariantMonoidal
Annotations
@inline()
def product[A, B](fa: F[Throwable, A], fb: F[Throwable, B]): F[Throwable, (A, B)]
Definition Classes
FlatMap → Apply → Semigroupal
final def productL[A, B](fa: F[Throwable, A])(fb: F[Throwable, B]): F[Throwable, A]
Definition Classes
BIOCatsApplicative → Apply
Annotations
@inline()
def productLEval[A, B](fa: F[Throwable, A])(fb: Eval[F[Throwable, B]]): F[Throwable, A]
Definition Classes
FlatMap
final def productR[A, B](fa: F[Throwable, A])(fb: F[Throwable, B]): F[Throwable, B]
Definition Classes
BIOCatsApplicative → Apply
Annotations
@inline()
def productREval[A, B](fa: F[Throwable, A])(fb: Eval[F[Throwable, B]]): F[Throwable, B]
Definition Classes
FlatMap
final def pure[A](x: A): F[Throwable, A]
Definition Classes
BIOCatsApplicative → Applicative
Annotations
@inline()
def race[A, B](fa: F[Throwable, A], fb: F[Throwable, B]): F[Throwable, Either[A, B]]
Definition Classes
BIOCatsSpawn → GenSpawn
def raceOutcome[A, B](fa: F[Throwable, A], fb: F[Throwable, B]): F[Throwable, Either[Outcome[[β$36$]F[Throwable, β$36$], Throwable, A], Outcome[[β$37$]F[Throwable, β$37$], Throwable, B]]]
Definition Classes
BIOCatsSpawn → GenSpawn
final def racePair[A, B](fa: F[Throwable, A], fb: F[Throwable, B]): F[Throwable, Either[(Outcome[[β$30$]F[Throwable, β$30$], Throwable, A], Fiber[[β$31$]F[Throwable, β$31$], Throwable, B]), (Fiber[[β$32$]F[Throwable, β$32$], Throwable, A], Outcome[[β$33$]F[Throwable, β$33$], Throwable, B])]]
Definition Classes
BIOCatsSpawn → GenSpawn
Annotations
@inline()
final def raiseError[A](e: Throwable): F[Throwable, A]
Definition Classes
BIOCatsMonadError → ApplicativeError
Annotations
@inline()
def raiseUnless(cond: Boolean)(e: => Throwable): F[Throwable, Unit]
Definition Classes
ApplicativeError
def raiseWhen(cond: Boolean)(e: => Throwable): F[Throwable, Unit]
Definition Classes
ApplicativeError
final def realTime: F[Throwable, FiniteDuration]
Definition Classes
BIOCatsClock → Clock
def realTimeInstant: F[Throwable, Instant]
Definition Classes
ClockPlatform
def recover[A](fa: F[Throwable, A])(pf: PartialFunction[Throwable, A]): F[Throwable, A]
Definition Classes
ApplicativeError
final def recoverWith[A](fa: F[Throwable, A])(pf: PartialFunction[Throwable, F[Throwable, A]]): F[Throwable, A]
Definition Classes
BIOCatsMonadError → ApplicativeError
Annotations
@inline()
def redeem[A, B](fa: F[Throwable, A])(recover: (Throwable) => B, f: (A) => B): F[Throwable, B]
Definition Classes
ApplicativeError
final def redeemWith[A, B](fa: F[Throwable, A])(recover: (Throwable) => F[Throwable, B], bind: (A) => F[Throwable, B]): F[Throwable, B]
Definition Classes
BIOCatsMonadError → MonadError
Annotations
@inline()
final def ref[A](a: A): F[Throwable, Ref[[β$41$]F[Throwable, β$41$], A]]
Definition Classes
BIOCatsConcurrent → GenConcurrent
def replicateA[A](n: Int, fa: F[Throwable, A]): F[Throwable, List[A]]
Definition Classes
Applicative
def replicateA_[A](n: Int, fa: F[Throwable, A]): F[Throwable, Unit]
Definition Classes
Applicative
def rethrow[A, EE <: Throwable](fa: F[Throwable, Either[EE, A]]): F[Throwable, A]
Definition Classes
MonadError
final def rootCancelScope: CancelScope
Definition Classes
GenSpawn → MonadCancel
final def sleep(time: FiniteDuration): F[Throwable, Unit]
Definition Classes
BIOCatsTemporal → GenTemporal
def sleep(time: Duration): F[Throwable, Unit]
Definition Classes
GenTemporal
final def start[A](fa: F[Throwable, A]): F[Throwable, Fiber[[β$29$]F[Throwable, β$29$], Throwable, A]]
Definition Classes
BIOCatsSpawn → GenSpawn
Annotations
@inline()
final def suspend[A](hint: Type)(thunk: => A): F[Throwable, A]
Definition Classes
BIOCatsSync → Sync
Annotations
@inline()
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
final def tailRecM[A, B](a: A)(f: (A) => F[Throwable, Either[A, B]]): F[Throwable, B]
Definition Classes
BIOCatsMonad → FlatMap
Annotations
@inline()
def timed[A](fa: F[Throwable, A]): F[Throwable, (FiniteDuration, A)]
Definition Classes
Clock
final def timeout[A](fa: F[Throwable, A], duration: FiniteDuration)(implicit ev: <:<[TimeoutException, Throwable]): F[Throwable, A]
Definition Classes
BIOCatsTemporal → GenTemporal
def timeout[A](fa: F[Throwable, A], duration: Duration)(implicit ev: <:<[TimeoutException, Throwable]): F[Throwable, A]
Definition Classes
GenTemporal
final def timeoutAndForget[A](fa: F[Throwable, A], duration: FiniteDuration)(implicit ev: <:<[TimeoutException, Throwable]): F[Throwable, A]
Definition Classes
BIOCatsTemporal → GenTemporal
def timeoutAndForget[A](fa: F[Throwable, A], duration: Duration)(implicit ev: <:<[TimeoutException, Throwable]): F[Throwable, A]
Definition Classes
GenTemporal
final def timeoutTo[A](fa: F[Throwable, A], duration: FiniteDuration, fallback: F[Throwable, A]): F[Throwable, A]
Definition Classes
BIOCatsTemporal → GenTemporal
def timeoutTo[A](fa: F[Throwable, A], duration: Duration, fallback: F[Throwable, A]): F[Throwable, A]
Definition Classes
GenTemporal
final def toPoll(restoreInterruption: RestoreInterruption2[F]): Poll[[β$22$]F[Throwable, β$22$]]
Attributes
protected
Definition Classes
BIOCatsMonadCancel
Annotations
@inline()
def toString(): String
Definition Classes
AnyRef → Any
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Definition Classes
ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Definition Classes
ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Definition Classes
ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Definition Classes
ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Definition Classes
ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Definition Classes
ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Definition Classes
ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Definition Classes
ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Definition Classes
ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Definition Classes
ApplyArityFunctions
def tuple2[A, B](f1: F[Throwable, A], f2: F[Throwable, B]): F[Throwable, (A, B)]
Definition Classes
ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Definition Classes
ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19], f20: F[Throwable, A20]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Definition Classes
ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8], f9: F[Throwable, A9], f10: F[Throwable, A10], f11: F[Throwable, A11], f12: F[Throwable, A12], f13: F[Throwable, A13], f14: F[Throwable, A14], f15: F[Throwable, A15], f16: F[Throwable, A16], f17: F[Throwable, A17], f18: F[Throwable, A18], f19: F[Throwable, A19], f20: F[Throwable, A20], f21: F[Throwable, A21]): F[Throwable, (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
def tuple3[A0, A1, A2](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2]): F[Throwable, (A0, A1, A2)]
Definition Classes
ApplyArityFunctions
def tuple4[A0, A1, A2, A3](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3]): F[Throwable, (A0, A1, A2, A3)]
Definition Classes
ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4]): F[Throwable, (A0, A1, A2, A3, A4)]
Definition Classes
ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5]): F[Throwable, (A0, A1, A2, A3, A4, A5)]
Definition Classes
ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6)]
Definition Classes
ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7)]
Definition Classes
ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](f0: F[Throwable, A0], f1: F[Throwable, A1], f2: F[Throwable, A2], f3: F[Throwable, A3], f4: F[Throwable, A4], f5: F[Throwable, A5], f6: F[Throwable, A6], f7: F[Throwable, A7], f8: F[Throwable, A8]): F[Throwable, (A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Definition Classes
ApplyArityFunctions
def tupleLeft[A, B](fa: F[Throwable, A], b: B): F[Throwable, (B, A)]
Definition Classes
Functor
def tupleRight[A, B](fa: F[Throwable, A], b: B): F[Throwable, (A, B)]
Definition Classes
Functor
final def uncancelable[A](body: (Poll[[β$20$]F[Throwable, β$20$]]) => F[Throwable, A]): F[Throwable, A]
Definition Classes
BIOCatsMonadCancel → MonadCancel
Annotations
@inline()
def unique: F[Throwable, Token]
Definition Classes
BIOCatsTemporalImpl → BIOCatsSync → Sync → Unique
final def unit: F[Throwable, Unit]
Definition Classes
BIOCatsApplicative → Applicative → InvariantMonoidal
Annotations
@inline()
final def unlessA[A](cond: Boolean)(f: => F[Throwable, A]): F[Throwable, Unit]
Definition Classes
BIOCatsApplicative → Applicative
Annotations
@inline()
def untilDefinedM[A](foa: F[Throwable, Option[A]]): F[Throwable, A]
Definition Classes
FlatMap
def untilM[G[_], A](f: F[Throwable, A])(cond: => F[Throwable, Boolean])(implicit G: Alternative[G]): F[Throwable, G[A]]
Definition Classes
Monad
def untilM_[A](f: F[Throwable, A])(cond: => F[Throwable, Boolean]): F[Throwable, Unit]
Definition Classes
Monad
def unzip[A, B](fab: F[Throwable, (A, B)]): (F[Throwable, A], F[Throwable, B])
Definition Classes
Functor
final def void[A](fa: F[Throwable, A]): F[Throwable, Unit]
Definition Classes
BIOCatsFunctor → Functor
Annotations
@inline()
def voidError(fu: F[Throwable, Unit]): F[Throwable, Unit]
Definition Classes
ApplicativeError
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
final def whenA[A](cond: Boolean)(f: => F[Throwable, A]): F[Throwable, Unit]
Definition Classes
BIOCatsApplicative → Applicative
Annotations
@inline()
def whileM[G[_], A](p: F[Throwable, Boolean])(body: => F[Throwable, A])(implicit G: Alternative[G]): F[Throwable, G[A]]
Definition Classes
Monad
def whileM_[A](p: F[Throwable, Boolean])(body: => F[Throwable, A]): F[Throwable, Unit]
Definition Classes
Monad
final def widen[A, B >: A](fa: F[Throwable, A]): F[Throwable, B]
Definition Classes
BIOCatsFunctor → Functor
Annotations
@inline()

Deprecated Value Members

def ifA[A](fcond: F[Throwable, Boolean])(ifTrue: F[Throwable, A], ifFalse: F[Throwable, A]): F[Throwable, 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 BIOCatsTemporal[F]

Inherited from BIOCatsConcurrent[F]

Inherited from BIOCatsSpawn[F]

Inherited from GenTemporal[[β$45$]F[Throwable, β$45$], Throwable]

Inherited from GenConcurrent[[β$45$]F[Throwable, β$45$], Throwable]

Inherited from GenSpawn[[β$45$]F[Throwable, β$45$], Throwable]

Inherited from BIOCatsSync[F]

Inherited from Sync[[β$26$]F[Throwable, β$26$]]

Inherited from Defer[[β$26$]F[Throwable, β$26$]]

Inherited from Unique[[β$26$]F[Throwable, β$26$]]

Inherited from BIOCatsClock[F, Throwable]

Inherited from Clock[[β$25$]F[Throwable, β$25$]]

Inherited from ClockPlatform[[β$25$]F[Throwable, β$25$]]

Inherited from BIOCatsMonadCancel[F]

Inherited from MonadCancel[[β$16$]F[Throwable, β$16$], Throwable]

Inherited from BIOCatsMonadError[F, Throwable]

Inherited from MonadError[[β$15$]F[Throwable, β$15$], Throwable]

Inherited from ApplicativeError[[β$15$]F[Throwable, β$15$], Throwable]

Inherited from BIOCatsMonad[F, Throwable]

Inherited from BIOCatsApplicative[F, Throwable]

Inherited from BIOCatsFunctor[F, Throwable]

Inherited from S12

Inherited from S11

Inherited from S10

Inherited from S9

Inherited from S8

Inherited from S7

Inherited from S6

Inherited from S5

Inherited from S4

Inherited from S3

Inherited from S2

Inherited from S1

Inherited from Monad[[β$14$]F[Throwable, β$14$]]

Inherited from Applicative[[β$14$]F[Throwable, β$14$]]

Inherited from InvariantMonoidal[[β$14$]F[Throwable, β$14$]]

Inherited from FlatMap[[β$14$]F[Throwable, β$14$]]

Inherited from FlatMapArityFunctions[[β$14$]F[Throwable, β$14$]]

Inherited from Apply[[β$14$]F[Throwable, β$14$]]

Inherited from ApplyArityFunctions[[β$14$]F[Throwable, β$14$]]

Inherited from InvariantSemigroupal[[β$14$]F[Throwable, β$14$]]

Inherited from Semigroupal[[β$14$]F[Throwable, β$14$]]

Inherited from Functor[[β$14$]F[Throwable, β$14$]]

Inherited from Invariant[[β$14$]F[Throwable, β$14$]]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

BIOCatsTemporalImpl