ForEach

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.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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.

final def compose[G[+_]](implicit g: Covariant[G]): Covariant[[+A]F[G[A]]]

Compose two covariant functors.

final def compose[G[_]](implicit g: Invariant[G]): Invariant[[A]F[G[A]]]

Compose two invariant functors.

def compositionLaw[A, B, C](fa: F[A], f: <=>[A, B], g: <=>[B, C])(implicit equal: Equal[F[C]]): Boolean

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

def equals(arg0: Any): Boolean

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

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

def finalize(): Unit

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

def foldMapM[G[+_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Covariant[G], arg1: IdentityFlatten[G], arg2: Identity[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.

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)]

def fproductLeft[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[(B, A)]

final def getClass(): Class[_]

def groupByNonEmpty[V, K](fa: F[V])(f: (V) ⇒ K): Map[K, NonEmptyChunk[V]]

def groupByNonEmptyM[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

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

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.

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

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]

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 an Ord is defined, or None 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 an Ord is defined, or None 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

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

Returns whether the collection contains at least one element

final def notify(): Unit

final def notifyAll(): Unit

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.

def partitionMapM[G[+_], A, B, C](fa: F[A])(f: (A) ⇒ G[Either[B, C]])(implicit arg0: IdentityFlatten[G], arg1: Covariant[G], both: IdentityBoth[F], either: IdentityEither[F]): G[(F[B], F[C])]

Partitions the collection based on the specified effectual function.

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.

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, returning None 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, returning None 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

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

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

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.

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.

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

Zips each element of the collection with its index.