Traverse1

trait Traverse1[F[_]] extends Traverse[F] with Foldable1[F]

A scalaz.Traverse where traverse is total over scalaz.Applys. That is, toList cannot return an empty list.

Companion
object
trait Foldable1[F]
trait Traverse[F]
trait Foldable[F]
trait Functor[F]
class Object
trait Matchable
class Any

Type members

Classlikes

Inherited classlikes

Inherited from
Foldable1
Inherited from
Foldable
Inherited from
Functor
class Traversal[G[_]](implicit G: Applicative[G])
Inherited from
Traverse
Inherited from
Traverse

Value members

Abstract methods

def traverse1Impl[G[_] : Apply, A, B](fa: F[A])(f: A => G[B]): G[F[B]]

Transform fa using f, collecting all the Gs with ap.

Transform fa using f, collecting all the Gs with ap.

Concrete methods

def compose[G[_] : Traverse1]: Traverse1[[α] =>> F[G[α]]]

The composition of Traverse1 F and G, [x]F[G[x]], is a Traverse1

The composition of Traverse1 F and G, [x]F[G[x]], is a Traverse1

override
def foldMap1[A, B](fa: F[A])(f: A => B)(implicit F: Semigroup[B]): B
Definition Classes
def product[G[_]](implicit G0: Traverse1[G]): Traverse1[[α] =>> (F[α], G[α])]

The product of Traverse1 F and G, [x](F[x], G[x]]), is a Traverse1

The product of Traverse1 F and G, [x](F[x], G[x]]), is a Traverse1

def product0[G[_]](implicit G0: Traverse[G]): Traverse1[[α] =>> (F[α], G[α])]

The product of Traverse1 F and Traverse G, [x](F[x], G[x]]), is a Traverse1

The product of Traverse1 F and Traverse G, [x](F[x], G[x]]), is a Traverse1

def sequence1[G[_] : Apply, A](fga: F[G[A]]): G[F[A]]
def sequence1M[A, G[_]](fgfa: F[G[F[A]]])(implicit G: Apply[G], F: Bind[F]): G[F[A]]

A version of sequence1 where a subsequent monadic join is applied to the inner result

A version of sequence1 where a subsequent monadic join is applied to the inner result

final
def sequence1U[GA](fga: F[GA])(implicit G: Unapply[[F[_]] =>> Apply[F], GA]): M[F[A]]
def traverse1[G[_], A, B](fa: F[A])(f: A => G[B])(implicit a: Apply[G]): G[F[B]]
def traverse1M[A, G[_], B](fa: F[A])(f: A => G[F[B]])(implicit G: Apply[G], F: Bind[F]): G[F[B]]

A version of traverse1 where a subsequent monadic join is applied to the inner result.

A version of traverse1 where a subsequent monadic join is applied to the inner result.

final
def traverse1U[A, GB](fa: F[A])(f: A => GB)(implicit G: Unapply[[F[_]] =>> Apply[F], GB]): M[F[A]]
override
def traverseImpl[G[_] : Applicative, A, B](fa: F[A])(f: A => G[B]): G[F[B]]
Definition Classes

Inherited methods

def all[A](fa: F[A])(p: A => Boolean): Boolean

Whether all As in fa yield true from p.

Whether all As in fa yield true from p.

Inherited from
Foldable
def allM[G[_], A](fa: F[A])(p: A => G[Boolean])(implicit G: Monad[G]): G[Boolean]

all with monadic traversal.

all with monadic traversal.

Inherited from
Foldable
def any[A](fa: F[A])(p: A => Boolean): Boolean

Whether any As in fa yield true from p.

Whether any As in fa yield true from p.

Inherited from
Foldable
def anyM[G[_], A](fa: F[A])(p: A => G[Boolean])(implicit G: Monad[G]): G[Boolean]

any with monadic traversal.

any with monadic traversal.

Inherited from
Foldable
def apply[A, B](fa: F[A])(f: A => B): F[B]

Alias for map.

Alias for map.

Inherited from
Functor
final
def asum[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]

Alias for psum. asum is the name used in Haskell.

Alias for psum. asum is the name used in Haskell.

