trait IsomorphismBind[F[_], G[_]] extends Bind[F] with IsomorphismApply[F, G]
- Alphabetic
- By Inheritance
- IsomorphismBind
- IsomorphismApply
- IsomorphismFunctor
- IsomorphismInvariantFunctor
- Bind
- Apply
- Functor
- InvariantFunctor
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- trait ApplyLaw extends FunctorLaw
- Definition Classes
- Apply
- trait FlippedApply extends Apply[F]
- Attributes
- protected[this]
- Definition Classes
- Apply
- trait BindLaw extends ApplyLaw
- Definition Classes
- Bind
- trait FunctorLaw extends InvariantFunctorLaw
- Definition Classes
- Functor
- trait InvariantFunctorLaw extends AnyRef
- Definition Classes
- InvariantFunctor
Abstract Value Members
- implicit abstract def G: Bind[G]
- Definition Classes
- IsomorphismBind → IsomorphismApply → IsomorphismFunctor → IsomorphismInvariantFunctor
- abstract def iso: Isomorphism.<~>[F, G]
- Definition Classes
- IsomorphismFunctor → IsomorphismInvariantFunctor
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
apply2
and all other combinators, as well as scalaz.Bind, thef
action appears to the *left*. Sof
should 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
- 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 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
- IsomorphismApply → 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 applying1[Z, A1](f: (A1) => Z)(implicit a1: F[A1]): F[Z]
- Definition Classes
- Apply
- final def applying2[Z, A1, A2](f: (A1, A2) => Z)(implicit a1: F[A1], a2: F[A2]): F[Z]
- Definition Classes
- Apply
- final def applying3[Z, A1, A2, A3](f: (A1, A2, A3) => Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
- Definition Classes
- Apply
- final def applying4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) => Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
- 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
F
and BifunctorG
,[x, y]F[G[x, y]]
, is a BifunctorThe composition of Functor
F
and 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(classOf[java.lang.CloneNotSupportedException]) @native()
- def compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[G[α]]]
The composition of Applys
F
andG
,[x]F[G[x]]
, is a ApplyThe composition of Applys
F
andG
,[x]F[G[x]]
, is a Apply- Definition Classes
- Apply
- def compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[G[α]]]
The composition of Functors
F
andG
,[x]F[G[x]]
, is a FunctorThe composition of Functors
F
andG
,[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
fa
andfb
according toApply[F]
with a function that discards theA
(s)Combine
fa
andfb
according toApply[F]
with a function that discards theA
(s)- Definition Classes
- Apply
- def discardRight[A, B](fa: => F[A], fb: => F[B]): F[A]
Combine
fa
andfb
according toApply[F]
with a function that discards theB
(s)Combine
fa
andfb
according toApply[F]
with a function that discards theB
(s)- Definition Classes
- Apply
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flip: Apply[F]
An
Apply
forF
in which effects happen in the opposite order.An
Apply
forF
in which effects happen in the opposite order.- Definition Classes
- Apply
- def forever[A, B](fa: F[A]): F[B]
Repeats an applicative action infinitely
Repeats an applicative action infinitely
- Definition Classes
- Apply
- def fpair[A](fa: F[A]): F[(A, A)]
Twin all
A
s infa
.Twin all
A
s infa
.- Definition Classes
- Functor
- def fproduct[A, B](fa: F[A])(f: (A) => B): F[(A, B)]
Pair all
A
s infa
with the result of function application.Pair all
A
s infa
with 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[_ <: AnyRef]
- 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]
if
lifted into a binding.if
lifted into a binding. Unlikelift3((t,c,a)=>if(t)c else a)
, this will only include context from the chosen ofifTrue
andifFalse
, 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 join[A](ffa: F[F[A]]): F[A]
Sequence the inner
F
ofFFA
after the outerF
, forming a singleF[A]
.Sequence the inner
F
ofFFA
after the outerF
, forming a singleF[A]
.- Definition Classes
- Bind
- def lift[A, B](f: (A) => B): (F[A]) => F[B]
Lift
f
intoF
.Lift
f
intoF
.- 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 liftReducer[A, B](implicit r: Reducer[A, B]): Reducer[F[A], F[B]]
- Definition Classes
- Apply
- def map[A, B](fa: F[A])(f: (A) => B): F[B]
Lift
f
intoF
and apply toF[A]
.Lift
f
intoF
and 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 mproduct[A, B](fa: F[A])(f: (A) => F[B]): F[(A, B)]
Pair
A
with the result of function application.Pair
A
with 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 product[G[_]](implicit G0: Bind[G]): Bind[[α](F[α], G[α])]
The product of Bind
F
andG
,[x](F[x], G[x]])
, is a BindThe product of Bind
F
andG
,[x](F[x], G[x]])
, is a Bind- Definition Classes
- Bind
- def product[G[_]](implicit G0: Apply[G]): Apply[[α](F[α], G[α])]
The product of Applys
F
andG
,[x](F[x], G[x]])
, is a ApplyThe product of Applys
F
andG
,[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
F
andG
,[x](F[x], G[x]])
, is a FunctorThe product of Functors
F
andG
,[x](F[x], G[x]])
, is a Functor- Definition Classes
- Functor
- 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
a
to the left ofB
s inf
.Inject
a
to the left ofB
s inf
.- Definition Classes
- Functor
- def strengthR[A, B](f: F[A], b: B): F[(A, B)]
Inject
b
to the right ofA
s inf
.Inject
b
to the right ofA
s inf
.- Definition Classes
- Functor
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- 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 unfoldrOpt[S, A, B](seed: S)(f: (S) => Maybe[(F[A], S)])(implicit R: Reducer[A, B]): Maybe[F[B]]
Unfold
seed
to the right and combine effects left-to-right, using the given Reducer to combine values. - def void[A](fa: F[A]): F[Unit]
Empty
fa
of meaningful pure values, preserving its structure.Empty
fa
of meaningful pure values, preserving its structure.- Definition Classes
- Functor
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- 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]
ifA
is a subtype ofB
.Functors are covariant by nature, so we can treat an
F[A]
as anF[B]
ifA
is a subtype ofB
.- Definition Classes
- Functor
- def xmap[A, B](ma: F[A], f: (A) => B, g: (B) => A): F[B]
Converts
ma
to a value of typeF[B]
using the provided functionsf
andg
.Converts
ma
to a value of typeF[B]
using the provided functionsf
andg
.- Definition Classes
- IsomorphismInvariantFunctor → InvariantFunctor
- def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]
Converts
ma
to a value of typeF[B]
using the provided bijection.Converts
ma
to 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
ma
to a value of typeF[B]
using the provided isomorphism.Converts
ma
to a value of typeF[B]
using the provided isomorphism.- Definition Classes
- InvariantFunctor