DeriveBuildFrom

zio.prelude.InvariantVersionSpecific.DeriveBuildFrom
See theDeriveBuildFrom companion object
trait DeriveBuildFrom[F[_]]

Attributes

Companion
object
Graph
Supertypes
class Object
trait Matchable
class Any

Members list

Value members

Abstract methods

def derive[A]: BuildFrom[F[Any], A, F[A]]
def forEach[G[_] : Covariant, A, B](fa: F[A])(f: A => G[B]): G[F[B]]
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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

Implicitly added by IterableForEach

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>]
Implicitly added by IterableForEach
def concatenate[A : Identity](fa: F[A]): A
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

Filters the collection with the predicate f.

Filters the collection with the predicate f.

Attributes

Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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]]
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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]]
Implicitly added by IterableForEach
def forEach_[G[_] : Covariant, A](fa: F[A])(f: A => G[Any]): G[Unit]
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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]]
Implicitly added by IterableForEach
def groupByNonEmptyM[G[_] : Covariant, V, K](fa: F[V])(f: V => G[K]): G[Map[K, NonEmptyChunk[V]]]
Implicitly added by IterableForEach
def intersperse[A](fa: F[A], middle: A)(implicit I: Identity[A]): A
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

Returns whether the collection is empty.

Returns whether the collection is empty.

Attributes

def map[A, B](f: A => B): (F[A]) => F[B]
Implicitly added by IterableForEach

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])
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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])
Implicitly added by IterableForEach

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])]
Implicitly added by IterableForEach

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])
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

Returns the product of all elements in the collection.

Returns the product of all elements in the collection.

Attributes

Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

Reverses the order of elements in the collection.

Reverses the order of elements in the collection.

Attributes

def size[A](fa: F[A]): Int
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

Converts the collection to a Chunk.

Converts the collection to a Chunk.

Attributes

def toList[A](fa: F[A]): List[A]
Implicitly added by IterableForEach

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]]
Implicitly added by IterableForEach

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]
Implicitly added by IterableForEach

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)]
Implicitly added by IterableForEach

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>]
Implicitly added by IterableForEach

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>]
Implicitly added by IterableForEach

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>]
Implicitly added by IterableForEach

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
Implicitly added by IterableForEach

Attributes

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

Attributes

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

Attributes

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

Attributes

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

Attributes

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

Attributes

Inherited from:
Covariant