Inherited from
Foldable
def bicompose[G[_, _] : Bifoldable]: Bifoldable[[α, β] =>> F[G[α, β]]]

The composition of Foldable F and Bifoldable G, [x, y]F[G[x, y]], is a Bifoldable

The composition of Foldable F and Bifoldable G, [x, y]F[G[x, y]], is a Bifoldable

Inherited from
Foldable
def bicompose[G[_, _] : Bitraverse]: Bitraverse[[α, β] =>> F[G[α, β]]]

The composition of Traverse F and Bitraverse G, [x, y]F[G[x, y]], is a Bitraverse

The composition of Traverse F and Bitraverse G, [x, y]F[G[x, y]], is a Bitraverse

Inherited from
Traverse
def bicompose[G[_, _] : Bifunctor]: Bifunctor[[α, β] =>> F[G[α, β]]]

The composition of Functor F and Bifunctor G, [x, y]F[G[x, y]], is a Bifunctor

The composition of Functor F and Bifunctor G, [x, y]F[G[x, y]], is a Bifunctor

Inherited from
Functor
def collapse[X[_], A](x: F[A])(implicit A: ApplicativePlus[X]): X[A]
Inherited from
Foldable
def compose[G[_] : Foldable1]: Foldable1[[α] =>> F[G[α]]]

The composition of Foldable1 F and G, [x]F[G[x]], is a Foldable1

The composition of Foldable1 F and G, [x]F[G[x]], is a Foldable1

Inherited from
Foldable1
def compose[G[_]](implicit G0: Foldable[G]): Foldable[[α] =>> F[G[α]]]

The composition of Foldables F and G, [x]F[G[x]], is a Foldable

The composition of Foldables F and G, [x]F[G[x]], is a Foldable

Inherited from
Foldable
def compose[G[_]](implicit G0: Traverse[G]): Traverse[[α] =>> F[G[α]]]

The composition of Traverses F and G, [x]F[G[x]], is a Traverse

The composition of Traverses F and G, [x]F[G[x]], is a Traverse

Inherited from
Traverse
def compose[G[_]](implicit G0: Functor[G]): Functor[[α] =>> F[G[α]]]

The composition of Functors F and G, [x]F[G[x]], is a Functor

The composition of Functors F and G, [x]F[G[x]], is a Functor

Inherited from
Functor
final
def count[A](fa: F[A]): Int

Alias for length.

Alias for length.

Inherited from
Foldable
def counzip[A, B](a: F[A] \/ F[B]): F[A \/ B]
Inherited from
Functor
def distinct[A](fa: F[A])(implicit A: Order[A]): IList[A]

O(n log n) complexity

O(n log n) complexity

Inherited from
Foldable
def distinct1[A](fa: F[A])(implicit A: Order[A]): NonEmptyList[A]

O(n log n) complexity

O(n log n) complexity

Inherited from
Foldable1
def distinctBy[A, B : Equal](fa: F[A])(f: A => B): IList[A]
Inherited from
Foldable
def distinctE[A](fa: F[A])(implicit A: Equal[A]): IList[A]

O(n^2^) complexity

O(n^2^) complexity

Inherited from
Foldable
def distinctE1[A](fa: F[A])(implicit A: Equal[A]): NonEmptyList[A]

O(n^2^) complexity

O(n^2^) complexity

Inherited from
Foldable1
def element[A : Equal](fa: F[A], a: A): Boolean

Whether a is an element of fa.

Whether a is an element of fa.

Inherited from
Foldable
final override
def empty[A](fa: F[A]): Boolean

always return false

always return false

Definition Classes
Inherited from
Foldable1
def extrema[A : Order](fa: F[A]): Option[(A, A)]

The smallest and largest elements of fa or None if fa is empty

The smallest and largest elements of fa or None if fa is empty

Inherited from
Foldable
def extremaBy[A, B : Order](fa: F[A])(f: A => B): Option[(A, A)]

The elements (amin, amax) of fa which yield the smallest and largest values of f(a), respectively, or None if fa is empty

The elements (amin, amax) of fa which yield the smallest and largest values of f(a), respectively, or None if fa is empty

