A typeclass that characterizes monads which support safe cancelation, masking, and finalization. MonadCancel extends the capabilities of cats.MonadError, so an instance of this typeclass must also provide a lawful instance for cats.MonadError.
==Fibers==
A fiber is a sequence of effects which are bound together by flatMap. The execution of a
fiber of an effect F[E, A] terminates with one of three outcomes, which are encoded by the
datatype Outcome:
- Outcome.Succeeded: indicates success with a value of type
A - Outcome.Errored: indicates failure with a value of type
E - Outcome.Canceled: indicates abnormal termination
Additionally, a fiber may never produce an outcome, in which case it is said to be non-terminating.
==Cancelation==
Cancelation refers to the act of requesting that the execution of a fiber be abnormally terminated. MonadCancel exposes a means of self-cancelation, with which a fiber can request that its own execution be terminated. Self-cancelation is achieved via canceled.
Cancelation is vaguely similar to the short-circuiting behavior introduced by cats.MonadError, but there are several key differences:
- Cancelation is effective; if it is observed it must be respected, and it cannot be reversed. In contrast, handleError exposes the ability to catch and recover from errors, and then proceed with normal execution.
- Cancelation can be masked via MonadCancel!.uncancelable. Masking is discussed in the next section.
- GenSpawn introduces external cancelation, another cancelation mechanism by which fibers can be canceled by external parties.
==Masking==
Masking allows a fiber to suppress cancelation for a period of time, which is achieved via uncancelable. If a fiber is canceled while it is masked, the cancelation is suppressed for as long as the fiber remains masked. Once the fiber reaches a completely unmasked state, it responds to the cancelation.
While a fiber is masked, it may optionally unmask by "polling", rendering itself cancelable again.
F.uncancelable { poll =>
// can only observe cancelation within `fb`
fa *> poll(fb) *> fc
}
These semantics allow users to precisely mark what regions of code are cancelable within a larger code block.
==Cancelation Boundaries==
A boundary corresponds to an iteration of the internal runloop. In general they are
introduced by any of the combinators from the cats/cats effect hierarchy (map, flatMap,
handleErrorWith, attempt, etc).
A cancelation boundary is a boundary where the cancelation status of a fiber may be checked and hence cancelation observed. Note that in general you cannot guarantee that cancelation will be observed at a given boundary. However, in the absence of masking it will be observed eventually.
With a small number of exceptions covered below, all boundaries are cancelable boundaries ie cancelation may be observed before the invocation of any combinator.
fa
.flatMap(f)
.handleErrorWith(g)
.map(h)
If the fiber above is canceled then the cancelation status may be checked and the execution terminated between any of the combinators.
As noted above, there are some boundaries which are not cancelable boundaries:
- Any boundary inside
uncancelableand not insidepoll. This is the definition of masking as above.
F.uncancelable( _ =>
fa
.flatMap(f)
.handleErrorWith(g)
.map(h)
)
None of the boundaries above are cancelation boundaries as cancelation is masked.
- The boundary after
uncancelable
F.uncancelable(poll => foo(poll)).flatMap(f)
It is guaranteed that we will not observe cancelation after uncancelable and hence
flatMap(f) will be invoked. This is necessary for uncancelable to compose. Consider for
example Resource#allocated
def allocated[B >: A](implicit F: MonadCancel[F, Throwable]): F[(B, F[Unit])]
which returns a tuple of the resource and a finalizer which needs to be invoked to clean-up
once the resource is no longer needed. The implementation of allocated can make sure it is
safe by appropriate use of uncancelable. However, if it were possible to observe
cancelation on the boundary directly after allocated then we would have a leak as the
caller would be unable to ensure that the finalizer is invoked. In other words, the safety of
allocated and the safety of f would not guarantee the safety of the composition
allocated.flatMap(f).
This does however mean that we violate the functor law that fa.map(identity) <-> fa as
F.uncancelable(_ => fa).onCancel(fin) <-!-> F.uncancelable(_ => fa).map(identity).onCancel(fin)
as cancelation may be observed before the onCancel on the RHS. The justification is that
cancelation is a hint rather than a mandate and so enshrining its behaviour in laws will
always be awkward. Given this, it is better to pick a semantic that allows safe composition
of regions.
- The boundary after
poll
F.uncancelable(poll => poll(fa).flatMap(f))
If fa completes successfully then cancelation may not be observed after poll but before
flatMap. The reasoning is similar to above - if fa has successfully produced a value then
the caller should have the opportunity to observe the value and ensure finalizers are
in-place, etc.
==Finalization==
Finalization refers to the act of running finalizers in response to a cancelation. Finalizers
are those effects whose evaluation is guaranteed in the event of cancelation. After a fiber
has completed finalization, it terminates with an outcome of Canceled.
Finalizers can be registered to a fiber for the duration of some effect via onCancel. If a fiber is canceled while running that effect, the registered finalizer is guaranteed to be run before terminating.
==Bracket pattern==
The aforementioned concepts work together to unlock a powerful pattern for safely interacting with effectful lifecycles: the bracket pattern. This is analogous to the try-with-resources/finally construct in Java.
A lifecycle refers to a pair of actions, which are called the acquisition action and the release action respectively. The relationship between these two actions is that if the former completes successfully, then the latter is guaranteed to be run eventually, even in the presence of errors and cancelation. While the lifecycle is active, other work can be performed, but this invariant is always respected.
The bracket pattern is an invaluable tool for safely handling resource lifecycles. Imagine an application that opens network connections to a database server to do work. If a task in the application is canceled while it holds an open database connection, the connection would never be released or returned to a pool, causing a resource leak.
To illustrate the compositional nature of MonadCancel and its combinators, the implementation of bracket is shown below:
def bracket[A, B](acquire: F[A])(use: A => F[B])(release: A => F[Unit]): F[B] =
uncancelable { poll =>
flatMap(acquire) { a =>
val finalized = onCancel(poll(use(a)), release(a).uncancelable)
val handled = onError(finalized) { case e => void(attempt(release(a).uncancelable)) }
flatMap(handled)(b => as(attempt(release(a).uncancelable), b))
}
}
See bracketCase and bracketFull for other variants of the bracket pattern. If more specialized behavior is necessary, it is recommended to use uncancelable and onCancel directly.
Attributes
- Companion:
- object
- Source:
- MonadCancel.scala
- Graph
- Supertypes
- trait Monad[F]trait FlatMap[F]trait FlatMapArityFunctions[F]trait Applicative[F]trait InvariantMonoidal[F]trait Apply[F]trait ApplyArityFunctions[F]trait InvariantSemigroupal[F]trait Semigroupal[F]trait Functor[F]trait Invariant[F]trait Serializableclass Objecttrait Matchableclass Any
- Known subtypes
Members list
Value members
Abstract methods
An effect that requests self-cancelation on the current fiber.
An effect that requests self-cancelation on the current fiber.
canceled has a return type of F[Unit] instead of F[Nothing] due to execution
continuing in a masked region. In the following example, the fiber requests
self-cancelation in a masked region, so cancelation is suppressed until the fiber is
completely unmasked. fa will run but fb will not. If canceled had a return type of
F[Nothing], then it would not be possible to continue execution to fa (there would be
no Nothing value to pass to the flatMap).
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
Attributes
- Source:
- MonadCancel.scala
An effect that requests self-cancelation on the current fiber.
An effect that requests self-cancelation on the current fiber.
canceled has a return type of F[Unit] instead of F[Nothing] due to execution
continuing in a masked region. In the following example, the fiber requests
self-cancelation in a masked region, so cancelation is suppressed until the fiber is
completely unmasked. fa will run but fb will not. If canceled had a return type of
F[Nothing], then it would not be possible to continue execution to fa (there would be
no Nothing value to pass to the flatMap).
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
Attributes
- Source:
- MonadCancel.scala
An effect that requests self-cancelation on the current fiber.
An effect that requests self-cancelation on the current fiber.
canceled has a return type of F[Unit] instead of F[Nothing] due to execution
continuing in a masked region. In the following example, the fiber requests
self-cancelation in a masked region, so cancelation is suppressed until the fiber is
completely unmasked. fa will run but fb will not. If canceled had a return type of
F[Nothing], then it would not be possible to continue execution to fa (there would be
no Nothing value to pass to the flatMap).
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
Attributes
- Source:
- MonadCancel.scala
An effect that requests self-cancelation on the current fiber.
An effect that requests self-cancelation on the current fiber.
canceled has a return type of F[Unit] instead of F[Nothing] due to execution
continuing in a masked region. In the following example, the fiber requests
self-cancelation in a masked region, so cancelation is suppressed until the fiber is
completely unmasked. fa will run but fb will not. If canceled had a return type of
F[Nothing], then it would not be possible to continue execution to fa (there would be
no Nothing value to pass to the flatMap).
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
Attributes
- Source:
- MonadCancel.scala
An effect that requests self-cancelation on the current fiber.
An effect that requests self-cancelation on the current fiber.
canceled has a return type of F[Unit] instead of F[Nothing] due to execution
continuing in a masked region. In the following example, the fiber requests
self-cancelation in a masked region, so cancelation is suppressed until the fiber is
completely unmasked. fa will run but fb will not. If canceled had a return type of
F[Nothing], then it would not be possible to continue execution to fa (there would be
no Nothing value to pass to the flatMap).
F.uncancelable { _ =>
F.canceled *> fa
} *> fb
Attributes
- Source:
- MonadCancel.scala
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Attributes
- Source:
- MonadCancel.scala
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Attributes
- Source:
- MonadCancel.scala
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Attributes
- Source:
- MonadCancel.scala
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Attributes
- Source:
- MonadCancel.scala
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Analogous to productR, but suppresses short-circuiting behavior except for cancelation.
Attributes
- Source:
- MonadCancel.scala
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.
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.
Attributes
- fa
The effect that is evaluated after
finis registered.- fin
The finalizer to register before evaluating
fa.- Source:
- MonadCancel.scala
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.
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.
Attributes
- fa
The effect that is evaluated after
finis registered.- fin
The finalizer to register before evaluating
fa.- Source:
- MonadCancel.scala
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.
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.
Attributes
- fa
The effect that is evaluated after
finis registered.- fin
The finalizer to register before evaluating
fa.- Source:
- MonadCancel.scala
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.
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.
Attributes
- fa
The effect that is evaluated after
finis registered.- fin
The finalizer to register before evaluating
fa.- Source:
- MonadCancel.scala
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.
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.
Attributes
- fa
The effect that is evaluated after
finis registered.- fin
The finalizer to register before evaluating
fa.- Source:
- MonadCancel.scala
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.
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.
Attributes
- Source:
- MonadCancel.scala
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.
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.
Attributes
- Source:
- MonadCancel.scala
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.
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.
Attributes
- Source:
- MonadCancel.scala
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.
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.
Attributes
- Source:
- MonadCancel.scala
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.
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.
Attributes
- Source:
- MonadCancel.scala
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.
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:
- Polling in the wrong order
- Subsequent polls when applying the same poll more than once:
poll(poll(fa))is equivalent topoll(fa) - Applying a poll bound to one fiber within another fiber
Attributes
- body
A function which takes a Poll and returns the effect that we wish to make uncancelable.
- Source:
- MonadCancel.scala
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.
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:
- Polling in the wrong order
- Subsequent polls when applying the same poll more than once:
poll(poll(fa))is equivalent topoll(fa) - Applying a poll bound to one fiber within another fiber
Attributes
- body
A function which takes a Poll and returns the effect that we wish to make uncancelable.
- Source:
- MonadCancel.scala
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.
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:
- Polling in the wrong order
- Subsequent polls when applying the same poll more than once:
poll(poll(fa))is equivalent topoll(fa) - Applying a poll bound to one fiber within another fiber
Attributes
- body
A function which takes a Poll and returns the effect that we wish to make uncancelable.
- Source:
- MonadCancel.scala
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.
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:
- Polling in the wrong order
- Subsequent polls when applying the same poll more than once:
poll(poll(fa))is equivalent topoll(fa) - Applying a poll bound to one fiber within another fiber
Attributes
- body
A function which takes a Poll and returns the effect that we wish to make uncancelable.
- Source:
- MonadCancel.scala
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.
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:
- Polling in the wrong order
- Subsequent polls when applying the same poll more than once:
poll(poll(fa))is equivalent topoll(fa) - Applying a poll bound to one fiber within another fiber
Attributes
- body
A function which takes a Poll and returns the effect that we wish to make uncancelable.
- Source:
- MonadCancel.scala
Concrete methods
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action
- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketCase for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action
- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketCase for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action
- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketCase for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action
- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketCase for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action
- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketCase for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketFull for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketFull for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketFull for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketFull for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- See also:
bracketFull for a more powerful variant
Resource for a composable datatype encoding of effectful lifecycles
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action which can be canceled
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action which can be canceled
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action which can be canceled
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action which can be canceled
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- Source:
- MonadCancel.scala
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.
Attributes
- acquire
the lifecycle acquisition action which can be canceled
- release
the lifecycle release action which depends on the outcome of
use- use
the effect to which the lifecycle is scoped, whose result is the return value of this function
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
The effect to run in the event of a cancelation or error.
- See also:
guaranteeCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
The effect to run in the event of a cancelation or error.
- See also:
guaranteeCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
The effect to run in the event of a cancelation or error.
- See also:
guaranteeCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
The effect to run in the event of a cancelation or error.
- See also:
guaranteeCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
The effect to run in the event of a cancelation or error.
- See also:
guaranteeCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
A function that returns the effect to run based on the outcome.
- See also:
bracketCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
A function that returns the effect to run based on the outcome.
- See also:
bracketCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
A function that returns the effect to run based on the outcome.
- See also:
bracketCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
A function that returns the effect to run based on the outcome.
- See also:
bracketCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
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.
Attributes
- fa
The effect that is run after
finis registered.- fin
A function that returns the effect to run based on the outcome.
- See also:
bracketCase for a more powerful variant
Outcome for the various outcomes of evaluation
- Source:
- MonadCancel.scala
Inherited methods
Alias for productR.
Alias for productR.
Alias for productR.
Alias for productR.
Alias for productR.
Alias for productL.
Alias for productL.
Alias for productL.
Alias for productL.
Alias for productL.
Alias for ap.
Alias for ap.
Alias for ap.
Alias for ap.
Alias for ap.
Transform certain errors using pf and rethrow them.
Non matching errors and successful values are not affected by this function.
Transform certain errors using pf and rethrow them.
Non matching errors and successful values are not affected by this function.
Example:
scala> import cats._, implicits._
scala> def pf: PartialFunction[String, String] = { case "error" => "ERROR" }
scala> ApplicativeError[Either[String, *], String].adaptError("error".asLeft[Int])(pf)
res0: Either[String,Int] = Left(ERROR)
scala> ApplicativeError[Either[String, *], String].adaptError("err".asLeft[Int])(pf)
res1: Either[String,Int] = Left(err)
scala> ApplicativeError[Either[String, *], String].adaptError(1.asRight[String])(pf)
res2: Either[String,Int] = Right(1)
The same function is available in ApplicativeErrorOps as adaptErr - it cannot have the same
name because this would result in ambiguous implicits due to adaptError
having originally been included in the MonadError API and syntax.
Attributes
- Definition Classes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Given a value and a function in the Apply context, applies the function to the value.
Given a value and a function in the Apply context, applies the function to the value.
Example:
scala> import cats.implicits._
scala> val someF: Option[Int => Long] = Some(_.toLong + 1L)
scala> val noneF: Option[Int => Long] = None
scala> val someInt: Option[Int] = Some(3)
scala> val noneInt: Option[Int] = None
scala> Apply[Option].ap(someF)(someInt)
res0: Option[Long] = Some(4)
scala> Apply[Option].ap(noneF)(someInt)
res1: Option[Long] = None
scala> Apply[Option].ap(someF)(noneInt)
res2: Option[Long] = None
scala> Apply[Option].ap(noneF)(noneInt)
res3: Option[Long] = None
Attributes
- Definition Classes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
ap2 is a binary version of ap, defined in terms of ap.
ap2 is a binary version of ap, defined in terms of ap.
Attributes
- Definition Classes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Replaces the A value in F[A] with the supplied value.
Replaces the A value in F[A] with the supplied value.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Replaces the A value in F[A] with the supplied value.
Replaces the A value in F[A] with the supplied value.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Replaces the A value in F[A] with the supplied value.
Replaces the A value in F[A] with the supplied value.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Replaces the A value in F[A] with the supplied value.
Replaces the A value in F[A] with the supplied value.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Replaces the A value in F[A] with the supplied value.
Replaces the A value in F[A] with the supplied value.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Handle errors by turning them into scala.util.Either values.
Handle errors by turning them into scala.util.Either values.
If there is no error, then an scala.util.Right value will be returned instead.
All non-fatal errors should be handled by this method.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle errors by turning them into scala.util.Either values.
Handle errors by turning them into scala.util.Either values.
If there is no error, then an scala.util.Right value will be returned instead.
All non-fatal errors should be handled by this method.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle errors by turning them into scala.util.Either values.
Handle errors by turning them into scala.util.Either values.
If there is no error, then an scala.util.Right value will be returned instead.
All non-fatal errors should be handled by this method.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle errors by turning them into scala.util.Either values.
Handle errors by turning them into scala.util.Either values.
If there is no error, then an scala.util.Right value will be returned instead.
All non-fatal errors should be handled by this method.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle errors by turning them into scala.util.Either values.
Handle errors by turning them into scala.util.Either values.
If there is no error, then an scala.util.Right value will be returned instead.
All non-fatal errors should be handled by this method.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but it only handles errors of type EE.
Similar to attempt, but it only handles errors of type EE.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but it only handles errors of type EE.
Similar to attempt, but it only handles errors of type EE.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but it only handles errors of type EE.
Similar to attempt, but it only handles errors of type EE.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but it only handles errors of type EE.
Similar to attempt, but it only handles errors of type EE.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but it only handles errors of type EE.
Similar to attempt, but it only handles errors of type EE.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Similar to attempt, but wraps the result in a cats.data.EitherT for convenience.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Note that if the effect returned by f fails, the resulting effect will fail too.
Alias for fa.attempt.flatTap(f).rethrow for convenience.
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Note that if the effect returned by f fails, the resulting effect will fail too.
Alias for fa.attempt.flatTap(f).rethrow for convenience.
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Note that if the effect returned by f fails, the resulting effect will fail too.
Alias for fa.attempt.flatTap(f).rethrow for convenience.
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Note that if the effect returned by f fails, the resulting effect will fail too.
Alias for fa.attempt.flatTap(f).rethrow for convenience.
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Reifies the value or error of the source and performs an effect on the result,
then recovers the original value or error back into F.
Note that if the effect returned by f fails, the resulting effect will fail too.
Alias for fa.attempt.flatTap(f).rethrow for convenience.
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success, Failure}
scala> def checkError(result: Either[Throwable, Int]): Try[String] = result.fold(_ => Failure(new java.lang.Exception), _ => Success("success"))
scala> val a: Try[Int] = Failure(new Throwable("failed"))
scala> a.attemptTap(checkError)
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Int] = Success(1)
scala> b.attemptTap(checkError)
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Often E is Throwable. Here we try to call pure or catch and raise.
Often E is Throwable. Here we try to call pure or catch and raise.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise.
Often E is Throwable. Here we try to call pure or catch and raise.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise.
Often E is Throwable. Here we try to call pure or catch and raise.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise.
Often E is Throwable. Here we try to call pure or catch and raise.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise.
Often E is Throwable. Here we try to call pure or catch and raise.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise
Often E is Throwable. Here we try to call pure or catch and raise
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise
Often E is Throwable. Here we try to call pure or catch and raise
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise
Often E is Throwable. Here we try to call pure or catch and raise
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise
Often E is Throwable. Here we try to call pure or catch and raise
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Often E is Throwable. Here we try to call pure or catch and raise
Often E is Throwable. Here we try to call pure or catch and raise
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Evaluates the specified block, catching exceptions of the specified type. Uncaught exceptions are propagated.
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Applicative[List].compose[Option]
scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Apply[List].compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Apply
- Source:
- Apply.scala
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Applicative[List].compose[Option]
scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Apply[List].compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Apply
- Source:
- Apply.scala
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Applicative[List].compose[Option]
scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Apply[List].compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Apply
- Source:
- Apply.scala
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Applicative[List].compose[Option]
scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Apply[List].compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Apply
- Source:
- Apply.scala
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Compose an Applicative[F] and an Applicative[G] into an
Applicative[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Applicative[List].compose[Option]
scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].
Example:
scala> import cats.implicits._
scala> val alo = Apply[List].compose[Option]
scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Attributes
- Inherited from:
- Apply
- Source:
- Apply.scala
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Attributes
- Inherited from:
- InvariantSemigroupal
- Source:
- InvariantSemigroupal.scala
Attributes
- Inherited from:
- InvariantSemigroupal
- Source:
- InvariantSemigroupal.scala
Attributes
- Inherited from:
- InvariantSemigroupal
- Source:
- InvariantSemigroupal.scala
Attributes
- Inherited from:
- InvariantSemigroupal
- Source:
- InvariantSemigroupal.scala
Attributes
- Inherited from:
- InvariantSemigroupal
- Source:
- InvariantSemigroupal.scala
Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]]
using F's imap and G's contramap.
Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]]
using F's imap and G's contramap.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> type ToInt[T] = T => Int
scala> val durSemigroupToInt: Semigroup[ToInt[FiniteDuration]] =
| Invariant[Semigroup]
| .composeContravariant[ToInt]
| .imap(Semigroup[ToInt[Long]])(Duration.fromNanos)(_.toNanos)
// semantically equal to (2.seconds.toSeconds.toInt + 1) + (2.seconds.toSeconds.toInt * 2) = 7
scala> durSemigroupToInt.combine(_.toSeconds.toInt + 1, _.toSeconds.toInt * 2)(2.seconds)
res1: Int = 7
Attributes
- Definition Classes
- Inherited from:
- Functor
- Source:
- Functor.scala
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Example:
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)
scala> val stringOrders: List[Order[String]] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List].composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Example:
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)
scala> val stringOrders: List[Order[String]] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List].composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Example:
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)
scala> val stringOrders: List[Order[String]] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List].composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Example:
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)
scala> val stringOrders: List[Order[String]] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List].composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Compose an Applicative[F] and a ContravariantMonoidal[G] into a
ContravariantMonoidal[λ[α => F[G[α]]]].
Example:
scala> import cats.kernel.Comparison
scala> import cats.implicits._
// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]
// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)
scala> val stringOrders: List[Order[String]] = List(alpha, strLength)
// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)
scala> val le = Applicative[List].composeContravariantMonoidal[Order]
// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)
// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)
// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)
scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]]
using F's imap and G's map.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup]
| .composeFunctor[List]
| .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
Attributes
- Inherited from:
- Invariant
- Source:
- Invariant.scala
Turns a successful value into an error if it does not satisfy a given predicate.
Turns a successful value into an error if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error if it does not satisfy a given predicate.
Turns a successful value into an error if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error if it does not satisfy a given predicate.
Turns a successful value into an error if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error if it does not satisfy a given predicate.
Turns a successful value into an error if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error if it does not satisfy a given predicate.
Turns a successful value into an error if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Turns a successful value into an error specified by the error function if it does not satisfy a given predicate.
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Attributes
- Inherited from:
- FlatMapArityFunctions
- Source:
- FlatMapArityFunctions.scala
Apply a monadic function and discard the result while keeping the effect.
Apply a monadic function and discard the result while keeping the effect.
scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Apply a monadic function and discard the result while keeping the effect.
Apply a monadic function and discard the result while keeping the effect.
scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Apply a monadic function and discard the result while keeping the effect.
Apply a monadic function and discard the result while keeping the effect.
scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Apply a monadic function and discard the result while keeping the effect.
Apply a monadic function and discard the result while keeping the effect.
scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Apply a monadic function and discard the result while keeping the effect.
Apply a monadic function and discard the result while keeping the effect.
scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
"flatten" a nested F of F structure into a single-layer F structure.
"flatten" a nested F of F structure into a single-layer F structure.
This is also commonly called join.
Example:
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
"flatten" a nested F of F structure into a single-layer F structure.
"flatten" a nested F of F structure into a single-layer F structure.
This is also commonly called join.
Example:
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
"flatten" a nested F of F structure into a single-layer F structure.
"flatten" a nested F of F structure into a single-layer F structure.
This is also commonly called join.
Example:
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
"flatten" a nested F of F structure into a single-layer F structure.
"flatten" a nested F of F structure into a single-layer F structure.
This is also commonly called join.
Example:
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
"flatten" a nested F of F structure into a single-layer F structure.
"flatten" a nested F of F structure into a single-layer F structure.
This is also commonly called join.
Example:
scala> import cats.Eval
scala> import cats.implicits._
scala> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Example:
scala> import cats.implicits._
scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Example:
scala> import cats.implicits._
scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Example:
scala> import cats.implicits._
scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Example:
scala> import cats.implicits._
scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Alias for map, since map can't be injected as syntax if
the implementing type already had a built-in .map method.
Example:
scala> import cats.implicits._
scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")
scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing].
Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing].
Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing].
Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing].
Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.
This will be an infinite loop, or it will return an F[Nothing].
Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Pair the result of function application with A.
Pair the result of function application with A.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Pair the result of function application with A.
Pair the result of function application with A.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Pair the result of function application with A.
Pair the result of function application with A.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Pair the result of function application with A.
Pair the result of function application with A.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Pair the result of function application with A.
Pair the result of function application with A.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Convert from scala.Either
Convert from scala.Either
Example:
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Either
Convert from scala.Either
Example:
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Either
Convert from scala.Either
Example:
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Either
Convert from scala.Either
Example:
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Either
Convert from scala.Either
Example:
scala> import cats.ApplicativeError
scala> import cats.instances.option._
scala> ApplicativeError[Option, Unit].fromEither(Right(1))
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromEither(Left(()))
res1: scala.Option[Nothing] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Option
Convert from scala.Option
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Option
Convert from scala.Option
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Option
Convert from scala.Option
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Option
Convert from scala.Option
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from scala.Option
Convert from scala.Option
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> val F = ApplicativeError[Either[String, *], String]
scala> F.fromOption(Some(1), "Empty")
res0: scala.Either[String, Int] = Right(1)
scala> F.fromOption(Option.empty[Int], "Empty")
res1: scala.Either[String, Int] = Left(Empty)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
If the error type is Throwable, we can convert from a scala.util.Try
If the error type is Throwable, we can convert from a scala.util.Try
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
If the error type is Throwable, we can convert from a scala.util.Try
If the error type is Throwable, we can convert from a scala.util.Try
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
If the error type is Throwable, we can convert from a scala.util.Try
If the error type is Throwable, we can convert from a scala.util.Try
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
If the error type is Throwable, we can convert from a scala.util.Try
If the error type is Throwable, we can convert from a scala.util.Try
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
If the error type is Throwable, we can convert from a scala.util.Try
If the error type is Throwable, we can convert from a scala.util.Try
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from cats.data.Validated
Convert from cats.data.Validated
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from cats.data.Validated
Convert from cats.data.Validated
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from cats.data.Validated
Convert from cats.data.Validated
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from cats.data.Validated
Convert from cats.data.Validated
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Convert from cats.data.Validated
Convert from cats.data.Validated
Example:
scala> import cats.implicits._
scala> import cats.ApplicativeError
scala> ApplicativeError[Option, Unit].fromValidated(1.valid[Unit])
res0: scala.Option[Int] = Some(1)
scala> ApplicativeError[Option, Unit].fromValidated(().invalid[Int])
res1: scala.Option[Int] = None
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, by mapping it to an A value.
Handle any error, by mapping it to an A value.
Attributes
- See also:
handleErrorWith to map to an
F[A]value instead of simply anAvalue.recover to only recover from certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, by mapping it to an A value.
Handle any error, by mapping it to an A value.
Attributes
- See also:
handleErrorWith to map to an
F[A]value instead of simply anAvalue.recover to only recover from certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, by mapping it to an A value.
Handle any error, by mapping it to an A value.
Attributes
- See also:
handleErrorWith to map to an
F[A]value instead of simply anAvalue.recover to only recover from certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, by mapping it to an A value.
Handle any error, by mapping it to an A value.
Attributes
- See also:
handleErrorWith to map to an
F[A]value instead of simply anAvalue.recover to only recover from certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, by mapping it to an A value.
Handle any error, by mapping it to an A value.
Attributes
- See also:
handleErrorWith to map to an
F[A]value instead of simply anAvalue.recover to only recover from certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Attributes
- See also:
handleError to handle any error by simply mapping it to an
Avalue instead of anF[A].recoverWith to recover from only certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Attributes
- See also:
handleError to handle any error by simply mapping it to an
Avalue instead of anF[A].recoverWith to recover from only certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Attributes
- See also:
handleError to handle any error by simply mapping it to an
Avalue instead of anF[A].recoverWith to recover from only certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Attributes
- See also:
handleError to handle any error by simply mapping it to an
Avalue instead of anF[A].recoverWith to recover from only certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Handle any error, potentially recovering from it, by mapping it to an
F[A] value.
Attributes
- See also:
handleError to handle any error by simply mapping it to an
Avalue instead of anF[A].recoverWith to recover from only certain errors.
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin
Attributes
- See also:
See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inherited from:
- Monad
- Source:
- Monad.scala
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin
Attributes
- See also:
See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inherited from:
- Monad
- Source:
- Monad.scala
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin
Attributes
- See also:
See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inherited from:
- Monad
- Source:
- Monad.scala
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin
Attributes
- See also:
See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inherited from:
- Monad
- Source:
- Monad.scala
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.
scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2
Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin
Attributes
- See also:
See https://gitter.im/typelevel/cats-effect?at=5f297e4314c413356f56d230 for the discussion.
- Inherited from:
- Monad
- Source:
- Monad.scala
Lifts if to Functor
Lifts if to Functor
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lifts if to Functor
Lifts if to Functor
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lifts if to Functor
Lifts if to Functor
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lifts if to Functor
Lifts if to Functor
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lifts if to Functor
Lifts if to Functor
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
if lifted into monad.
if lifted into monad.
if lifted into monad.
if lifted into monad.
if lifted into monad.
Transform an F[A] into an F[B] by providing a transformation from A
to B and one from B to A.
Transform an F[A] into an F[B] by providing a transformation from A
to B and one from B to A.
Example:
scala> import cats.implicits._
scala> import scala.concurrent.duration._
scala> val durSemigroup: Semigroup[FiniteDuration] =
| Invariant[Semigroup].imap(Semigroup[Long])(Duration.fromNanos)(_.toNanos)
scala> durSemigroup.combine(2.seconds, 3.seconds)
res1: FiniteDuration = 5 seconds
Attributes
- Definition Classes
- Inherited from:
- Functor
- Source:
- Functor.scala
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Apply a monadic function iteratively until its result satisfies the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Attributes
- Definition Classes
- Inherited from:
- Monad
- Source:
- Monad.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Applies the pure (binary) function f to the effectful values fa and fb.
Applies the pure (binary) function f to the effectful values fa and fb.
map2 can be seen as a binary version of cats.Functor#map.
Example:
scala> import cats.implicits._
scala> val someInt: Option[Int] = Some(3)
scala> val noneInt: Option[Int] = None
scala> val someLong: Option[Long] = Some(4L)
scala> val noneLong: Option[Long] = None
scala> Apply[Option].map2(someInt, someLong)((i, l) => i.toString + l.toString)
res0: Option[String] = Some(34)
scala> Apply[Option].map2(someInt, noneLong)((i, l) => i.toString + l.toString)
res0: Option[String] = None
scala> Apply[Option].map2(noneInt, noneLong)((i, l) => i.toString + l.toString)
res0: Option[String] = None
scala> Apply[Option].map2(noneInt, someLong)((i, l) => i.toString + l.toString)
res0: Option[String] = None
Attributes
- Definition Classes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Similar to map2 but uses Eval to allow for laziness in the F[B]
argument. This can allow for "short-circuiting" of computations.
Similar to map2 but uses Eval to allow for laziness in the F[B]
argument. This can allow for "short-circuiting" of computations.
NOTE: the default implementation of map2Eval does not short-circuit
computations. For data structures that can benefit from laziness, Apply
instances should override this method.
In the following example, x.map2(bomb)(_ + _) would result in an error,
but map2Eval "short-circuits" the computation. x is None and thus the
result of bomb doesn't even need to be evaluated in order to determine
that the result of map2Eval should be None.
scala> import cats.{Eval, Later}
scala> import cats.implicits._
scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom"))
scala> val x: Option[Int] = None
scala> x.map2Eval(bomb)(_ + _).value
res0: Option[Int] = None
Attributes
- Definition Classes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Pair A with the result of function application.
Pair A with the result of function application.
Example:
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Pair A with the result of function application.
Pair A with the result of function application.
Example:
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Pair A with the result of function application.
Pair A with the result of function application.
Example:
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Pair A with the result of function application.
Pair A with the result of function application.
Example:
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Pair A with the result of function application.
Pair A with the result of function application.
Example:
scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:
scala> import cats._, data._, implicits._
scala> case class Err(msg: String)
scala> type F[A] = EitherT[State[String, *], Err, A]
scala> val action: PartialFunction[Err, F[Unit]] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:
scala> import cats._, data._, implicits._
scala> case class Err(msg: String)
scala> type F[A] = EitherT[State[String, *], Err, A]
scala> val action: PartialFunction[Err, F[Unit]] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:
scala> import cats._, data._, implicits._
scala> case class Err(msg: String)
scala> type F[A] = EitherT[State[String, *], Err, A]
scala> val action: PartialFunction[Err, F[Unit]] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:
scala> import cats._, data._, implicits._
scala> case class Err(msg: String)
scala> type F[A] = EitherT[State[String, *], Err, A]
scala> val action: PartialFunction[Err, F[Unit]] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
Execute a callback on certain errors, then rethrow them. Any non matching error is rethrown as well.
In the following example, only one of the errors is logged, but they are both rethrown, to be possibly handled by another layer of the program:
scala> import cats._, data._, implicits._
scala> case class Err(msg: String)
scala> type F[A] = EitherT[State[String, *], Err, A]
scala> val action: PartialFunction[Err, F[Unit]] = {
| case Err("one") => EitherT.liftF(State.set("one"))
| }
scala> val prog1: F[Int] = (Err("one")).raiseError[F, Int]
scala> val prog2: F[Int] = (Err("two")).raiseError[F, Int]
scala> prog1.onError(action).value.run("").value
res0: (String, Either[Err,Int]) = (one,Left(Err(one)))
scala> prog2.onError(action).value.run("").value
res1: (String, Either[Err,Int]) = ("",Left(Err(two)))
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
point lifts any value into a Monoidal Functor.
point lifts any value into a Monoidal Functor.
Example:
scala> import cats.implicits._
scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- InvariantMonoidal
- Source:
- InvariantMonoidal.scala
point lifts any value into a Monoidal Functor.
point lifts any value into a Monoidal Functor.
Example:
scala> import cats.implicits._
scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- InvariantMonoidal
- Source:
- InvariantMonoidal.scala
point lifts any value into a Monoidal Functor.
point lifts any value into a Monoidal Functor.
Example:
scala> import cats.implicits._
scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- InvariantMonoidal
- Source:
- InvariantMonoidal.scala
point lifts any value into a Monoidal Functor.
point lifts any value into a Monoidal Functor.
Example:
scala> import cats.implicits._
scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- InvariantMonoidal
- Source:
- InvariantMonoidal.scala
point lifts any value into a Monoidal Functor.
point lifts any value into a Monoidal Functor.
Example:
scala> import cats.implicits._
scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- InvariantMonoidal
- Source:
- InvariantMonoidal.scala
Combine an F[A] and an F[B] into an F[(A, B)] that maintains the effects of both fa and fb.
Combine an F[A] and an F[B] into an F[(A, B)] that maintains the effects of both fa and fb.
Example:
scala> import cats.implicits._
scala> val noneInt: Option[Int] = None
scala> val some3: Option[Int] = Some(3)
scala> val noneString: Option[String] = None
scala> val someFoo: Option[String] = Some("foo")
scala> Semigroupal[Option].product(noneInt, noneString)
res0: Option[(Int, String)] = None
scala> Semigroupal[Option].product(noneInt, someFoo)
res1: Option[(Int, String)] = None
scala> Semigroupal[Option].product(some3, noneString)
res2: Option[(Int, String)] = None
scala> Semigroupal[Option].product(some3, someFoo)
res3: Option[(Int, String)] = Some((3,foo))
Attributes
- Definition Classes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Compose two actions, discarding any value produced by the second.
Compose two actions, discarding any value produced by the second.
Attributes
- See also:
productR to discard the value of the first instead. Example:
scala> import cats.implicits._ scala> import cats.data.Validated scala> import Validated.{Valid, Invalid} scala> type ErrOr[A] = Validated[String, A] scala> val validInt: ErrOr[Int] = Valid(3) scala> val validBool: ErrOr[Boolean] = Valid(true) scala> val invalidInt: ErrOr[Int] = Invalid("Invalid int.") scala> val invalidBool: ErrOr[Boolean] = Invalid("Invalid boolean.") scala> Apply[ErrOr].productL(validInt)(validBool) res0: ErrOr[Int] = Valid(3) scala> Apply[ErrOr].productL(invalidInt)(validBool) res1: ErrOr[Int] = Invalid(Invalid int.) scala> Apply[ErrOr].productL(validInt)(invalidBool) res2: ErrOr[Int] = Invalid(Invalid boolean.) scala> Apply[ErrOr].productL(invalidInt)(invalidBool) res3: ErrOr[Int] = Invalid(Invalid int.Invalid boolean.)- Definition Classes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Compose two actions, discarding any value produced by the first.
Compose two actions, discarding any value produced by the first.
Attributes
- See also:
productL to discard the value of the second instead. Example:
scala> import cats.implicits._ scala> import cats.data.Validated scala> import Validated.{Valid, Invalid} scala> type ErrOr[A] = Validated[String, A] scala> val validInt: ErrOr[Int] = Valid(3) scala> val validBool: ErrOr[Boolean] = Valid(true) scala> val invalidInt: ErrOr[Int] = Invalid("Invalid int.") scala> val invalidBool: ErrOr[Boolean] = Invalid("Invalid boolean.") scala> Apply[ErrOr].productR(validInt)(validBool) res0: ErrOr[Boolean] = Valid(true) scala> Apply[ErrOr].productR(invalidInt)(validBool) res1: ErrOr[Boolean] = Invalid(Invalid int.) scala> Apply[ErrOr].productR(validInt)(invalidBool) res2: ErrOr[Boolean] = Invalid(Invalid boolean.) scala> Apply[ErrOr].productR(invalidInt)(invalidBool) res3: ErrOr[Boolean] = Invalid(Invalid int.Invalid boolean.)- Definition Classes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:
scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
pure lifts any value into the Applicative Functor.
pure lifts any value into the Applicative Functor.
Example:
scala> import cats.implicits._
scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
pure lifts any value into the Applicative Functor.
pure lifts any value into the Applicative Functor.
Example:
scala> import cats.implicits._
scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
pure lifts any value into the Applicative Functor.
pure lifts any value into the Applicative Functor.
Example:
scala> import cats.implicits._
scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
pure lifts any value into the Applicative Functor.
pure lifts any value into the Applicative Functor.
Example:
scala> import cats.implicits._
scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
pure lifts any value into the Applicative Functor.
pure lifts any value into the Applicative Functor.
Example:
scala> import cats.implicits._
scala> Applicative[Option].pure(10)
res0: Option[Int] = Some(10)
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Lift an error into the F context.
Lift an error into the F context.
Example:
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_]](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String]): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A] = Either[String, A]
scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Lift an error into the F context.
Lift an error into the F context.
Example:
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_]](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String]): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A] = Either[String, A]
scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Lift an error into the F context.
Lift an error into the F context.
Example:
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_]](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String]): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A] = Either[String, A]
scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Lift an error into the F context.
Lift an error into the F context.
Example:
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_]](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String]): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A] = Either[String, A]
scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Lift an error into the F context.
Lift an error into the F context.
Example:
scala> import cats.implicits._
// integer-rounded division
scala> def divide[F[_]](dividend: Int, divisor: Int)(implicit F: ApplicativeError[F, String]): F[Int] =
| if (divisor === 0) F.raiseError("division by zero")
| else F.pure(dividend / divisor)
scala> type ErrorOr[A] = Either[String, A]
scala> divide[ErrorOr](6, 3)
res0: ErrorOr[Int] = Right(2)
scala> divide[ErrorOr](6, 0)
res1: ErrorOr[Int] = Left(division by zero)
Attributes
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when cond is false, otherwise F.unit
Returns raiseError when cond is false, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when cond is false, otherwise F.unit
Returns raiseError when cond is false, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when cond is false, otherwise F.unit
Returns raiseError when cond is false, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when cond is false, otherwise F.unit
Returns raiseError when cond is false, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when cond is false, otherwise F.unit
Returns raiseError when cond is false, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when the cond is true, otherwise F.unit
Returns raiseError when the cond is true, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when the cond is true, otherwise F.unit
Returns raiseError when the cond is true, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when the cond is true, otherwise F.unit
Returns raiseError when the cond is true, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when the cond is true, otherwise F.unit
Returns raiseError when the cond is true, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns raiseError when the cond is true, otherwise F.unit
Returns raiseError when the cond is true, otherwise F.unit
Attributes
- Example:
val tooMany = 5 val x: Int = ??? F.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an A value.
Recover from certain errors by mapping them to an A value.
Attributes
- See also:
handleError to handle any/all errors.
recoverWith to recover from certain errors by mapping them to
F[A]values.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an A value.
Recover from certain errors by mapping them to an A value.
Attributes
- See also:
handleError to handle any/all errors.
recoverWith to recover from certain errors by mapping them to
F[A]values.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an A value.
Recover from certain errors by mapping them to an A value.
Attributes
- See also:
handleError to handle any/all errors.
recoverWith to recover from certain errors by mapping them to
F[A]values.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an A value.
Recover from certain errors by mapping them to an A value.
Attributes
- See also:
handleError to handle any/all errors.
recoverWith to recover from certain errors by mapping them to
F[A]values.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an A value.
Recover from certain errors by mapping them to an A value.
Attributes
- See also:
handleError to handle any/all errors.
recoverWith to recover from certain errors by mapping them to
F[A]values.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an F[A] value.
Recover from certain errors by mapping them to an F[A] value.
Attributes
- See also:
handleErrorWith to handle any/all errors.
recover to recover from certain errors by mapping them to
Avalues.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an F[A] value.
Recover from certain errors by mapping them to an F[A] value.
Attributes
- See also:
handleErrorWith to handle any/all errors.
recover to recover from certain errors by mapping them to
Avalues.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an F[A] value.
Recover from certain errors by mapping them to an F[A] value.
Attributes
- See also:
handleErrorWith to handle any/all errors.
recover to recover from certain errors by mapping them to
Avalues.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an F[A] value.
Recover from certain errors by mapping them to an F[A] value.
Attributes
- See also:
handleErrorWith to handle any/all errors.
recover to recover from certain errors by mapping them to
Avalues.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Recover from certain errors by mapping them to an F[A] value.
Recover from certain errors by mapping them to an F[A] value.
Attributes
- See also:
handleErrorWith to handle any/all errors.
recover to recover from certain errors by mapping them to
Avalues.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and map, this equivalence being available:
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
Usage of redeem subsumes handleError because:
fa.redeem(fe, id) <-> fa.handleError(fe)
Implementations are free to override it in order to optimize error recovery.
Attributes
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and map, this equivalence being available:
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
Usage of redeem subsumes handleError because:
fa.redeem(fe, id) <-> fa.handleError(fe)
Implementations are free to override it in order to optimize error recovery.
Attributes
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and map, this equivalence being available:
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
Usage of redeem subsumes handleError because:
fa.redeem(fe, id) <-> fa.handleError(fe)
Implementations are free to override it in order to optimize error recovery.
Attributes
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and map, this equivalence being available:
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
Usage of redeem subsumes handleError because:
fa.redeem(fe, id) <-> fa.handleError(fe)
Implementations are free to override it in order to optimize error recovery.
Attributes
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or map functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and map, this equivalence being available:
fa.redeem(fe, fs) <-> fa.attempt.map(_.fold(fe, fs))
Usage of redeem subsumes handleError because:
fa.redeem(fe, id) <-> fa.handleError(fe)
Implementations are free to override it in order to optimize error recovery.
Attributes
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and flatMap, this equivalence being available:
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
Usage of redeemWith subsumes handleErrorWith because:
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
Usage of redeemWith also subsumes flatMap because:
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
Implementations are free to override it in order to optimize error recovery.
Attributes
- bind
is the function that gets to transform the source in case of success
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
redeem, attempt and handleErrorWith
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and flatMap, this equivalence being available:
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
Usage of redeemWith subsumes handleErrorWith because:
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
Usage of redeemWith also subsumes flatMap because:
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
Implementations are free to override it in order to optimize error recovery.
Attributes
- bind
is the function that gets to transform the source in case of success
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
redeem, attempt and handleErrorWith
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and flatMap, this equivalence being available:
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
Usage of redeemWith subsumes handleErrorWith because:
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
Usage of redeemWith also subsumes flatMap because:
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
Implementations are free to override it in order to optimize error recovery.
Attributes
- bind
is the function that gets to transform the source in case of success
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
redeem, attempt and handleErrorWith
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and flatMap, this equivalence being available:
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
Usage of redeemWith subsumes handleErrorWith because:
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
Usage of redeemWith also subsumes flatMap because:
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
Implementations are free to override it in order to optimize error recovery.
Attributes
- bind
is the function that gets to transform the source in case of success
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
redeem, attempt and handleErrorWith
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
Returns a new value that transforms the result of the source,
given the recover or bind functions, which get executed depending
on whether the result is successful or if it ends in error.
This is an optimization on usage of attempt and flatMap, this equivalence being available:
fa.redeemWith(fe, fs) <-> fa.attempt.flatMap(_.fold(fe, fs))
Usage of redeemWith subsumes handleErrorWith because:
fa.redeemWith(fe, F.pure) <-> fa.handleErrorWith(fe)
Usage of redeemWith also subsumes flatMap because:
fa.redeemWith(F.raiseError, fs) <-> fa.flatMap(fs)
Implementations are free to override it in order to optimize error recovery.
Attributes
- bind
is the function that gets to transform the source in case of success
- fa
is the source whose result is going to get transformed
- recover
is the function that gets called to recover the source in case of error
- See also:
redeem, attempt and handleErrorWith
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Given fa and n, apply fa n times to construct an F[List[A]] value.
Given fa and n, apply fa n times to construct an F[List[A]] value.
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
| Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times to construct an F[List[A]] value.
Given fa and n, apply fa n times to construct an F[List[A]] value.
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
| Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times to construct an F[List[A]] value.
Given fa and n, apply fa n times to construct an F[List[A]] value.
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
| Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times to construct an F[List[A]] value.
Given fa and n, apply fa n times to construct an F[List[A]] value.
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
| Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times to construct an F[List[A]] value.
Given fa and n, apply fa n times to construct an F[List[A]] value.
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
| Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times discarding results to return F[Unit].
Given fa and n, apply fa n times discarding results to return F[Unit].
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[Unit] =
| Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times discarding results to return F[Unit].
Given fa and n, apply fa n times discarding results to return F[Unit].
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[Unit] =
| Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times discarding results to return F[Unit].
Given fa and n, apply fa n times discarding results to return F[Unit].
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[Unit] =
| Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times discarding results to return F[Unit].
Given fa and n, apply fa n times discarding results to return F[Unit].
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[Unit] =
| Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Given fa and n, apply fa n times discarding results to return F[Unit].
Given fa and n, apply fa n times discarding results to return F[Unit].
Example:
scala> import cats.data.State
scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[Unit] =
| Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Inverse of attempt
Inverse of attempt
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Inverse of attempt
Inverse of attempt
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Inverse of attempt
Inverse of attempt
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Inverse of attempt
Inverse of attempt
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Inverse of attempt
Inverse of attempt
Example:
scala> import cats.implicits._
scala> import scala.util.{Try, Success}
scala> val a: Try[Either[Throwable, Int]] = Success(Left(new java.lang.Exception))
scala> a.rethrow
res0: scala.util.Try[Int] = Failure(java.lang.Exception)
scala> val b: Try[Either[Throwable, Int]] = Success(Right(1))
scala> b.rethrow
res1: scala.util.Try[Int] = Success(1)
Attributes
- Inherited from:
- MonadError
- Source:
- MonadError.scala
Keeps calling f until a scala.util.Right[B] is returned.
Keeps calling f until a scala.util.Right[B] is returned.
Based on Phil Freeman's Stack Safety for Free.
Implementations of this method should use constant stack space relative to f.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Keeps calling f until a scala.util.Right[B] is returned.
Keeps calling f until a scala.util.Right[B] is returned.
Based on Phil Freeman's Stack Safety for Free.
Implementations of this method should use constant stack space relative to f.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Keeps calling f until a scala.util.Right[B] is returned.
Keeps calling f until a scala.util.Right[B] is returned.
Based on Phil Freeman's Stack Safety for Free.
Implementations of this method should use constant stack space relative to f.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Keeps calling f until a scala.util.Right[B] is returned.
Keeps calling f until a scala.util.Right[B] is returned.
Based on Phil Freeman's Stack Safety for Free.
Implementations of this method should use constant stack space relative to f.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Keeps calling f until a scala.util.Right[B] is returned.
Keeps calling f until a scala.util.Right[B] is returned.
Based on Phil Freeman's Stack Safety for Free.
Implementations of this method should use constant stack space relative to f.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Attributes
- Inherited from:
- ApplyArityFunctions
- Source:
- ApplyArityFunctions.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Tuples the A value in F[A] with the supplied B value, with the B value on the left.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Tuples the A value in F[A] with the supplied B value, with the B value on the right.
Example:
scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue
scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Returns an F[Unit] value, equivalent with pure(()).
Returns an F[Unit] value, equivalent with pure(()).
A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a val).
Example:
scala> import cats.implicits._
scala> Applicative[Option].unit
res0: Option[Unit] = Some(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns an F[Unit] value, equivalent with pure(()).
Returns an F[Unit] value, equivalent with pure(()).
A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a val).
Example:
scala> import cats.implicits._
scala> Applicative[Option].unit
res0: Option[Unit] = Some(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns an F[Unit] value, equivalent with pure(()).
Returns an F[Unit] value, equivalent with pure(()).
A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a val).
Example:
scala> import cats.implicits._
scala> Applicative[Option].unit
res0: Option[Unit] = Some(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns an F[Unit] value, equivalent with pure(()).
Returns an F[Unit] value, equivalent with pure(()).
A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a val).
Example:
scala> import cats.implicits._
scala> Applicative[Option].unit
res0: Option[Unit] = Some(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns an F[Unit] value, equivalent with pure(()).
Returns an F[Unit] value, equivalent with pure(()).
A useful shorthand, also allowing implementations to optimize the
returned reference (e.g. it can be a val).
Example:
scala> import cats.implicits._
scala> Applicative[Option].unit
res0: Option[Unit] = Some(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Returns the given argument (mapped to Unit) if cond is false,
otherwise, unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())
scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())
scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.
Attributes
- Inherited from:
- FlatMap
- Source:
- FlatMap.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Collects results into an
arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Execute an action repeatedly until the Boolean condition returns true.
The condition is evaluated after the loop body. Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
NOTE: Check for effect duplication, possibly memoize before
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
NOTE: Check for effect duplication, possibly memoize before
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
NOTE: Check for effect duplication, possibly memoize before
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
NOTE: Check for effect duplication, possibly memoize before
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.
NOTE: Check for effect duplication, possibly memoize before
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList
scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Void any error, by mapping it to Unit.
Void any error, by mapping it to Unit.
This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:
IO.deferred[OutcomeIO[A]].flatMap { oc =>
ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
// ...
}
Without the .voidError, the Cats Effect runtime would consider an error in ioa to be
unhandled and elevate it to ExecutionContext#reportFailure.
Attributes
- See also:
handleError to map to an
Avalue instead ofUnit.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Void any error, by mapping it to Unit.
Void any error, by mapping it to Unit.
This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:
IO.deferred[OutcomeIO[A]].flatMap { oc =>
ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
// ...
}
Without the .voidError, the Cats Effect runtime would consider an error in ioa to be
unhandled and elevate it to ExecutionContext#reportFailure.
Attributes
- See also:
handleError to map to an
Avalue instead ofUnit.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Void any error, by mapping it to Unit.
Void any error, by mapping it to Unit.
This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:
IO.deferred[OutcomeIO[A]].flatMap { oc =>
ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
// ...
}
Without the .voidError, the Cats Effect runtime would consider an error in ioa to be
unhandled and elevate it to ExecutionContext#reportFailure.
Attributes
- See also:
handleError to map to an
Avalue instead ofUnit.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Void any error, by mapping it to Unit.
Void any error, by mapping it to Unit.
This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:
IO.deferred[OutcomeIO[A]].flatMap { oc =>
ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
// ...
}
Without the .voidError, the Cats Effect runtime would consider an error in ioa to be
unhandled and elevate it to ExecutionContext#reportFailure.
Attributes
- See also:
handleError to map to an
Avalue instead ofUnit.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Void any error, by mapping it to Unit.
Void any error, by mapping it to Unit.
This is useful when errors are reported via a side-channel but not directly handled. For example in Cats Effect:
IO.deferred[OutcomeIO[A]].flatMap { oc =>
ioa.guaranteeCase(oc.complete(_).void).void.voidError.start
// ...
}
Without the .voidError, the Cats Effect runtime would consider an error in ioa to be
unhandled and elevate it to ExecutionContext#reportFailure.
Attributes
- See also:
handleError to map to an
Avalue instead ofUnit.- Inherited from:
- ApplicativeError
- Source:
- ApplicativeError.scala
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()
scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()
scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()
scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()
scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Returns the given argument (mapped to Unit) if cond is true, otherwise,
unit lifted into F.
Example:
scala> import cats.implicits._
scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())
scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())
scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()
scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Attributes
- Inherited from:
- Applicative
- Source:
- Applicative.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Collects the results into an arbitrary Alternative value, such as a Vector.
This implementation uses append on each evaluation result,
so avoid data structures with non-constant append performance, e.g. List.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Execute an action repeatedly as long as the given Boolean expression
returns true. The condition is evaluated before the loop body.
Discards results.
Attributes
- Inherited from:
- Monad
- Source:
- Monad.scala
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a ClassCastException, because it is
implemented as a type cast. It could be implemented as map(identity), but
according to the functor laws, that should be equal to fa, and a type
cast is often much more performant.
See this example
of widen creating a ClassCastException.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a ClassCastException, because it is
implemented as a type cast. It could be implemented as map(identity), but
according to the functor laws, that should be equal to fa, and a type
cast is often much more performant.
See this example
of widen creating a ClassCastException.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a ClassCastException, because it is
implemented as a type cast. It could be implemented as map(identity), but
according to the functor laws, that should be equal to fa, and a type
cast is often much more performant.
See this example
of widen creating a ClassCastException.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a ClassCastException, because it is
implemented as a type cast. It could be implemented as map(identity), but
according to the functor laws, that should be equal to fa, and a type
cast is often much more performant.
See this example
of widen creating a ClassCastException.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a ClassCastException, because it is
implemented as a type cast. It could be implemented as map(identity), but
according to the functor laws, that should be equal to fa, and a type
cast is often much more performant.
See this example
of widen creating a ClassCastException.
Example:
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption
scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)
Attributes
- Inherited from:
- Functor
- Source:
- Functor.scala
Deprecated and Inherited methods
Attributes
- Deprecated
- true
- Inherited from:
- Apply
- Source:
- Apply.scala
Attributes
- Deprecated
- true
- Inherited from:
- Apply
- Source:
- Apply.scala
Attributes
- Deprecated
- true
- Inherited from:
- Apply
- Source:
- Apply.scala
Attributes
- Deprecated
- true
- Inherited from:
- Apply
- Source:
- Apply.scala