trait IsomorphismMonad[F[_], G[_]] extends Monad[F] with IsomorphismApplicative[F, G] with IsomorphismBind[F, G]
- Alphabetic
- By Inheritance
- IsomorphismMonad
- IsomorphismBind
- IsomorphismApplicative
- IsomorphismApply
- IsomorphismFunctor
- Monad
- Bind
- BindParent
- Applicative
- ApplicativeParent
- Apply
- ApplyParent
- Functor
- InvariantFunctor
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
ApplicativeLaw extends ApplyLaw
- Definition Classes
- Applicative
-
trait
ApplyLaw extends FunctorLaw
- Definition Classes
- Apply
-
trait
BindLaw extends ApplyLaw
- Definition Classes
- Bind
-
trait
FunctorLaw extends InvariantFunctorLaw
- Definition Classes
- Functor
-
trait
InvariantFunctorLaw extends AnyRef
- Definition Classes
- InvariantFunctor
-
trait
MonadLaw extends ApplicativeLaw with BindLaw
- Definition Classes
- Monad
Abstract Value Members
-
implicit abstract
def
G: Monad[G]
- Definition Classes
- IsomorphismMonad → IsomorphismBind → IsomorphismApplicative → IsomorphismApply → IsomorphismFunctor
-
abstract
def
iso: Isomorphism.<~>[F, G]
- Definition Classes
- IsomorphismFunctor
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
ap[A, B](fa: ⇒ F[A])(f: ⇒ F[(A) ⇒ B]): F[B]
Sequence
f, thenfa, combining their results by function application.Sequence
f, thenfa, combining their results by function application.NB: with respect to
apply2and all other combinators, as well as scalaz.Bind, thefaction appears to the *left*. Sofshould be the "first"F-action to perform. This is in accordance with all other implementations of this typeclass in common use, which are "function first".- Definition Classes
- IsomorphismApplicative → IsomorphismApply → Apply
-
def
ap2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: F[(A, B) ⇒ C]): F[C]
- Definition Classes
- Apply
-
def
ap3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: F[(A, B, C) ⇒ D]): F[D]
- Definition Classes
- Apply
-
def
ap4[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: F[(A, B, C, D) ⇒ E]): F[E]
- Definition Classes
- Apply
-
def
ap5[A, B, C, D, E, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: F[(A, B, C, D, E) ⇒ R]): F[R]
- Definition Classes
- Apply
-
def
ap6[A, B, C, D, E, FF, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF])(f: F[(A, B, C, D, E, FF) ⇒ R]): F[R]
- Definition Classes
- Apply
-
def
ap7[A, B, C, D, E, FF, G, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G])(f: F[(A, B, C, D, E, FF, G) ⇒ R]): F[R]
- Definition Classes
- Apply
-
def
ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H])(f: F[(A, B, C, D, E, FF, G, H) ⇒ R]): F[R]
- Definition Classes
- Apply
-
def
apF[A, B](f: ⇒ F[(A) ⇒ B]): (F[A]) ⇒ F[B]
Flipped variant of
ap.Flipped variant of
ap.- Definition Classes
- Apply
-
def
applicativeLaw: ApplicativeLaw
- Definition Classes
- Applicative
-
val
applicativeSyntax: ApplicativeSyntax[F]
- Definition Classes
- Applicative
-
def
apply[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
Alias for
map.Alias for
map.- Definition Classes
- Functor
-
def
apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): F[R]
- Definition Classes
- Apply
-
def
apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J], fk: ⇒ F[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): F[R]
- Definition Classes
- Apply
-
def
apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J], fk: ⇒ F[K], fl: ⇒ F[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): F[R]
- Definition Classes
- Apply
-
def
apply2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C): F[C]
- Definition Classes
- IsomorphismApplicative → Applicative → Apply
-
def
apply3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: (A, B, C) ⇒ D): F[D]
- Definition Classes
- Apply
-
def
apply4[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: (A, B, C, D) ⇒ E): F[E]
- Definition Classes
- Apply
-
def
apply5[A, B, C, D, E, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: (A, B, C, D, E) ⇒ R): F[R]
- Definition Classes
- Apply
-
def
apply6[A, B, C, D, E, FF, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF])(f: (A, B, C, D, E, FF) ⇒ R): F[R]
- Definition Classes
- Apply
-
def
apply7[A, B, C, D, E, FF, G, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G])(f: (A, B, C, D, E, FF, G) ⇒ R): F[R]
- Definition Classes
- Apply
-
def
apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): F[R]
- Definition Classes
- Apply
-
def
apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): F[R]
- Definition Classes
- Apply
-
def
applyApplicative: Applicative[[α]\/[F[α], α]]
Add a unit to any Apply to form an Applicative.
Add a unit to any Apply to form an Applicative.
- Definition Classes
- Apply
-
def
applyLaw: ApplyLaw
- Definition Classes
- Apply
-
val
applySyntax: ApplySyntax[F]
- Definition Classes
- Apply
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β]]]
The composition of Functor
Fand BifunctorG,[x, y]F[G[x, y]], is a BifunctorThe composition of Functor
Fand BifunctorG,[x, y]F[G[x, y]], is a Bifunctor- Definition Classes
- Functor
-
def
bind[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[B]
Equivalent to
join(map(fa)(f)).Equivalent to
join(map(fa)(f)).- Definition Classes
- IsomorphismBind → Bind
-
def
bindLaw: BindLaw
- Definition Classes
- Bind
-
val
bindSyntax: BindSyntax[F]
- Definition Classes
- Bind
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]F[G[α]]]
The composition of Applicatives
FandG,[x]F[G[x]], is an ApplicativeThe composition of Applicatives
FandG,[x]F[G[x]], is an Applicative- Definition Classes
- Applicative
-
def
compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[G[α]]]
The composition of Applys
FandG,[x]F[G[x]], is a ApplyThe composition of Applys
FandG,[x]F[G[x]], is a Apply- Definition Classes
- Apply
-
def
compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[G[α]]]
The composition of Functors
FandG,[x]F[G[x]], is a FunctorThe composition of Functors
FandG,[x]F[G[x]], is a Functor- Definition Classes
- Functor
-
def
counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
- Definition Classes
- Functor
-
def
discardLeft[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[B]
Combine
faandfbaccording toApply[F]with a function that discards theA(s)Combine
faandfbaccording toApply[F]with a function that discards theA(s)- Definition Classes
- ApplyParent
-
def
discardRight[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[A]
Combine
faandfbaccording toApply[F]with a function that discards theB(s)Combine
faandfbaccording toApply[F]with a function that discards theB(s)- Definition Classes
- ApplyParent
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
filterM[A](l: List[A])(f: (A) ⇒ F[Boolean]): F[List[A]]
Filter
laccording to an applicative predicate.Filter
laccording to an applicative predicate.- Definition Classes
- Applicative
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
flip: Applicative[F]
An
ApplicativeforFin which effects happen in the opposite order.An
ApplicativeforFin which effects happen in the opposite order.- Definition Classes
- Applicative → ApplyParent
-
def
forever[A, B](fa: F[A]): F[B]
Repeats a monadic action infinitely
Repeats a monadic action infinitely
- Definition Classes
- Bind → ApplyParent
-
def
fpair[A](fa: F[A]): F[(A, A)]
Twin all
As infa.Twin all
As infa.- Definition Classes
- Functor
-
def
fproduct[A, B](fa: F[A])(f: (A) ⇒ B): F[(A, B)]
Pair all
As infawith the result of function application.Pair all
As infawith the result of function application.- Definition Classes
- Functor
-
def
functorLaw: FunctorLaw
- Definition Classes
- Functor
-
val
functorSyntax: FunctorSyntax[F]
- Definition Classes
- Functor
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]F[G[α]]]
The composition of Functor F and Contravariant G,
[x]F[G[x]], is contravariant.The composition of Functor F and Contravariant G,
[x]F[G[x]], is contravariant.- Definition Classes
- Functor
-
def
ifM[B](value: F[Boolean], ifTrue: ⇒ F[B], ifFalse: ⇒ F[B]): F[B]
iflifted into a binding.iflifted into a binding. Unlikelift3((t,c,a)=>if(t)c else a), this will only include context from the chosen ofifTrueandifFalse, not the other.- Definition Classes
- Bind
-
def
invariantFunctorLaw: InvariantFunctorLaw
- Definition Classes
- InvariantFunctor
-
val
invariantFunctorSyntax: InvariantFunctorSyntax[F]
- Definition Classes
- InvariantFunctor
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
iterateUntil[A](f: F[A])(p: (A) ⇒ Boolean): F[A]
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.
- Definition Classes
- Monad
-
def
iterateWhile[A](f: F[A])(p: (A) ⇒ Boolean): F[A]
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.
- Definition Classes
- Monad
-
def
join[A](ffa: F[F[A]]): F[A]
Sequence the inner
FofFFAafter the outerF, forming a singleF[A].Sequence the inner
FofFFAafter the outerF, forming a singleF[A].- Definition Classes
- Bind
-
def
lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]
Lift
fintoF.Lift
fintoF.- Definition Classes
- Functor
-
def
lift10[A, B, C, D, E, FF, G, H, I, J, R](f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J]) ⇒ F[R]
- Definition Classes
- Apply
-
def
lift11[A, B, C, D, E, FF, G, H, I, J, K, R](f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K]) ⇒ F[R]
- Definition Classes
- Apply
-
def
lift12[A, B, C, D, E, FF, G, H, I, J, K, L, R](f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K], F[L]) ⇒ F[R]
- Definition Classes
- Apply
-
def
lift2[A, B, C](f: (A, B) ⇒ C): (F[A], F[B]) ⇒ F[C]
- Definition Classes
- Apply
-
def
lift3[A, B, C, D](f: (A, B, C) ⇒ D): (F[A], F[B], F[C]) ⇒ F[D]
- Definition Classes
- Apply
-
def
lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (F[A], F[B], F[C], F[D]) ⇒ F[E]
- Definition Classes
- Apply
-
def
lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (F[A], F[B], F[C], F[D], F[E]) ⇒ F[R]
- Definition Classes
- Apply
-
def
lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF]) ⇒ F[R]
- Definition Classes
- Apply
-
def
lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G]) ⇒ F[R]
- Definition Classes
- Apply
-
def
lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H]) ⇒ F[R]
- Definition Classes
- Apply
-
def
lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I]) ⇒ F[R]
- Definition Classes
- Apply
-
def
map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
Lift
fintoFand apply toF[A].Lift
fintoFand apply toF[A].- Definition Classes
- IsomorphismFunctor → Functor
-
def
mapply[A, B](a: A)(f: F[(A) ⇒ B]): F[B]
Lift
apply(a), and apply the result tof.Lift
apply(a), and apply the result tof.- Definition Classes
- Functor
-
def
monadLaw: MonadLaw
- Definition Classes
- Monad
-
val
monadSyntax: MonadSyntax[F]
- Definition Classes
- Monad
-
def
mproduct[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[(A, B)]
Pair
Awith the result of function application.Pair
Awith the result of function application.- Definition Classes
- Bind
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
par: Par[F]
A lawful implementation of this that is isomorphic up to the methods defined on Applicative allowing for optimised parallel implementations that would otherwise violate laws of more specific typeclasses (e.g.
A lawful implementation of this that is isomorphic up to the methods defined on Applicative allowing for optimised parallel implementations that would otherwise violate laws of more specific typeclasses (e.g. Monad).
- Definition Classes
- ApplicativeParent
-
def
point[A](a: ⇒ A): F[A]
- Definition Classes
- IsomorphismApplicative → Applicative
-
def
product[G[_]](implicit G0: Monad[G]): Monad[[α](F[α], G[α])]
The product of Monad
FandG,[x](F[x], G[x]]), is a MonadThe product of Monad
FandG,[x](F[x], G[x]]), is a Monad- Definition Classes
- Monad
-
def
product[G[_]](implicit G0: Bind[G]): Bind[[α](F[α], G[α])]
The product of Bind
FandG,[x](F[x], G[x]]), is a BindThe product of Bind
FandG,[x](F[x], G[x]]), is a Bind- Definition Classes
- Bind
-
def
product[G[_]](implicit G0: Applicative[G]): Applicative[[α](F[α], G[α])]
The product of Applicatives
FandG,[x](F[x], G[x]]), is an ApplicativeThe product of Applicatives
FandG,[x](F[x], G[x]]), is an Applicative- Definition Classes
- Applicative
-
def
product[G[_]](implicit G0: Apply[G]): Apply[[α](F[α], G[α])]
The product of Applys
FandG,[x](F[x], G[x]]), is a ApplyThe product of Applys
FandG,[x](F[x], G[x]]), is a Apply- Definition Classes
- Apply
-
def
product[G[_]](implicit G0: Functor[G]): Functor[[α](F[α], G[α])]
The product of Functors
FandG,[x](F[x], G[x]]), is a FunctorThe product of Functors
FandG,[x](F[x], G[x]]), is a Functor- Definition Classes
- Functor
-
final
def
pure[A](a: ⇒ A): F[A]
- Definition Classes
- Applicative
-
def
replicateM[A](n: Int, fa: F[A]): F[List[A]]
Performs the action
ntimes, returning the list of results.Performs the action
ntimes, returning the list of results.- Definition Classes
- Applicative
-
def
replicateM_[A](n: Int, fa: F[A]): F[Unit]
Performs the action
ntimes, returning nothing.Performs the action
ntimes, returning nothing.- Definition Classes
- Applicative
-
def
sequence[A, G[_]](as: G[F[A]])(implicit arg0: Traverse[G]): F[G[A]]
- Definition Classes
- Applicative
-
def
sequence1[A, G[_]](as: G[F[A]])(implicit arg0: Traverse1[G]): F[G[A]]
- Definition Classes
- Apply
-
def
strengthL[A, B](a: A, f: F[B]): F[(A, B)]
Inject
ato the left ofBs inf.Inject
ato the left ofBs inf.- Definition Classes
- Functor
-
def
strengthR[A, B](f: F[A], b: B): F[(A, B)]
Inject
bto the right ofAs inf.Inject
bto the right ofAs inf.- Definition Classes
- Functor
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
traverse[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse[G]): F[G[B]]
- Definition Classes
- Applicative
-
def
traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse1[G]): F[G[B]]
- Definition Classes
- Apply
-
def
tuple2[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[(A, B)]
- Definition Classes
- Apply
-
def
tuple3[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C]): F[(A, B, C)]
- Definition Classes
- Apply
-
def
tuple4[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D]): F[(A, B, C, D)]
- Definition Classes
- Apply
-
def
tuple5[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E]): F[(A, B, C, D, E)]
- Definition Classes
- Apply
-
def
unlessM[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]
Returns the given argument if
condisfalse, otherwise, unit lifted into F.Returns the given argument if
condisfalse, otherwise, unit lifted into F.- Definition Classes
- Applicative
-
def
untilM[G[_], A](f: F[A], cond: ⇒ F[Boolean])(implicit G: MonadPlus[G]): F[G[A]]
Execute an action repeatedly until the
Booleancondition returnstrue.Execute an action repeatedly until the
Booleancondition returnstrue. The condition is evaluated after the loop body. Collects results into an arbitraryMonadPlusvalue, such as aList.- Definition Classes
- Monad
-
def
untilM_[A](f: F[A], cond: ⇒ F[Boolean]): F[Unit]
Execute an action repeatedly until the
Booleancondition returnstrue.Execute an action repeatedly until the
Booleancondition returnstrue. The condition is evaluated after the loop body. Discards results.- Definition Classes
- Monad
-
def
void[A](fa: F[A]): F[Unit]
Empty
faof meaningful pure values, preserving its structure.Empty
faof meaningful pure values, preserving its structure.- Definition Classes
- Functor
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
whenM[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]
Returns the given argument if
condistrue, otherwise, unit lifted into F.Returns the given argument if
condistrue, otherwise, unit lifted into F.- Definition Classes
- Applicative
-
def
whileM[G[_], A](p: F[Boolean], body: ⇒ F[A])(implicit G: MonadPlus[G]): F[G[A]]
Execute an action repeatedly as long as the given
Booleanexpression returnstrue.Execute an action repeatedly as long as the given
Booleanexpression returnstrue. The condition is evaluated before the loop body. Collects the results into an arbitraryMonadPlusvalue, such as aList.- Definition Classes
- Monad
-
def
whileM_[A](p: F[Boolean], body: ⇒ F[A]): F[Unit]
Execute an action repeatedly as long as the given
Booleanexpression returnstrue.Execute an action repeatedly as long as the given
Booleanexpression returnstrue. The condition is evaluated before the loop body. Discards results.- Definition Classes
- Monad
-
def
widen[A, B](fa: F[A])(implicit ev: <~<[A, B]): F[B]
Functors are covariant by nature, so we can treat an
F[A]as anF[B]ifAis a subtype ofB.Functors are covariant by nature, so we can treat an
F[A]as anF[B]ifAis a subtype ofB.- Definition Classes
- Functor
-
def
xmap[A, B](fa: F[A], f: (A) ⇒ B, g: (B) ⇒ A): F[B]
Converts
mato a value of typeF[B]using the provided functionsfandg.Converts
mato a value of typeF[B]using the provided functionsfandg.- Definition Classes
- Functor → InvariantFunctor
-
def
xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]
Converts
mato a value of typeF[B]using the provided bijection.Converts
mato a value of typeF[B]using the provided bijection.- Definition Classes
- InvariantFunctor
-
def
xmapi[A, B](ma: F[A])(iso: Isomorphism.<=>[A, B]): F[B]
Converts
mato a value of typeF[B]using the provided isomorphism.Converts
mato a value of typeF[B]using the provided isomorphism.- Definition Classes
- InvariantFunctor