zio-prelude-docs
API
Generated with
zio-prelude-docs/zio.prelude/ForEachSyntax/ForEachOps

ForEachOps

zio.prelude.ForEachSyntax.ForEachOps
implicit class ForEachOps[F[_], A](self: F[A])

Provides infix syntax for traversing collections.

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any

Members list

Value members

Concrete methods

def collect[B](pf: PartialFunction[A, B])(implicit F: ForEach[F], I: IdentityEither[F], B: IdentityBoth[F]): F[B]
def collectM[G[_] : IdentityBoth, B](f: A => G[Option[B]])(implicit evidence$1: IdentityBoth[G], evidence$2: Covariant[G], F: ForEach[F], I: IdentityEither[F], B: IdentityBoth[F]): G[F[B]]
def concatenate(implicit F: ForEach[F], A: Identity[A]): A
def contains[A1 >: A](a: A1)(implicit A: Equal[A1], F: ForEach[F]): Boolean
def count(f: A => Boolean)(implicit F: ForEach[F]): Int
def exists(f: A => Boolean)(implicit F: ForEach[F]): Boolean
def filter(f: A => Boolean)(implicit F: ForEach[F], I: IdentityEither[F], B: IdentityBoth[F]): F[A]
def filterM[G[_] : IdentityBoth](f: A => G[Boolean])(implicit evidence$1: IdentityBoth[G], evidence$2: Covariant[G], F: ForEach[F], I: IdentityEither[F], B: IdentityBoth[F]): G[F[A]]
def find(f: A => Boolean)(implicit F: ForEach[F]): Option[A]
def foldLeft[S](s: S)(f: (S, A) => S)(implicit F: ForEach[F]): S
def foldLeftM[G[_] : Covariant, S](s: S)(f: (S, A) => G[S])(implicit evidence$1: IdentityFlatten[G], evidence$2: Covariant[G], F: ForEach[F]): G[S]
def foldMap[B : Identity](f: A => B)(implicit evidence$1: Identity[B], F: ForEach[F]): B
def foldMapM[G[_] : IdentityBoth, B : Identity](f: A => G[B])(implicit evidence$1: Covariant[G], evidence$2: IdentityBoth[G], evidence$3: Identity[B], F: ForEach[F]): G[B]
def foldRight[S](s: S)(f: (A, S) => S)(implicit F: ForEach[F]): S
def foldRightM[G[_] : Covariant, S](s: S)(f: (A, S) => G[S])(implicit evidence$1: IdentityFlatten[G], evidence$2: Covariant[G], F: ForEach[F]): G[S]
def forEach[G[_] : Covariant, B](f: A => G[B])(implicit evidence$1: IdentityBoth[G], evidence$2: Covariant[G], F: ForEach[F]): G[F[B]]
def forEachFlatten[G[_] : Covariant, B](f: A => G[F[B]])(implicit evidence$1: IdentityBoth[G], evidence$2: Covariant[G], F: ForEach[F], AF: AssociativeFlatten[F]): G[F[B]]
def forEach_[G[_] : Covariant](f: A => G[Any])(implicit evidence$1: IdentityBoth[G], evidence$2: Covariant[G], F: ForEach[F]): G[Unit]
def forall(f: A => Boolean)(implicit F: ForEach[F]): Boolean
def intersperse[A1 >: A](middle: A1)(implicit F: ForEach[F], I: Identity[A1]): A1
def isEmpty(implicit F: ForEach[F]): Boolean
def mapAccum[S, B](s: S)(f: (S, A) => (S, B))(implicit F: ForEach[F]): (S, F[B])
def maxByOption[B : Ord](f: A => B)(implicit evidence$1: Ord[B], F: ForEach[F]): Option[A]
def maxOption(implicit A: Ord[A], F: ForEach[F]): Option[A]
def minByOption[B : Ord](f: A => B)(implicit evidence$1: Ord[B], F: ForEach[F]): Option[A]
def minOption(implicit A: Ord[A], F: ForEach[F]): Option[A]
def nonEmpty(implicit F: ForEach[F]): Boolean
def product(implicit A: Identity[subtypeF.Type[A]], F: ForEach[F]): A
def reduceAssociative(implicit F: ForEach[F], A: Associative[A]): Option[A]
def reduceIdempotent(implicit F: ForEach[F], ia: Idempotent[A], ea: Equal[A]): Option[A]
def reduceIdentity(implicit F: ForEach[F], A: Identity[A]): A
def reduceMapOption[B : Associative](f: A => B)(implicit evidence$1: Associative[B], F: ForEach[F]): Option[B]
def reduceOption(f: (A, A) => A)(implicit F: ForEach[F]): Option[A]
def reverse(implicit F: ForEach[F]): F[A]
def size(implicit F: ForEach[F]): Int
def sum(implicit A: Identity[subtypeF.Type[A]], F: ForEach[F]): A
def toChunk(implicit F: ForEach[F]): Chunk[A]
def withFilter(f: A => Boolean)(implicit F: ForEach[F], I: IdentityEither[F], B: IdentityBoth[F]): F[A]
def zipAll[B](that: F[B])(implicit F: ForEach[F], both: IdentityBoth[F], either: IdentityEither[F]): F[These[A, B]]
def zipAllWith[B, C](that: F[B])(f: (These[A, B]) => C)(implicit F: ForEach[F], both: IdentityBoth[F], either: IdentityEither[F]): F[C]
def zipWithIndex(implicit F: ForEach[F]): F[(A, Int)]
Generated with