trait Traverse1[F[_]] extends Traverse[F] with Foldable1[F] with Traverse1Parent[F]
A scalaz.Traverse where traverse is total over
scalaz.Applys. That is, toList cannot return an empty list.
- Self Type
- Traverse1[F]
- Source
- Traverse1.scala
- Alphabetic
- By Inheritance
- Traverse1
- Traverse1Parent
- Foldable1
- Foldable1Parent
- Traverse
- TraverseParent
- Foldable
- FoldableParent
- Functor
- InvariantFunctor
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
FoldableLaw extends AnyRef
- Definition Classes
- Foldable
-
trait
Foldable1Law extends FoldableLaw
- Definition Classes
- Foldable1
-
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
- trait Traverse1Law extends TraverseLaw
Abstract Value Members
-
abstract
def
foldMapRight1[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): B
Right-associative fold of a structure.
Right-associative fold of a structure.
- Definition Classes
- Foldable1
-
abstract
def
traverse1Impl[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Apply[G]): G[F[B]]
Transform
fausingf, collecting all theGs withap.
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[[a, b]F[G[a, b]]]
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[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
collapse[X[_], A](x: F[A])(implicit A: ApplicativePlus[X]): X[A]
- Definition Classes
- Foldable
-
def
compose[G[_]](implicit arg0: Traverse1[G]): Traverse1[[α]F[G[α]]]
The composition of Traverse1
FandG,[x]F[G[x]], is a Traverse1 -
def
compose[G[_]](implicit arg0: Foldable1[G]): Foldable1[[α]F[G[α]]]
The composition of Foldable1
FandG,[x]F[G[x]], is a Foldable1The composition of Foldable1
FandG,[x]F[G[x]], is a Foldable1- Definition Classes
- Foldable1
-
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
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
-
final
def
empty[A](fa: F[A]): Boolean
always return
false -
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): 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[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
findLeft[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
- Definition Classes
- FoldableParent
-
def
findMapM[M[_], A, B](fa: F[A])(f: (A) ⇒ M[Option[B]])(implicit arg0: Monad[M]): M[Option[B]]
- Definition Classes
- FoldableParent
-
def
findRight[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
- Definition Classes
- FoldableParent
-
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
fold1[M](t: F[M])(implicit arg0: Semigroup[M]): M
- Definition Classes
- Foldable1
-
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.
-
def
foldLeft1[A](fa: F[A])(f: (A, A) ⇒ A): A
Left-associative fold of a structure.
Left-associative fold of a structure.
- Definition Classes
- Foldable1
-
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.
-
def
foldMap1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): B
Map each element of the structure to a scalaz.Semigroup, and combine the results.
Map each element of the structure to a scalaz.Semigroup, and combine the results.
-
def
foldMap1Opt[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): Option[B]
As
foldMapbut returningNoneif the foldable is empty andSomeotherwise -
def
foldMapLeft1[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): B
Left-associative fold of a structure.
Left-associative fold of a structure.
- Definition Classes
- Foldable1
- def foldMapLeft1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]
-
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]
-
def
foldRight[A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B
Right-associative fold of a structure.
-
def
foldRight1[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): A
Right-associative fold of a structure.
Right-associative fold of a structure.
- Definition Classes
- Foldable1
-
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
foldable1Law: Foldable1Law
- Definition Classes
- Foldable1
-
val
foldable1Syntax: Foldable1Syntax[F]
- Definition Classes
- Foldable1
-
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
-
final
def
foldl1[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): A
Curried
foldLeft1.Curried
foldLeft1.- Definition Classes
- Foldable1
- def foldl1Opt[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): Option[A]
-
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
-
final
def
foldr1[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): A
Curried
foldRight1.Curried
foldRight1.- Definition Classes
- Foldable1
- def foldr1Opt[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]
-
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[_]
- 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
- TraverseParent
-
def
intercalate[A](fa: F[A], a: A)(implicit arg0: Monoid[A]): A
Insert an
Abetween every A, yielding the sum. -
def
intercalate1[A](fa: F[A], a: A)(implicit A: Semigroup[A]): A
Insert an
Abetween every A, yielding the sum.Insert an
Abetween every A, yielding the sum.- Definition Classes
- Foldable1
-
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]. -
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. -
def
maximum1[A](fa: F[A])(implicit arg0: Order[A]): A
The greatest element of
fa.The greatest element of
fa.- Definition Classes
- Foldable1
-
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. -
def
maximumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): A
The element
aoffawhich yield the greatest value off(a).The element
aoffawhich yield the greatest value off(a).- Definition Classes
- Foldable1
-
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. -
def
maximumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): B
The greatest value of
f(a)for each elementaoffa.The greatest value of
f(a)for each elementaoffa.- Definition Classes
- Foldable1
-
def
minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]
The smallest element of
fa, or None iffais empty. -
def
minimum1[A](fa: F[A])(implicit arg0: Order[A]): A
The smallest element of
fa.The smallest element of
fa.- Definition Classes
- Foldable1
-
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. -
def
minimumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): A
The element
aoffawhich yield the smallest value off(a).The element
aoffawhich yield the smallest value off(a).- Definition Classes
- Foldable1
-
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. -
def
minimumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): B
The smallest value of
f(a)for each elementaoffa.The smallest value of
f(a)for each elementaoffa.- Definition Classes
- Foldable1
-
def
msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
- Definition Classes
- FoldableParent
-
def
msuml1[G[_], A](fa: F[G[A]])(implicit arg0: Plus[G]): G[A]
- Definition Classes
- Foldable1Parent
-
def
msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]
- Definition Classes
- FoldableParent
-
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: Traverse1[G]): Traverse1[[α](F[α], G[α])]
The product of Traverse1
FandG,[x](F[x], G[x]]), is a Traverse1 -
def
product[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](F[α], G[α])]
The product of Foldable1
FandG,[x](F[x], G[x]]), is a Foldable1The product of Foldable1
FandG,[x](F[x], G[x]]), is a Foldable1- Definition Classes
- Foldable1
-
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: Traverse[G]): Traverse1[[α](F[α], G[α])]
The product of Traverse1
Fand TraverseG,[x](F[x], G[x]]), is a Traverse1 -
def
product0[G[_]](implicit G0: Foldable[G]): Foldable1[[α](F[α], G[α])]
The product of Foldable1
Fand FoldableG,[x](F[x], G[x]]), is a Foldable1The product of Foldable1
Fand FoldableG,[x](F[x], G[x]]), is a Foldable1- Definition Classes
- Foldable1
-
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 sequence1[G[_], A](fga: F[G[A]])(implicit arg0: Apply[G]): G[F[A]]
-
def
sequence1U[GA](fga: F[GA])(implicit G: Unapply[Apply, GA]): M[F[A]]
- Definition Classes
- Traverse1Parent
-
def
sequence1_[M[_], A](fa: F[M[A]])(implicit a: Apply[M], x: Semigroup[M[A]]): M[Unit]
- Definition Classes
- Foldable1
-
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
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
suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
- Definition Classes
- FoldableParent
-
def
sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
- Definition Classes
- FoldableParent
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
to[A, G[_]](fa: F[A])(implicit c: CanBuildFrom[Nothing, A, G[A]]): G[A]
- Definition Classes
- Foldable
-
def
toEphemeralStream[A](fa: F[A]): EphemeralStream[A]
- Definition Classes
- Foldable
-
def
toIList[A](fa: F[A]): IList[A]
- Definition Classes
- Foldable
-
def
toIndexedSeq[A](fa: F[A]): IndexedSeq[A]
- Definition Classes
- Foldable
-
def
toList[A](fa: F[A]): List[A]
- Definition Classes
- Foldable
-
def
toNel[A](fa: F[A]): NonEmptyList[A]
- Definition Classes
- Foldable1Parent
-
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
traversal[G[_]](implicit arg0: Applicative[G]): Traversal[G]
- Definition Classes
- Traverse
-
def
traversalS[S]: Traversal[[x]IndexedStateT[[X]X, S, S, x]]
- 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 traverse1[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit a: Apply[G]): G[F[B]]
- def traverse1Law: Traverse1Law
- val traverse1Syntax: Traverse1Syntax[F]
-
def
traverse1U[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Apply, GB]): M[F[A]]
- Definition Classes
- Traverse1Parent
-
def
traverse1_[M[_], A, B](fa: F[A])(f: (A) ⇒ M[B])(implicit a: Apply[M], x: Semigroup[M[B]]): M[Unit]
- Definition Classes
- Foldable1
-
def
traverseImpl[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Applicative[G]): G[F[B]]
Transform
fausingf, collecting all theGs withap. -
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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
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: BijectionT.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