Inherited from
Foldable
def extremaOf[A, B : Order](fa: F[A])(f: A => B): Option[(B, B)]

The smallest and largest values of f(a) for each element a of fa , or None if fa is empty

The smallest and largest values of f(a) for each element a of fa , or None if fa is empty

Inherited from
Foldable
def filterLength[A](fa: F[A])(f: A => Boolean): Int
Inherited from
Foldable
def findLeft[A](fa: F[A])(f: A => Boolean): Option[A]
Inherited from
Foldable
final
def findMapM[M[_] : Monad, A, B](fa: F[A])(f: A => M[Option[B]]): 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

Inherited from
Foldable
def findRight[A](fa: F[A])(f: A => Boolean): Option[A]
Inherited from
Foldable
def fold[M : Monoid](t: F[M]): M

Combine the elements of a structure using a monoid.

Combine the elements of a structure using a monoid.

Inherited from
Foldable
def fold1[M : Semigroup](t: F[M]): M
Inherited from
Foldable1
def fold1Opt[A : Semigroup](fa: F[A]): Option[A]

Like fold but returning None if the foldable is empty and Some otherwise

Like fold but returning None if the foldable is empty and Some otherwise

Inherited from
Foldable
def foldLShape[A, B](fa: F[A], z: B)(f: (B, A) => B): (B, F[Unit])
Inherited from
Traverse
override
def foldLeft[A, B](fa: F[A], z: B)(f: (B, A) => B): B
Definition Classes
Inherited from
Traverse
def foldLeft1[A](fa: F[A])(f: (A, A) => A): A

Left-associative fold of a structure.

Left-associative fold of a structure.

Inherited from
Foldable1
def foldLeft1Opt[A](fa: F[A])(f: (A, A) => A): Option[A]
Inherited from
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.

Inherited from
Foldable
def foldLeftM1[G[_], A, B](fa: F[A])(z: A => B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]
Inherited from
Foldable1
override
def foldMap[A, B](fa: F[A])(f: A => B)(implicit F: Monoid[B]): B
Definition Classes
Inherited from
Foldable1
override
def foldMap1Opt[A, B](fa: F[A])(f: A => B)(implicit F: Semigroup[B]): Option[B]
Definition Classes
Inherited from
Foldable1
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.

Inherited from
Foldable1
override
def foldMapLeft1Opt[A, B](fa: F[A])(z: A => B)(f: (B, A) => B): Option[B]
Definition Classes
Inherited from
Foldable1
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 B has a Monoid.

Specialization of foldRightM when B has a Monoid.

Inherited from
Foldable
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.

Inherited from
Foldable1
override
def foldMapRight1Opt[A, B](fa: F[A])(z: A => B)(f: (A, => B) => B): Option[B]
Definition Classes
Inherited from
Foldable1
override
def foldRight[A, B](fa: F[A], z: => B)(f: (A, => B) => B): B
Definition Classes
Inherited from
Foldable1
def foldRight1[A](fa: F[A])(f: (A, => A) => A): A

Right-associative fold of a structure.

Right-associative fold of a structure.

Inherited from
Foldable1
def foldRight1Opt[A](fa: F[A])(f: (A, => A) => A): Option[A]
Inherited from
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.

Inherited from
Foldable
def foldRightM1[G[_], A, B](fa: F[A])(z: A => B)(f: (A, => B) => G[B])(implicit G: Monad[G]): G[B]
Inherited from
Foldable1
Inherited from
Foldable
final
def foldl[A, B](fa: F[A], z: B)(f: B => A => B): B

Curried version of foldLeft

Curried version of foldLeft

Inherited from
Foldable
final
def foldl1[A](fa: F[A])(f: A => A => A): A

Curried foldLeft1.

Curried foldLeft1.

Inherited from
Foldable1
override
def foldl1Opt[A](fa: F[A])(f: A => A => A): Option[A]
Definition Classes
Inherited from
Foldable1
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 foldLeftM

Curried version of foldLeftM

Inherited from
Foldable
final
def foldlM1[G[_] : Monad, A, B](fa: F[A])(z: A => B)(f: B => A => G[B]): G[B]

