Traverse1

Companion object 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.

Self Type: Traverse1[F]
Source: Traverse1.scala

Linear Supertypes

Foldable1[F], Traverse[F], Foldable[F], Functor[F], InvariantFunctor[F], AnyRef, Any

Known Subclasses

IsomorphismTraverse1

Ordering

Alphabetic
By Inheritance

Inherited

Traverse1
Foldable1
Traverse
Foldable
Functor
InvariantFunctor
AnyRef
Any

Hide All
Show All

Visibility

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 fa using f, collecting all the Gs with ap.

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 in fa yield true from p.
Whether all As in fa yield true from p.

Definition Classes
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.

Definition Classes
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.

Definition Classes
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.

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
final def asum[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
Alias for psum.
Alias for psum. asum is the name used in Haskell.

Definition Classes
Foldable
def bicompose[G[_, _]](implicit arg0: Bitraverse[G]): 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

Definition Classes
Traverse
def bicompose[G[_, _]](implicit arg0: Bifoldable[G]): 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

Definition Classes
Foldable
def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): 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

Definition Classes
Functor
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
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 F and G, [x]F[G[x]], is a Traverse1
def compose[G[_]](implicit arg0: Foldable1[G]): 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

Definition Classes
Foldable1
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

Definition Classes
Traverse
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

Definition Classes
Foldable
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

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) complexity
O(n log n) complexity

Definition Classes
Foldable
def distinct1[A](fa: F[A])(implicit A: Order[A]): NonEmptyList[A]
O(n log n) complexity
O(n log n) complexity

Definition Classes
Foldable1
def distinctBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[A]

Definition Classes
Foldable
def distinctE[A](fa: F[A])(implicit A: Equal[A]): IList[A]
O(n²) complexity
O(n²) complexity

Definition Classes
Foldable
def distinctE1[A](fa: F[A])(implicit A: Equal[A]): NonEmptyList[A]
O(n²) complexity
O(n²) complexity

Definition Classes
Foldable1
def element[A](fa: F[A], a: A)(implicit arg0: Equal[A]): Boolean
Whether a is an element of fa.
Whether a is an element of fa.

Definition Classes
Foldable
final def empty[A](fa: F[A]): Boolean
always return false
always return false

Definition Classes
Foldable1 → Foldable
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 fa or None if fa is empty
The smallest and largest elements of fa or None if fa is empty

Definition Classes
Foldable
def extremaBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[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

Definition Classes
Foldable
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 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

Definition Classes
Foldable
def filterLength[A](fa: F[A])(f: (A) ⇒ Boolean): Int

Definition Classes
Foldable
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 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 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

Definition Classes
Foldable
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
Traverse → Foldable
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 foldLeftM1[G[_], A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ G[B])(implicit G: Monad[G]): G[B]

Definition Classes
Foldable1
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
Foldable1 → Foldable
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.

Definition Classes
Traverse1 → Foldable1
def foldMap1Opt[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): Option[B]
As foldMap but returning None if the foldable is empty and Some otherwise
As foldMap but returning None if the foldable is empty and Some otherwise

Definition Classes
Foldable1 → Foldable
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]

Definition Classes
Foldable1 → 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 B has a Monoid.
Specialization of foldRightM when B has a Monoid.

Definition Classes
Foldable
def foldMapRight1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]

Definition Classes
Foldable1 → 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
Foldable1 → Foldable
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 foldRightM1[G[_], A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit G: Monad[G]): G[B]

Definition Classes
Foldable1
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 foldLeft
Curried 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]

Definition Classes
Foldable1 → 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 foldLeftM
Curried version of foldLeftM

Definition Classes
Foldable
final def foldlM1[G[_], A, B](fa: F[A])(z: (A) ⇒ B)(f: (B) ⇒ (A) ⇒ G[B])(implicit arg0: Monad[G]): G[B]
Curried version of foldLeftM1
Curried version of foldLeftM1

Definition Classes
Foldable1
final def foldr[A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ B): B
Curried version of foldRight
Curried 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]

Definition Classes
Foldable1 → 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 foldRightM
Curried version of foldRightM

Definition Classes
Foldable
final def foldrM1[G[_], A, B](fa: F[A])(z: (A) ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ G[B])(implicit arg0: Monad[G]): G[B]
Curried version of foldRightM1
Curried version of foldRightM1

Definition Classes
Foldable1
def fpair[A](fa: F[A]): F[(A, A)]
Twin all As in fa.
Twin all As in fa.

Definition Classes
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.

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 i in a Some, or None if 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, or default if 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 arg0: Monoid[A]): A
Insert an A between every A, yielding the sum.
Insert an A between every A, yielding the sum.

Definition Classes
Foldable1 → Foldable
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.

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 f into F.
Lift f into F.

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 f into F and apply to F[A].
Lift f into F and apply to F[A].

Definition Classes
Traverse → 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 to f.
Lift apply(a), and apply the result to f.

Definition Classes
Functor
def maximum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]
The greatest element of fa, or None if fa is empty.
The greatest element of fa, or None if fa is empty.

Definition Classes
Foldable1 → Foldable
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 a of fa which yields the greatest value of f(a), or None if fa is empty.
The element a of fa which yields the greatest value of f(a), or None if fa is empty.

