ForEach

zio.prelude.ForEach
See theForEach companion object
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.

Attributes

Companion
object
Graph
Supertypes
trait Covariant[F]
trait Invariant[F]
class Object
trait Matchable
class Any
Show all
Known subtypes
Self type
ForEach[F]

Members list

Value members

Abstract methods

def forEach[G[_] : Covariant, A, B](fa: F[A])(f: A => G[B]): 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.

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.

Attributes

Concrete methods

def collect[A, B](fa: F[A])(pf: PartialFunction[A, B])(implicit identityBoth: IdentityBoth[F], identityEither: IdentityEither[F]): F[B]

Collects elements of the collection for which the partial functionpf is defined.

Collects elements of the collection for which the partial functionpf is defined.

Attributes

Collects elements of the collection for which the effectual partial function pf is defined.

Collects elements of the collection for which the effectual partial function pf is defined.

Attributes

final def compose[G[_] : ForEach]: ForEach[{ type lambda = [A] =>> F[G[A]]; }#<none>]
def concatenate[A : Identity](fa: F[A]): A

Reduces the collection to a summary value using the associative operation. Alias for fold.

Reduces the collection to a summary value using the associative operation. Alias for fold.

Attributes

def contains[A, A1 >: A](fa: F[A])(a: A1)(implicit A: Equal[A1]): Boolean

Returns whether the collection contains the specified element.

Returns whether the collection contains the specified element.

Attributes

def count[A](fa: F[A])(f: A => Boolean): Int

Returns the number of elements in the collection that satisfy the specified predicate.

Returns the number of elements in the collection that satisfy the specified predicate.

Attributes

def exists[A](fa: F[A])(f: A => Boolean): Boolean

Returns whether any element of the collection satisfies the specified predicate.

Returns whether any element of the collection satisfies the specified predicate.

Attributes

def filter[A](fa: F[A])(f: A => Boolean)(implicit identityBoth: IdentityBoth[F], identityEither: IdentityEither[F]): F[A]

Filters the collection with the predicate f.

Filters the collection with the predicate f.

Attributes

Filters the collection with the effectual predicate f.

Filters the collection with the effectual predicate f.

Attributes

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.

Returns the first element in the collection satisfying the specified predicate if one exists or None otherwise.

Attributes

def flip[G[_] : Covariant, A](fa: F[G[A]]): 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.

Converts a collection with elements that are in the context of effects to a collection of elements in the context of an effect.

Attributes

def fold[A : Identity](fa: F[A]): A

Folds over the elements of this collection using an associative operation and an identity. Alias for reduceIdentity.

Folds over the elements of this collection using an associative operation and an identity. Alias for reduceIdentity.

Attributes

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.

Folds over the elements of this collection from left to right to produce a summary value, maintaining some internal state along the way.

Attributes

def foldLeftM[G[_] : Covariant, S, A](fa: F[A])(s: S)(f: (S, A) => G[S]): 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.

Effectually fold over the elements of this collection from left to right to produce a summary value, maintaining some internal state along the way.

Attributes

def foldMap[A, B : Identity](fa: F[A])(f: A => B): B

Maps each element of the collection to a type B for which an Identity is defined using the function f, then reduces those values to a single summary using the combine operation of Identity, or the identity element if the collection is empty.

Maps each element of the collection to a type B for which an Identity is defined using the function f, then reduces those values to a single summary using the combine operation of Identity, or the identity element if the collection is empty.

Attributes

def foldMapM[G[_] : IdentityBoth, A, B : Identity](fa: F[A])(f: A => G[B]): G[B]

Effectfully maps each element of the collection to a type B for which an Identity is defined using the function f, then reduces those values to a single summary using the combine operation of Identity, or the identity element if the collection is empty.

Effectfully maps each element of the collection to a type B for which an Identity is defined using the function f, then reduces those values to a single summary using the combine operation of Identity, or the identity element if the collection is empty.

Attributes

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.

Folds over the elements of this collection from right to left to produce a summary value, maintaining some internal state along the way.

Attributes

def foldRightM[G[_] : Covariant, S, A](fa: F[A])(s: S)(f: (A, S) => G[S]): 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.

Effectually fold over the elements of this collection from right to left to produce a summary value, maintaining some internal state along the way.

Attributes

def forEachFlatten[G[_] : Covariant, A, B](fa: F[A])(f: A => G[F[B]])(implicit evidence$1: IdentityBoth[G], evidence$2: Covariant[G], F: AssociativeFlatten[F]): G[F[B]]
def forEach_[G[_] : Covariant, A](fa: F[A])(f: A => G[Any]): G[Unit]

Traverses each element in the collection with the specified effectual function f purely for its effects.

Traverses each element in the collection with the specified effectual function f purely for its effects.

Attributes

def forall[A](fa: F[A])(f: A => Boolean): Boolean

Returns whether any element of the collection satisfies the specified predicate.

Returns whether any element of the collection satisfies the specified predicate.

Attributes

def groupByNonEmpty[V, K](fa: F[V])(f: V => K): Map[K, NonEmptyChunk[V]]
def groupByNonEmptyM[G[_] : Covariant, V, K](fa: F[V])(f: V => G[K]): G[Map[K, NonEmptyChunk[V]]]
def intersperse[A](fa: F[A], middle: A)(implicit I: Identity[A]): A

Folds over the elements of this collection using an associative operation with the middle element interspersed between every element.

Folds over the elements of this collection using an associative operation with the middle element interspersed between every element.

Attributes

def isEmpty[A](fa: F[A]): Boolean

Returns whether the collection is empty.

Returns whether the collection is empty.

Attributes

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.

Lifts a function operating on values to a function that operates on each element of a collection.

Attributes

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.

Statefully maps over the elements of the collection, maintaining some state along the way and returning the final state along with the new collection.

Attributes

def maxByOption[A, B : Ord](fa: F[A])(f: A => 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 an Ord is defined, or None otherwise.

Returns the largest element in the collection if one exists, using the function f to map each element to a type for which an Ord is defined, or None otherwise.

Attributes

def maxOption[A : Ord](fa: F[A]): Option[A]

Returns the largest value in the collection if one exists or None otherwise.

Returns the largest value in the collection if one exists or None otherwise.

Attributes

def minByOption[A, B : Ord](fa: F[A])(f: A => 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 an Ord is defined, or None otherwise.

Returns the smallest element in the collection if one exists, using the function f to map each element to a type for which an Ord is defined, or None otherwise.

Attributes

def minOption[A : Ord](fa: F[A]): Option[A]

Returns the smallest value in the collection if one exists or None otherwise.

Returns the smallest value in the collection if one exists or None otherwise.

Attributes

def nonEmpty[A](fa: F[A]): Boolean

Returns whether the collection contains at least one element

Returns whether the collection contains at least one element

Attributes

def partitionMap[A, B, C](fa: F[A])(f: A => Either[B, C])(implicit both: IdentityBoth[F], either: IdentityEither[F]): (F[B], F[C])

Partitions the collection based on the specified function.

Partitions the collection based on the specified function.

Attributes

def partitionMapM[G[_] : Covariant, A, B, C](fa: F[A])(f: A => G[Either[B, C]])(implicit evidence$1: IdentityBoth[G], evidence$2: Covariant[G], both: IdentityBoth[F], either: IdentityEither[F]): G[(F[B], F[C])]

Partitions the collection based on the specified effectual function.

Partitions the collection based on the specified effectual function.

Attributes

def partitionMapV[W, E, A, B](fa: F[A])(f: A => ZValidation[W, E, B])(implicit both: IdentityBoth[F], either: IdentityEither[F]): (F[E], F[B])

Partitions the collection based on the specified validation function.

Partitions the collection based on the specified validation function.

Attributes

def product[A](fa: F[A])(implicit ev: Identity[subtypeF.Type[A]]): A

Returns the product of all elements in the collection.

Returns the product of all elements in the collection.

Attributes

Reduces the collection to a summary value using the associative operation, returning None if the collection is empty.

Reduces the collection to a summary value using the associative operation, returning None if the collection is empty.

Attributes

def reduceIdempotent[A : Equal](fa: F[A]): Option[A]

Reduces the collection to a summary value using the idempotent operation, returning None if the collection is empty.

Reduces the collection to a summary value using the idempotent operation, returning None if the collection is empty.

Attributes

def reduceIdentity[A : Identity](fa: F[A]): A

Reduces the collection to a summary value using the associative operation. Alias for fold.

Reduces the collection to a summary value using the associative operation. Alias for fold.

Attributes

def reduceMapOption[A, B : Associative](fa: F[A])(f: A => 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, returning None if the collection is empty.

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, returning None if the collection is empty.

Attributes

def reduceOption[A](fa: F[A])(f: (A, A) => A): Option[A]

Reduces the collection to a summary value using the binary function f, returning None if the collection is empty.

Reduces the collection to a summary value using the binary function f, returning None if the collection is empty.

Attributes

def reverse[A](fa: F[A]): F[A]

Reverses the order of elements in the collection.

Reverses the order of elements in the collection.

Attributes

def size[A](fa: F[A]): Int

Returns the number of elements in the collection.

Returns the number of elements in the collection.

Attributes

def sum[A](fa: F[A])(implicit ev: Identity[subtypeF.Type[A]]): A

Returns the sum of all elements in the collection.

Returns the sum of all elements in the collection.

Attributes

def toChunk[A](fa: F[A]): Chunk[A]

Converts the collection to a Chunk.

Converts the collection to a Chunk.

Attributes

def toList[A](fa: F[A]): List[A]

Converts the collection to a List.

Converts the collection to a List.

Attributes

def zipAll[A, B, C](fa: F[A], fb: F[B])(implicit both: IdentityBoth[F], either: IdentityEither[F]): F[These[A, B]]

Zips the left collection and right collection together, using None to handle the case where one collection is larger than the other.

Zips the left collection and right collection together, using None to handle the case where one collection is larger than the other.

Attributes

def zipAllWith[A, B, C](fa: F[A], fb: F[B])(f: (These[A, B]) => C)(implicit both: IdentityBoth[F], either: IdentityEither[F]): F[C]

Zips the left collection and right collection together, using the specified function to handle the cases where one collection is larger than the other.

Zips the left collection and right collection together, using the specified function to handle the cases where one collection is larger than the other.

Attributes

def zipWithIndex[A](fa: F[A]): F[(A, Int)]

Zips each element of the collection with its index.

Zips each element of the collection with its index.

Attributes

Inherited methods

final def compose[G[_]](implicit g: Contravariant[G]): Contravariant[{ type lambda = [A] =>> F[G[A]]; }#<none>]

Compose covariant and contravariant functors.

Compose covariant and contravariant functors.

Attributes

Inherited from:
Covariant
final def compose[G[_]](implicit g: Covariant[G]): Covariant[{ type lambda = [A] =>> F[G[A]]; }#<none>]

Compose two covariant functors.

Compose two covariant functors.

Attributes

Inherited from:
Covariant
final def compose[G[_]](implicit g: Invariant[G]): Invariant[{ type lambda = [A] =>> F[G[A]]; }#<none>]

Compose two invariant functors.

Compose two invariant functors.

Attributes

Inherited from:
Invariant
def compositionLaw[A, B, C](fa: F[A], f: Equivalence[A, B], g: Equivalence[B, C])(implicit equal: Equal[F[C]]): Boolean

Attributes

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

Attributes

Inherited from:
Covariant
def fproductLeft[A, B](f: A => B): (F[A]) => F[(B, A)]

Attributes

Inherited from:
Covariant
def identityLaw1[A](fa: F[A])(implicit equal: Equal[F[A]]): Boolean

Attributes

Inherited from:
Invariant
final def invmap[A, B](f: Equivalence[A, B]): Equivalence[F[A], F[B]]

Attributes

Inherited from:
Covariant
final def mapSubset[A, B : AnyType](f: A => B): (F[A]) => F[B]

Attributes

Inherited from:
Covariant