Curried version of foldLeftM1

Curried version of foldLeftM1

Inherited from
Foldable1
final
def foldr[A, B](fa: F[A], z: => B)(f: A => (=> B) => B): B

Curried version of foldRight

Curried version of foldRight

Inherited from
Foldable
final
def foldr1[A](fa: F[A])(f: A => (=> A) => A): A

Curried foldRight1.

Curried foldRight1.

Inherited from
Foldable1
override
def foldr1Opt[A](fa: F[A])(f: A => (=> A) => A): Option[A]
Definition Classes
Inherited from
Foldable1
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 foldRightM

Curried version of foldRightM

Inherited from
Foldable
final
def foldrM1[G[_] : Monad, A, B](fa: F[A])(z: A => B)(f: A => (=> B) => G[B]): G[B]

Curried version of foldRightM1

Curried version of foldRightM1

Inherited from
Foldable1
def fpair[A](fa: F[A]): F[(A, A)]

Twin all As in fa.

Twin all As in fa.

Inherited from
Functor
def fproduct[A, B](fa: F[A])(f: A => B): F[(A, B)]

Pair all As in fa with the result of function application.

Pair all As in fa with the result of function application.

Inherited from
Functor
Inherited from
Functor
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.

Inherited from
Functor
def index[A](fa: F[A], i: Int): Option[A]
Returns

the element at index i in a Some, or None if the given index falls outside of the range

Inherited from
Foldable
def indexOr[A](fa: F[A], default: => A, i: Int): A
Returns

the element at index i, or default if the given index falls outside of the range

Inherited from
Foldable
def indexed[A](fa: F[A]): F[(Int, A)]
Inherited from
Traverse
override
def intercalate[A : Monoid](fa: F[A], a: A): A
Definition Classes
Inherited from
Foldable1
def intercalate1[A](fa: F[A], a: A)(implicit A: Semigroup[A]): A

Insert an A between every A, yielding the sum.

Insert an A between every A, yielding the sum.

Inherited from
Foldable1
def length[A](fa: F[A]): Int

Deforested alias for toStream(fa).size.

Deforested alias for toStream(fa).size.

Inherited from
Foldable
def lift[A, B](f: A => B): F[A] => F[B]

Lift f into F.

Lift f into F.

Inherited from
Functor
def longDigits[A](fa: F[A])(implicit d: A <:< Digit): Long
Inherited from
Foldable
override
def map[A, B](fa: F[A])(f: A => B): F[B]
Definition Classes
Inherited from
Traverse
def mapAccumL[S, A, B](fa: F[A], z: S)(f: (S, A) => (S, B)): (S, F[B])
Inherited from
Traverse
def mapAccumR[S, A, B](fa: F[A], z: S)(f: (S, A) => (S, B)): (S, F[B])
Inherited from
Traverse
def mapply[A, B](a: A)(f: F[A => B]): F[B]

Lift apply(a), and apply the result to f.

Lift apply(a), and apply the result to f.

Inherited from
Functor
override
def maximum[A : Order](fa: F[A]): Option[A]
Definition Classes
Inherited from
Foldable1
def maximum1[A : Order](fa: F[A]): A

The greatest element of fa.

The greatest element of fa.

Inherited from
Foldable1
override
def maximumBy[A, B : Order](fa: F[A])(f: A => B): Option[A]
Definition Classes
Inherited from
Foldable1
def maximumBy1[A, B : Order](fa: F[A])(f: A => B): A

The element a of fa which yield the greatest value of f(a).

The element a of fa which yield the greatest value of f(a).

Inherited from
Foldable1
override
def maximumOf[A, B : Order](fa: F[A])(f: A => B): Option[B]
Definition Classes
Inherited from
Foldable1
def maximumOf1[A, B : Order](fa: F[A])(f: A => B): B

The greatest value of f(a) for each element a of fa.

The greatest value of f(a) for each element a of fa.

Inherited from
Foldable1
override
def minimum[A : Order](fa: F[A]): Option[A]
Definition Classes
Inherited from
Foldable1
def minimum1[A : Order](fa: F[A]): A