Definition Classes
Foldable1 → Foldable
def maximumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[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).

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 element a of fa, or None if fa is empty.
The greatest value of f(a) for each element a of fa, or None if fa is empty.

Definition Classes
Foldable1 → Foldable
def maximumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[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.

Definition Classes
Foldable1
def minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]
The smallest element of fa, or None if fa is empty.
The smallest element of fa, or None if fa is empty.

Definition Classes
Foldable1 → Foldable
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 a of fa which yields the smallest value of f(a), or None if fa is empty.
The element a of fa which yields the smallest value of f(a), or None if fa is empty.

Definition Classes
Foldable1 → Foldable
def minimumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[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).

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 element a of fa, or None if fa is empty.
The smallest value of f(a) for each element a of fa, or None if fa is empty.

Definition Classes
Foldable1 → Foldable
def minimumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[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.

Definition Classes
Foldable1
def msuml1[G[_], A](fa: F[G[A]])(implicit G: Plus[G]): G[A]

Definition Classes
Foldable1
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 F and G, [x](F[x], G[x]]), is a Traverse1
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

Definition Classes
Foldable1
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

Definition Classes
Traverse
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

Definition Classes
Foldable
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

Definition Classes
Functor
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
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

Definition Classes
Foldable1
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

Definition Classes
Traverse
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

Definition Classes
Foldable
def psum[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
Sum using a polymorphic monoid (PlusEmpty).
Sum using a polymorphic monoid (PlusEmpty). Should support early termination, i.e. summing no more elements than is needed to determine the result.

Definition Classes
Foldable
def psum1[G[_], A](fa: F[G[A]])(implicit G: Plus[G]): G[A]

Definition Classes
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).
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.

Definition Classes
Foldable
def psumMap1[A, B, G[_]](fa: F[A])(f: (A) ⇒ G[B])(implicit G: Plus[G]): G[B]

Definition Classes
Foldable1
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 scanLeft1[A](fa: F[A])(f: (A, A) ⇒ A): NonEmptyList[A]

Definition Classes
Foldable1
def scanRight1[A](fa: F[A])(f: (A, A) ⇒ A): NonEmptyList[A]

Definition Classes
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.

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]]
final def sequence1U[GA](fga: F[GA])(implicit G: Unapply[Apply, GA]): M[F[A]]
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 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

Definition Classes
Traverse
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 to State *
sequence_ specialized to State *

Definition Classes
Foldable
final def sequenceU[A](self: F[A])(implicit G: Unapply[Applicative, A]): M[F[A]]
A version of sequence that infers the nested type constructor.
A version of sequence that 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 M that ignores the value in fa.
Strict sequencing in an applicative functor M that ignores the value in fa.

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
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.

Definition Classes
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.

Definition Classes
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.

Definition Classes
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.

Definition Classes
Functor
def suml[A](fa: F[A])(implicit A: Monoid[A]): A

Definition Classes
Foldable
def suml1[A](fa: F[A])(implicit A: Semigroup[A]): A

Definition Classes
Foldable1
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 sumr1[A](fa: F[A])(implicit A: Semigroup[A]): A

Definition Classes
Foldable1
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 toNel[A](fa: F[A]): NonEmptyList[A]

Definition Classes
Foldable1
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[S, S, [X]X, β$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 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]
final def traverse1U[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Apply, GB]): M[F[A]]
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 fa using f, collecting all the Gs with ap.
Transform fa using f, collecting all the Gs with ap.

Definition Classes
Traverse1 → 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 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.

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 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.

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 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.

Definition Classes
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 *

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 traverse that infers the type constructor G.
A version of traverse that infers the type constructor G.

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 constructor M.
A version of traverse_ that infers the type constructor M.

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 M that ignores the result of f.
Strict traversal in an applicative functor M that ignores the result of f.

Definition Classes
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.

Definition Classes
Functor
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
def 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 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.

Definition Classes
Functor
def xmap[A, B](fa: F[A], f: (A) ⇒ B, g: (B) ⇒ A): F[B]
Converts ma to a value of type F[B] using the provided functions f and g.
Converts ma to a value of type F[B] using the provided functions f and g.

Definition Classes
Functor → InvariantFunctor
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.

Definition Classes
InvariantFunctor
def xmapi[A, B](ma: F[A])(iso: Isomorphism.<=>[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.

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

Deprecated Value Members

def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]

Definition Classes
Foldable
Annotations
@deprecated
Deprecated
(Since version 7.3.0) use psum
def msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]

Definition Classes
Foldable
Annotations
@deprecated
Deprecated
(Since version 7.3.0) use psum

Packages

Traverse1

Companion object Traverse1

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

Type Members

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from Foldable1[F]

Inherited from Traverse[F]

Inherited from Foldable[F]

Inherited from Functor[F]

Inherited from InvariantFunctor[F]

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Traverse1 

Companion object Traverse1

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

Type Members

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from Foldable1[F]

Inherited from Traverse[F]

Inherited from Foldable[F]

Inherited from Functor[F]

Inherited from InvariantFunctor[F]

Inherited from AnyRef

Inherited from Any

Ungrouped

Traverse1