trait ForEach[F[+_]] extends Covariant[F]
ForEach
is an abstraction that describes the ability to iterate over
a collection, performing an effect for each element in the collection and
returning a collection with the same shape in the context of the effect.
By choosing the appropriate effect type to traverse with a wide range of operations on collections can be described. In particular, by traversing with state we can describe folds which allow implementing a wide variety of collection operations that produce summaries from a collection of values.
- Self Type
- ForEach[F]
- Alphabetic
- By Inheritance
- ForEach
- Covariant
- Invariant
- CovariantSubset
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def forEach[G[+_], A, B](fa: F[A])(f: (A) => G[B])(implicit arg0: IdentityBoth[G], arg1: Covariant[G]): G[F[B]]
Traverse each element in the collection using the specified effectual function
f
, returning a new collection with the results in the context of the effect.
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
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- final def compose[G[+_]](implicit arg0: ForEach[G]): ForEach[[+A]F[G[A]]]
- final def compose[G[-_]](implicit g: Contravariant[G]): Contravariant[[-A]F[G[A]]]
Compose covariant and contravariant functors.
Compose covariant and contravariant functors.
- Definition Classes
- Covariant
- final def compose[G[+_]](implicit g: Covariant[G]): Covariant[[+A]F[G[A]]]
Compose two covariant functors.
Compose two covariant functors.
- Definition Classes
- Covariant
- final def compose[G[_]](implicit g: Invariant[G]): Invariant[[A]F[G[A]]]
Compose two invariant functors.
Compose two invariant functors.
- Definition Classes
- Invariant
- def compositionLaw[A, B, C](fa: F[A], f: <=>[A, B], g: <=>[B, C])(implicit equal: Equal[F[C]]): Boolean
- Definition Classes
- Invariant
- def contains[A, A1 >: A](fa: F[A])(a: A1)(implicit A: Equal[A1]): Boolean
Returns whether the collection contains the specified element.
- def count[A](fa: F[A])(f: (A) => Boolean): Int
Returns the number of elements in the collection that satisfy the specified predicate.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def exists[A](fa: F[A])(f: (A) => Boolean): Boolean
Returns whether any element of the collection satisfies the specified predicate.
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def find[A](fa: F[A])(f: (A) => Boolean): Option[A]
Returns the first element in the collection satisfying the specified predicate if one exists or
None
otherwise. - def flip[G[+_], A](fa: F[G[A]])(implicit arg0: IdentityBoth[G], arg1: Covariant[G]): G[F[A]]
Converts a collection with elements that are in the context of effects to a collection of elements in the context of an effect.
- def fold[A](fa: F[A])(implicit arg0: Identity[A]): A
Folds over the elements of this collection using an associative operation and an identity.
- def foldLeft[S, A](fa: F[A])(s: S)(f: (S, A) => S): S
Folds over the elements of this collection from left to right to produce a summary value, maintaining some internal state along the way.
- def foldLeftM[G[+_], S, A](fa: F[A])(s: S)(f: (S, A) => G[S])(implicit arg0: IdentityFlatten[G], arg1: Covariant[G]): G[S]
Effectually fold over the elements of this collection from left to right to produce a summary value, maintaining some internal state along the way.
- def foldMap[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Identity[B]): B
Maps each element of the collection to a type
B
for which anIdentity
is defined using the functionf
, then reduces those values to a single summary using thecombine
operation ofIdentity
, or theidentity
element if the collection is empty. - def foldRight[S, A](fa: F[A])(s: S)(f: (A, S) => S): S
Folds over the elements of this collection from right to left to produce a summary value, maintaining some internal state along the way.
- def foldRightM[G[+_], S, A](fa: F[A])(s: S)(f: (A, S) => G[S])(implicit arg0: IdentityFlatten[G], arg1: Covariant[G]): G[S]
Effectually fold over the elements of this collection from right to left to produce a summary value, maintaining some internal state along the way.
- def forEach_[G[+_], A](fa: F[A])(f: (A) => G[Any])(implicit arg0: IdentityBoth[G], arg1: Covariant[G]): G[Unit]
Traverses each element in the collection with the specified effectual function
f
purely for its effects. - def forall[A](fa: F[A])(f: (A) => Boolean): Boolean
Returns whether any element of the collection satisfies the specified predicate.
- def fproduct[A, B](f: (A) => B): (F[A]) => F[(A, B)]
- Definition Classes
- Covariant
- def fproductLeft[A, B](f: (A) => B): (F[A]) => F[(B, A)]
- Definition Classes
- Covariant
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def groupBy[V, K](fa: F[V])(f: (V) => K): Map[K, NonEmptyChunk[V]]
- def groupByM[G[+_], V, K](fa: F[V])(f: (V) => G[K])(implicit arg0: IdentityBoth[G], arg1: Covariant[G]): G[Map[K, NonEmptyChunk[V]]]
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def identityLaw1[A](fa: F[A])(implicit equal: Equal[F[A]]): Boolean
- Definition Classes
- Invariant
- final def invmap[A, B](f: <=>[A, B]): <=>[F[A], F[B]]
- def isEmpty[A](fa: F[A]): Boolean
Returns whether the collection is empty.
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def map[A, B](f: (A) => B): (F[A]) => F[B]
Lifts a function operating on values to a function that operates on each element of a collection.
- def mapAccum[S, A, B](fa: F[A])(s: S)(f: (S, A) => (S, B)): (S, F[B])
Statefully maps over the elements of the collection, maintaining some state along the way and returning the final state along with the new collection.
- final def mapSubset[A, B](f: (A) => B)(implicit arg0: AnyType[B]): (F[A]) => F[B]
- Definition Classes
- Covariant → CovariantSubset
- def maxByOption[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Ord[B]): Option[A]
Returns the largest element in the collection if one exists, using the function
f
to map each element to a type for which anOrd
is defined, orNone
otherwise. - def maxOption[A](fa: F[A])(implicit arg0: Ord[A]): Option[A]
Returns the largest value in the collection if one exists or
None
otherwise. - def minByOption[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Ord[B]): Option[A]
Returns the smallest element in the collection if one exists, using the function
f
to map each element to a type for which anOrd
is defined, orNone
otherwise. - def minOption[A](fa: F[A])(implicit arg0: Ord[A]): Option[A]
Returns the smallest value in the collection if one exists or
None
otherwise. - final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nonEmpty[A](fa: F[A]): Boolean
Returns whether the collection contains at least one element
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def product[A](fa: F[A])(implicit ev: Identity[Prod[A]]): A
Returns the product of all elements in the collection.
- def reduceAssociative[A](fa: F[A])(implicit arg0: Associative[A]): Option[A]
Reduces the collection to a summary value using the associative operation, returning
None
if the collection is empty. - def reduceIdempotent[A](fa: F[A])(implicit arg0: Idempotent[A], arg1: Equal[A]): Option[A]
Reduces the collection to a summary value using the idempotent operation, returning
None
if the collection is empty. - def reduceIdentity[A](fa: F[A])(implicit arg0: Identity[A]): A
Reduces the collection to a summary value using the associative operation.
- def reduceMapOption[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Associative[B]): Option[B]
Maps each element of the collection to a type
B
for which an associative operation exists and then reduces the values using the associative operation, returningNone
if the collection is empty. - def reduceOption[A](fa: F[A])(f: (A, A) => A): Option[A]
Reduces the collection to a summary value using the binary function
f
, returningNone
if the collection is empty. - def reverse[A](fa: F[A]): F[A]
Reverses the order of elements in the collection.
- def size[A](fa: F[A]): Int
Returns the number of elements in the collection.
- def sum[A](fa: F[A])(implicit ev: Identity[Sum[A]]): A
Returns the sum of all elements in the collection.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toChunk[A](fa: F[A]): Chunk[A]
Converts the collection to a
Chunk
. - def toList[A](fa: F[A]): List[A]
Converts the collection to a
List
. - def toString(): String
- Definition Classes
- AnyRef → Any
- 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 zipWithIndex[A](fa: F[A]): F[(A, Int)]
Zips each element of the collection with its index.