The smallest element of fa.

The smallest element of fa.

Inherited from
Foldable1
override
def minimumBy[A, B : Order](fa: F[A])(f: A => B): Option[A]
Definition Classes
Inherited from
Foldable1
def minimumBy1[A, B : Order](fa: F[A])(f: A => B): A

The element a of fa which yield the smallest value of f(a).

The element a of fa which yield the smallest value of f(a).

Inherited from
Foldable1
override
def minimumOf[A, B : Order](fa: F[A])(f: A => B): Option[B]
Definition Classes
Inherited from
Foldable1
def minimumOf1[A, B : Order](fa: F[A])(f: A => B): B

The smallest value of f(a) for each element a of fa.

The smallest value of f(a) for each element a of fa.

Inherited from
Foldable1
def msuml1[G[_], A](fa: F[G[A]])(implicit G: Plus[G]): G[A]
Inherited from
Foldable1
def product[G[_]](implicit G0: Foldable1[G]): Foldable1[[α] =>> (F[α], G[α])]

The product of Foldable1 F and G, [x](F[x], G[x]]), is a Foldable1

The product of Foldable1 F and G, [x](F[x], G[x]]), is a Foldable1

Inherited from
Foldable1
def product[G[_]](implicit G0: Foldable[G]): Foldable[[α] =>> (F[α], G[α])]

The product of Foldables F and G, [x](F[x], G[x]]), is a Foldable

The product of Foldables F and G, [x](F[x], G[x]]), is a Foldable

Inherited from
Foldable
def product[G[_]](implicit G0: Traverse[G]): Traverse[[α] =>> (F[α], G[α])]

The product of Traverses F and G, [x](F[x], G[x]]), is a Traverse

The product of Traverses F and G, [x](F[x], G[x]]), is a Traverse

Inherited from
Traverse
def product[G[_]](implicit G0: Functor[G]): Functor[[α] =>> (F[α], G[α])]

The product of Functors F and G, [x](F[x], G[x]]), is a Functor

The product of Functors F and G, [x](F[x], G[x]]), is a Functor

Inherited from
Functor
def product0[G[_]](implicit G0: Foldable[G]): Foldable1[[α] =>> (F[α], G[α])]

The product of Foldable1 F and Foldable G, [x](F[x], G[x]]), is a Foldable1

The product of Foldable1 F and Foldable G, [x](F[x], G[x]]), is a Foldable1

Inherited from
Foldable1
def product0[G[_]](implicit G0: Foldable1[G]): Foldable1[[α] =>> (F[α], G[α])]

The product of Foldable F and Foldable1 G, [x](F[x], G[x]]), is a Foldable1

The product of Foldable F and Foldable1 G, [x](F[x], G[x]]), is a Foldable1

Inherited from
Foldable
def product0[G[_]](implicit G0: Traverse1[G]): Traverse1[[α] =>> (F[α], G[α])]

The product of Traverse F and Traverse1 G, [x](F[x], G[x]]), is a Traverse1

The product of Traverse F and Traverse1 G, [x](F[x], G[x]]), is a Traverse1

Inherited from
Traverse
def psum[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]

Sum using a polymorphic monoid (PlusEmpty). Should support early termination, i.e. summing no more elements than is needed to determine the result.

Sum using a polymorphic monoid (PlusEmpty). Should support early termination, i.e. summing no more elements than is needed to determine the result.

Inherited from
Foldable
def psum1[G[_], A](fa: F[G[A]])(implicit G: Plus[G]): G[A]
Inherited from
Foldable1
def psumMap[A, B, G[_]](fa: F[A])(f: A => G[B])(implicit G: PlusEmpty[G]): G[B]

Map elements to G[B] and sum using a polymorphic monoid (PlusEmpty). Should support early termination, i.e. mapping and summing no more elements than is needed to determine the result.

Map elements to G[B] and sum using a polymorphic monoid (PlusEmpty). Should support early termination, i.e. mapping and summing no more elements than is needed to determine the result.

