trait IsomorphismTraverse[F[_], G[_]] extends Traverse[F] with IsomorphismFoldable[F, G] with IsomorphismFunctor[F, G]
- Alphabetic
- By Inheritance
- IsomorphismTraverse
- IsomorphismFunctor
- IsomorphismFoldable
- Traverse
- TraverseParent
- Foldable
- FoldableParent
- Functor
- InvariantFunctor
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- trait FoldableLaw extends AnyRef
- Definition Classes
- Foldable
- trait FunctorLaw extends InvariantFunctorLaw
- Definition Classes
- Functor
- trait InvariantFunctorLaw extends AnyRef
- Definition Classes
- InvariantFunctor
- class Traversal[G[_]] extends AnyRef
- Definition Classes
- Traverse
- trait TraverseLaw extends FunctorLaw
- Definition Classes
- Traverse
Abstract Value Members
- implicit abstract def G: Traverse[G]
- Definition Classes
- IsomorphismTraverse → IsomorphismFunctor → IsomorphismFoldable
- 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 all[A](fa: F[A])(p: (A) => Boolean): Boolean
Whether all
As infayield true fromp.Whether all
As infayield true fromp.- Definition Classes
- Foldable
- def allM[G[_], A](fa: F[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
allwith monadic traversal.allwith monadic traversal.- Definition Classes
- Foldable
- def any[A](fa: F[A])(p: (A) => Boolean): Boolean
Whether any
As infayield true fromp.Whether any
As infayield true fromp.- Definition Classes
- Foldable
- def anyM[G[_], A](fa: F[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
anywith monadic traversal.anywith monadic traversal.- Definition Classes
- Foldable
- def apply[A, B](fa: F[A])(f: (A) => B): F[B]
Alias for
map.Alias for
map.- Definition Classes
- Functor
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def bicompose[G[_, _]](implicit arg0: Bitraverse[G]): Bitraverse[[α, β]F[G[α, β]]]
The composition of Traverse
Fand BitraverseG,[x, y]F[G[x, y]], is a BitraverseThe composition of Traverse
Fand BitraverseG,[x, y]F[G[x, y]], is a Bitraverse- Definition Classes
- Traverse
- def bicompose[G[_, _]](implicit arg0: Bifoldable[G]): Bifoldable[[α, β]F[G[α, β]]]
The composition of Foldable
Fand BifoldableG,[x, y]F[G[x, y]], is a BifoldableThe composition of Foldable
Fand BifoldableG,[x, y]F[G[x, y]], is a Bifoldable- Definition Classes
- Foldable
- 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 clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collapse[X[_], A](x: F[A])(implicit A: ApplicativePlus[X]): X[A]
- Definition Classes
- Foldable
- def compose[G[_]](implicit G0: Traverse[G]): Traverse[[α]F[G[α]]]
The composition of Traverses
FandG,[x]F[G[x]], is a TraverseThe composition of Traverses
FandG,[x]F[G[x]], is a Traverse- Definition Classes
- Traverse
- def compose[G[_]](implicit G0: Foldable[G]): Foldable[[α]F[G[α]]]
The composition of Foldables
FandG,[x]F[G[x]], is a FoldableThe composition of Foldables
FandG,[x]F[G[x]], is a Foldable- Definition Classes
- Foldable
- 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
- final def count[A](fa: F[A]): Int
Alias for
length.Alias for
length.- Definition Classes
- Foldable
- def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
- Definition Classes
- Functor
- def distinct[A](fa: F[A])(implicit A: Order[A]): IList[A]
O(n log n)O(n log n)- Definition Classes
- Foldable
- def distinctBy[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Equal[B]): IList[A]
- Definition Classes
- FoldableParent
- def distinctE[A](fa: F[A])(implicit A: Equal[A]): IList[A]
O(n2)O(n2)- Definition Classes
- Foldable
- def element[A](fa: F[A], a: A)(implicit arg0: Equal[A]): Boolean
Whether
ais an element offa.Whether
ais an element offa.- Definition Classes
- Foldable
- def empty[A](fa: F[A]): Boolean
Deforested alias for
toStream(fa).isEmpty.Deforested alias for
toStream(fa).isEmpty.- Definition Classes
- Foldable
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def extrema[A](fa: F[A])(implicit arg0: Order[A]): Option[(A, A)]
The smallest and largest elements of
faor None iffais emptyThe smallest and largest elements of
faor None iffais empty- Definition Classes
- FoldableParent
- def extremaBy[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): Option[(A, A)]
The elements (amin, amax) of
fawhich yield the smallest and largest values off(a), respectively, or None iffais emptyThe elements (amin, amax) of
fawhich yield the smallest and largest values off(a), respectively, or None iffais empty- Definition Classes
- FoldableParent
- def extremaOf[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): Option[(B, B)]
The smallest and largest values of
f(a)for each elementaoffa, or None iffais emptyThe smallest and largest values of
f(a)for each elementaoffa, or None iffais empty- Definition Classes
- FoldableParent
- def filterLength[A](fa: F[A])(f: (A) => Boolean): Int
- Definition Classes
- FoldableParent
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def findLeft[A](fa: F[A])(f: (A) => Boolean): Option[A]
- Definition Classes
- Foldable
- final def findMapM[M[_], A, B](fa: F[A])(f: (A) => M[Option[B]])(implicit arg0: Monad[M]): M[Option[B]]
map elements in a Foldable with a monadic function and return the first element that is mapped successfully
map elements in a Foldable with a monadic function and return the first element that is mapped successfully
- Definition Classes
- Foldable
- def findRight[A](fa: F[A])(f: (A) => Boolean): Option[A]
- Definition Classes
- Foldable
- def fold[M](t: F[M])(implicit arg0: Monoid[M]): M
Combine the elements of a structure using a monoid.
Combine the elements of a structure using a monoid.
- Definition Classes
- Foldable
- def fold1Opt[A](fa: F[A])(implicit arg0: Semigroup[A]): Option[A]
Like
foldbut returningNoneif the foldable is empty andSomeotherwiseLike
foldbut returningNoneif the foldable is empty andSomeotherwise- Definition Classes
- FoldableParent
- def foldLShape[A, B](fa: F[A], z: B)(f: (B, A) => B): (B, F[Unit])
- Definition Classes
- Traverse
- def foldLeft[A, B](fa: F[A], z: B)(f: (B, A) => B): B
Left-associative fold of a structure.
Left-associative fold of a structure.
- Definition Classes
- IsomorphismFoldable → Foldable
- def foldLeft1Opt[A](fa: F[A])(f: (A, A) => A): Option[A]
- Definition Classes
- Foldable
- def foldLeftM[G[_], A, B](fa: F[A], z: B)(f: (B, A) => G[B])(implicit M: Monad[G]): G[B]
Left-associative, monadic fold of a structure.
Left-associative, monadic fold of a structure.
- Definition Classes
- Foldable
- def foldMap[A, B](fa: F[A])(f: (A) => B)(implicit F: Monoid[B]): B
Map each element of the structure to a scalaz.Monoid, and combine the results.
Map each element of the structure to a scalaz.Monoid, and combine the results.
- Definition Classes
- IsomorphismFoldable → Foldable
- def foldMap1Opt[A, B](fa: F[A])(f: (A) => B)(implicit F: Semigroup[B]): Option[B]
As
foldMapbut returningNoneif the foldable is empty andSomeotherwiseAs
foldMapbut returningNoneif the foldable is empty andSomeotherwise- Definition Classes
- Foldable
- def foldMapLeft1Opt[A, B](fa: F[A])(z: (A) => B)(f: (B, A) => B): Option[B]
- Definition Classes
- Foldable
- def foldMapM[G[_], A, B](fa: F[A])(f: (A) => G[B])(implicit B: Monoid[B], G: Monad[G]): G[B]
Specialization of foldRightM when
Bhas aMonoid.Specialization of foldRightM when
Bhas aMonoid.- Definition Classes
- Foldable
- def foldMapRight1Opt[A, B](fa: F[A])(z: (A) => B)(f: (A, => B) => B): Option[B]
- Definition Classes
- Foldable
- def foldRight[A, B](fa: F[A], z: => B)(f: (A, => B) => B): B
Right-associative fold of a structure.
Right-associative fold of a structure.
- Definition Classes
- IsomorphismFoldable → Foldable
- def foldRight1Opt[A](fa: F[A])(f: (A, => A) => A): Option[A]
- Definition Classes
- Foldable
- def foldRightM[G[_], A, B](fa: F[A], z: => B)(f: (A, => B) => G[B])(implicit M: Monad[G]): G[B]
Right-associative, monadic fold of a structure.
Right-associative, monadic fold of a structure.
- Definition Classes
- Foldable
- def foldableLaw: FoldableLaw
- Definition Classes
- Foldable
- val foldableSyntax: FoldableSyntax[F]
- Definition Classes
- Foldable
- final def foldl[A, B](fa: F[A], z: B)(f: (B) => (A) => B): B
Curried version of
foldLeftCurried version of
foldLeft- Definition Classes
- Foldable
- def foldl1Opt[A](fa: F[A])(f: (A) => (A) => A): Option[A]
- Definition Classes
- Foldable
- final def foldlM[G[_], A, B](fa: F[A], z: => B)(f: (B) => (A) => G[B])(implicit M: Monad[G]): G[B]
Curried version of
foldLeftMCurried version of
foldLeftM- Definition Classes
- Foldable
- final def foldr[A, B](fa: F[A], z: => B)(f: (A) => (=> B) => B): B
Curried version of
foldRightCurried version of
foldRight- Definition Classes
- Foldable
- def foldr1Opt[A](fa: F[A])(f: (A) => (=> A) => A): Option[A]
- Definition Classes
- Foldable
- final def foldrM[G[_], A, B](fa: F[A], z: => B)(f: (A) => (=> B) => G[B])(implicit M: Monad[G]): G[B]
Curried version of
foldRightMCurried version of
foldRightM- Definition Classes
- Foldable
- 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[_ <: 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 index[A](fa: F[A], i: Int): Option[A]
- returns
the element at index
iin aSome, orNoneif the given index falls outside of the range
- Definition Classes
- Foldable
- def indexOr[A](fa: F[A], default: => A, i: Int): A
- returns
the element at index
i, ordefaultif the given index falls outside of the range
- Definition Classes
- Foldable
- def indexed[A](fa: F[A]): F[(Int, A)]
- Definition Classes
- Traverse
- def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A
Insert an
Abetween every A, yielding the sum.Insert an
Abetween every A, yielding the sum.- Definition Classes
- Foldable
- def invariantFunctorLaw: InvariantFunctorLaw
- Definition Classes
- InvariantFunctor
- val invariantFunctorSyntax: InvariantFunctorSyntax[F]
- Definition Classes
- InvariantFunctor
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def length[A](fa: F[A]): Int
Deforested alias for
toStream(fa).size.Deforested alias for
toStream(fa).size.- Definition Classes
- Foldable
- def lift[A, B](f: (A) => B): (F[A]) => F[B]
Lift
fintoF.Lift
fintoF.- Definition Classes
- Functor
- def longDigits[A](fa: F[A])(implicit d: <:<[A, Digit]): Long
- Definition Classes
- Foldable
- 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 mapAccumL[S, A, B](fa: F[A], z: S)(f: (S, A) => (S, B)): (S, F[B])
- Definition Classes
- Traverse
- def mapAccumR[S, A, B](fa: F[A], z: S)(f: (S, A) => (S, B)): (S, F[B])
- Definition Classes
- Traverse
- 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 maximum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]
The greatest element of
fa, or None iffais empty.The greatest element of
fa, or None iffais empty.- Definition Classes
- Foldable
- def maximumBy[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): Option[A]
The element
aoffawhich yields the greatest value off(a), or None iffais empty.The element
aoffawhich yields the greatest value off(a), or None iffais empty.- Definition Classes
- Foldable
- def maximumOf[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): Option[B]
The greatest value of
f(a)for each elementaoffa, or None iffais empty.The greatest value of
f(a)for each elementaoffa, or None iffais empty.- Definition Classes
- Foldable
- def minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]
The smallest element of
fa, or None iffais empty.The smallest element of
fa, or None iffais empty.- Definition Classes
- Foldable
- def minimumBy[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): Option[A]
The element
aoffawhich yields the smallest value off(a), or None iffais empty.The element
aoffawhich yields the smallest value off(a), or None iffais empty.- Definition Classes
- Foldable
- def minimumOf[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): Option[B]
The smallest value of
f(a)for each elementaoffa, or None iffais empty.The smallest value of
f(a)for each elementaoffa, or None iffais empty.- Definition Classes
- Foldable
- def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
- Definition Classes
- Foldable
- def msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]
- Definition Classes
- FoldableParent
- final def naturalTrans: ~>[F, G]
- Attributes
- protected[this]
- Definition Classes
- IsomorphismTraverse → IsomorphismFoldable
- 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: Traverse[G]): Traverse[[α](F[α], G[α])]
The product of Traverses
FandG,[x](F[x], G[x]]), is a TraverseThe product of Traverses
FandG,[x](F[x], G[x]]), is a Traverse- Definition Classes
- Traverse
- def product[G[_]](implicit G0: Foldable[G]): Foldable[[α](F[α], G[α])]
The product of Foldables
FandG,[x](F[x], G[x]]), is a FoldableThe product of Foldables
FandG,[x](F[x], G[x]]), is a Foldable- Definition Classes
- Foldable
- 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
- def product0[G[_]](implicit G0: Traverse1[G]): Traverse1[[α](F[α], G[α])]
The product of Traverse
Fand Traverse1G,[x](F[x], G[x]]), is a Traverse1The product of Traverse
Fand Traverse1G,[x](F[x], G[x]]), is a Traverse1- Definition Classes
- Traverse
- def product0[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](F[α], G[α])]
The product of Foldable
Fand Foldable1G,[x](F[x], G[x]]), is a Foldable1The product of Foldable
Fand Foldable1G,[x](F[x], G[x]]), is a Foldable1- Definition Classes
- Foldable
- def reverse[A](fa: F[A]): F[A]
- Definition Classes
- Traverse
- def runTraverseS[S, A, B](fa: F[A], s: S)(f: (A) => State[S, B]): (S, F[B])
- Definition Classes
- Traverse
- def selectSplit[A](fa: F[A])(p: (A) => Boolean): List[NonEmptyList[A]]
Selects groups of elements that satisfy p and discards others.
Selects groups of elements that satisfy p and discards others.
- Definition Classes
- Foldable
- def sequence[G[_], A](fga: F[G[A]])(implicit arg0: Applicative[G]): G[F[A]]
Traverse with the identity function.
Traverse with the identity function.
- Definition Classes
- Traverse
- def sequenceF_[M[_], A](ffa: F[Free[M, A]]): Free[M, Unit]
sequence_for Free.sequence_for Free. collapses into a single Free *- Definition Classes
- Foldable
- def sequenceM[A, G[_]](fgfa: F[G[F[A]]])(implicit G: Applicative[G], F: Bind[F]): G[F[A]]
A version of
sequencewhere a subsequent monadic join is applied to the inner resultA version of
sequencewhere a subsequent monadic join is applied to the inner result- Definition Classes
- TraverseParent
- def sequenceS[S, A](fga: F[State[S, A]]): State[S, F[A]]
Traverse with
State.Traverse with
State.- Definition Classes
- Traverse
- def sequenceS_[S, A](fga: F[State[S, A]]): State[S, Unit]
sequence_specialized toState*sequence_specialized toState*- Definition Classes
- Foldable
- final def sequenceU[A](self: F[A])(implicit G: Unapply[Applicative, A]): M[F[A]]
A version of
sequencethat infers the nested type constructor.A version of
sequencethat infers the nested type constructor.- Definition Classes
- Traverse
- def sequence_[M[_], A](fa: F[M[A]])(implicit a: Applicative[M]): M[Unit]
Strict sequencing in an applicative functor
Mthat ignores the value infa.Strict sequencing in an applicative functor
Mthat ignores the value infa.- Definition Classes
- Foldable
- def splitBy[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Equal[B]): IList[(B, NonEmptyList[A])]
Splits the elements into groups that produce the same result by a function f.
Splits the elements into groups that produce the same result by a function f.
- Definition Classes
- FoldableParent
- def splitByRelation[A](fa: F[A])(r: (A, A) => Boolean): IList[NonEmptyList[A]]
Splits into groups of elements that are transitively dependant by a relation r.
Splits into groups of elements that are transitively dependant by a relation r.
- Definition Classes
- FoldableParent
- def splitWith[A](fa: F[A])(p: (A) => Boolean): List[NonEmptyList[A]]
Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.
Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.
- Definition Classes
- Foldable
- 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
- def suml[A](fa: F[A])(implicit A: Monoid[A]): A
- Definition Classes
- Foldable
- def suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
- Definition Classes
- Foldable
- def sumr[A](fa: F[A])(implicit A: Monoid[A]): A
- Definition Classes
- Foldable
- def sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
- Definition Classes
- Foldable
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toEphemeralStream[A](fa: F[A]): EphemeralStream[A]
- Definition Classes
- Foldable
- def toIList[A](fa: F[A]): IList[A]
- Definition Classes
- Foldable
- def toList[A](fa: F[A]): List[A]
- Definition Classes
- Foldable
- def toSet[A](fa: F[A]): Set[A]
- Definition Classes
- Foldable
- def toStream[A](fa: F[A]): Stream[A]
- Definition Classes
- Foldable
- def toString(): String
- Definition Classes
- AnyRef → Any
- def toVector[A](fa: F[A]): Vector[A]
- Definition Classes
- Foldable
- def traversal[G[_]](implicit arg0: Applicative[G]): Traversal[G]
- Definition Classes
- Traverse
- def traversalS[S]: Traversal[[β$0$]IndexedStateT[[X]X, S, S, β$0$]]
- Definition Classes
- Traverse
- def traverse[G[_], A, B](fa: F[A])(f: (A) => G[B])(implicit arg0: Applicative[G]): G[F[B]]
- Definition Classes
- Traverse
- def traverseImpl[H[_], A, B](fa: F[A])(f: (A) => H[B])(implicit arg0: Applicative[H]): H[F[B]]
Transform
fausingf, collecting all theGs withap.Transform
fausingf, collecting all theGs withap.- Definition Classes
- IsomorphismTraverse → Traverse
- def traverseKTrampoline[S, G[_], A, B](fa: F[A])(f: (A) => Kleisli[G, S, B])(implicit arg0: Applicative[G]): Kleisli[G, S, F[B]]
Traverse
fawith aKleisli[G, S, B], internally using aTrampolineto avoid stack overflow.Traverse
fawith aKleisli[G, S, B], internally using aTrampolineto avoid stack overflow.- Definition Classes
- Traverse
- def traverseLaw: TraverseLaw
- Definition Classes
- Traverse
- final def traverseM[A, G[_], B](fa: F[A])(f: (A) => G[F[B]])(implicit G: Applicative[G], F: Bind[F]): G[F[B]]
A version of
traversewhere a subsequent monadic join is applied to the inner result.A version of
traversewhere a subsequent monadic join is applied to the inner result.- Definition Classes
- Traverse
- def traverseS[S, A, B](fa: F[A])(f: (A) => State[S, B]): State[S, F[B]]
Traverse with
State.Traverse with
State.- Definition Classes
- Traverse
- def traverseSTrampoline[S, G[_], A, B](fa: F[A])(f: (A) => State[S, G[B]])(implicit arg0: Applicative[G]): State[S, G[F[B]]]
Traverse
fawith aState[S, G[B]], internally using aTrampolineto avoid stack overflow.Traverse
fawith aState[S, G[B]], internally using aTrampolineto avoid stack overflow.- Definition Classes
- Traverse
- def traverseS_[S, A, B](fa: F[A])(f: (A) => State[S, B]): State[S, Unit]
traverse_specialized toState*traverse_specialized toState*- Definition Classes
- Foldable
- val traverseSyntax: TraverseSyntax[F]
- Definition Classes
- Traverse
- final def traverseU[A, GB](fa: F[A])(f: (A) => GB)(implicit G: Unapply[Applicative, GB]): M[F[A]]
A version of
traversethat infers the type constructorG.A version of
traversethat infers the type constructorG.- Definition Classes
- Traverse
- final def traverseU_[A, GB](fa: F[A])(f: (A) => GB)(implicit G: Unapply[Applicative, GB]): M[Unit]
A version of
traverse_that infers the type constructorM.A version of
traverse_that infers the type constructorM.- Definition Classes
- Foldable
- def traverse_[M[_], A, B](fa: F[A])(f: (A) => M[B])(implicit a: Applicative[M]): M[Unit]
Strict traversal in an applicative functor
Mthat ignores the result off.Strict traversal in an applicative functor
Mthat ignores the result off.- Definition Classes
- Foldable
- 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(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]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
- def zipL[A, B](fa: F[A], fb: F[B]): F[(A, Option[B])]
- Definition Classes
- Traverse
- def zipR[A, B](fa: F[A], fb: F[B]): F[(Option[A], B)]
- Definition Classes
- Traverse
- def zipWith[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) => C): (List[B], F[C])
- Definition Classes
- Traverse
- def zipWithL[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) => C): F[C]
- Definition Classes
- Traverse
- def zipWithR[A, B, C](fa: F[A], fb: F[B])(f: (Option[A], B) => C): F[C]
- Definition Classes
- Traverse