Inherited from
Foldable
def psumMap1[A, B, G[_]](fa: F[A])(f: A => G[B])(implicit G: Plus[G]): G[B]
Inherited from
Foldable1
def reverse[A](fa: F[A]): F[A]
Inherited from
Traverse
def runTraverseS[S, A, B](fa: F[A], s: S)(f: A => State[S, B]): (S, F[B])
Inherited from
Traverse
def scanLeft1[A](fa: F[A])(f: (A, A) => A): NonEmptyList[A]
Inherited from
Foldable1
def scanRight1[A](fa: F[A])(f: (A, A) => A): NonEmptyList[A]
Inherited from
Foldable1
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.

Inherited from
Foldable
def sequence[G[_] : Applicative, A](fga: F[G[A]]): G[F[A]]

Traverse with the identity function.

Traverse with the identity function.

Inherited from
Traverse
def sequence1_[M[_], A](fa: F[M[A]])(implicit a: Apply[M], x: Semigroup[M[A]]): M[Unit]
Inherited from
Foldable1
def sequenceF_[M[_], A](ffa: F[Free[M, A]]): Free[M, Unit]

sequence_ for Free. collapses into a single Free *

sequence_ for Free. collapses into a single Free *

Inherited from
Foldable
def sequenceM[A, G[_]](fgfa: F[G[F[A]]])(implicit G: Applicative[G], F: Bind[F]): G[F[A]]

A version of sequence where a subsequent monadic join is applied to the inner result

A version of sequence where a subsequent monadic join is applied to the inner result

Inherited from
Traverse
def sequenceS[S, A](fga: F[State[S, A]]): State[S, F[A]]

Traverse with State.

Traverse with State.

Inherited from
Traverse
def sequenceS_[S, A](fga: F[State[S, A]]): State[S, Unit]

sequence_ specialized to State *

sequence_ specialized to State *

Inherited from
Foldable
final
def sequenceU[A](self: F[A])(implicit G: Unapply[[F[_]] =>> Applicative[F], A]): M[F[A]]

A version of sequence that infers the nested type constructor.

A version of sequence that infers the nested type constructor.

Inherited from
Traverse
def sequence_[M[_], A](fa: F[M[A]])(implicit a: Applicative[M]): M[Unit]

Strict sequencing in an applicative functor M that ignores the value in fa.

Strict sequencing in an applicative functor M that ignores the value in fa.

Inherited from
Foldable
def splitBy[A, B : Equal](fa: F[A])(f: A => 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.

Inherited from
Foldable
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.

Inherited from
Foldable
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.

Inherited from
Foldable
def strengthL[A, B](a: A, f: F[B]): F[(A, B)]

Inject a to the left of Bs in f.

Inject a to the left of Bs in f.

Inherited from
Functor
def strengthR[A, B](f: F[A], b: B): F[(A, B)]

Inject b to the right of As in f.

Inject b to the right of As in f.

Inherited from
Functor
def suml[A](fa: F[A])(implicit A: Monoid[A]): A
Inherited from
Foldable
def suml1[A](fa: F[A])(implicit A: Semigroup[A]): A
Inherited from
Foldable1
def suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
Inherited from
Foldable
def sumr[A](fa: F[A])(implicit A: Monoid[A]): A
Inherited from
Foldable
def sumr1[A](fa: F[A])(implicit A: Semigroup[A]): A
Inherited from
Foldable1
def sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
Inherited from
Foldable
def toEphemeralStream[A](fa: F[A]): EphemeralStream[A]
Inherited from
Foldable
def toIList[A](fa: F[A]): IList[A]
Inherited from
Foldable
def toList[A](fa: F[A]): List[A]
Inherited from
Foldable
def toNel[A](fa: F[A]): NonEmptyList[A]
Inherited from
Foldable1
def toSet[A](fa: F[A]): Set[A]
Inherited from
Foldable
def toStream[A](fa: F[A]): Stream[A]
Inherited from
Foldable
def toVector[A](fa: F[A]): Vector[A]
Inherited from
Foldable
Inherited from
Traverse
def traversalS[S]: Traversal[[_] =>> State[S, _$10]]
Inherited from
Traverse
def traverse[G[_] : Applicative, A, B](fa: F[A])(f: A => G[B]): G[F[B]]
Inherited from
Traverse
def traverse1_[M[_], A, B](fa: F[A])(f: A => M[B])(implicit a: Apply[M], x: Semigroup[M[B]]): M[Unit]
Inherited from
Foldable1
def traverseKTrampoline[S, G[_] : Applicative, A, B](fa: F[A])(f: A => Kleisli[G, S, B]): Kleisli[G, S, F[B]]

Traverse fa with a Kleisli[G, S, B], internally using a Trampoline to avoid stack overflow.

Traverse fa with a Kleisli[G, S, B], internally using a Trampoline to avoid stack overflow.

Inherited from
Traverse
Inherited from
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 traverse where a subsequent monadic join is applied to the inner result.

A version of traverse where a subsequent monadic join is applied to the inner result.

Inherited from
Traverse
def traverseS[S, A, B](fa: F[A])(f: A => State[S, B]): State[S, F[B]]

Traverse with State.

Traverse with State.

Inherited from
Traverse
def traverseSTrampoline[S, G[_] : Applicative, A, B](fa: F[A])(f: A => State[S, G[B]]): State[S, G[F[B]]]

Traverse fa with a State[S, G[B]], internally using a Trampoline to avoid stack overflow.

Traverse fa with a State[S, G[B]], internally using a Trampoline to avoid stack overflow.

Inherited from
Traverse
def traverseS_[S, A, B](fa: F[A])(f: A => State[S, B]): State[S, Unit]

traverse_ specialized to State *

traverse_ specialized to State *

Inherited from
Foldable
final
def traverseU[A, GB](fa: F[A])(f: A => GB)(implicit G: Unapply[[F[_]] =>> Applicative[F], GB]): M[F[A]]

A version of traverse that infers the type constructor G.

A version of traverse that infers the type constructor G.

Inherited from
Traverse
final
def traverseU_[A, GB](fa: F[A])(f: A => GB)(implicit G: Unapply[[F[_]] =>> Applicative[F], GB]): M[Unit]

A version of traverse_ that infers the type constructor M.

A version of traverse_ that infers the type constructor M.

Inherited from
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 M that ignores the result of f.

Strict traversal in an applicative functor M that ignores the result of f.

Inherited from
Foldable
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.

Inherited from
Functor
def widen[A, B](fa: F[A])(implicit ev: Liskov[A, B]): F[B]

Functors are covariant by nature, so we can treat an F[A] as an F[B] if A is a subtype of B.

Functors are covariant by nature, so we can treat an F[A] as an F[B] if A is a subtype of B.

Inherited from
Functor
def xmap[A, B](fa: F[A], f: A => B, g: B => A): F[B]
Inherited from
Functor
def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]

Converts ma to a value of type F[B] using the provided bijection.

Converts ma to a value of type F[B] using the provided bijection.

Inherited from
InvariantFunctor
def xmapi[A, B](ma: F[A])(iso: IsoSet[A, B]): F[B]

Converts ma to a value of type F[B] using the provided isomorphism.

Converts ma to a value of type F[B] using the provided isomorphism.

Inherited from
InvariantFunctor
def zipL[A, B](fa: F[A], fb: F[B]): F[(A, Option[B])]
Inherited from
Traverse
def zipR[A, B](fa: F[A], fb: F[B]): F[(Option[A], B)]
Inherited from
Traverse
def zipWith[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) => C): (List[B], F[C])
Inherited from
Traverse
def zipWithL[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) => C): F[C]
Inherited from
Traverse
def zipWithR[A, B, C](fa: F[A], fb: F[B])(f: (Option[A], B) => C): F[C]
Inherited from
Traverse

Deprecated and Inherited methods

@deprecated("use psum", "7.3.0")
def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
Deprecated
Inherited from
Foldable
@deprecated("use psum", "7.3.0")
def msumlU[GA](fa: F[GA])(implicit G: Unapply[[F[_]] =>> PlusEmpty[F], GA]): M[A]
Deprecated
Inherited from
Foldable

Concrete fields

Inherited fields

Inherited from
Foldable
Inherited from
Functor
Inherited from
Traverse