Packages

implicit class ForEachOps[F[+_], A] extends AnyRef

Provides infix syntax for traversing collections.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ForEachOps
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new ForEachOps(self: F[A])

Value Members

  1. def concatenate(implicit F: ForEach[F], A: Identity[A]): A
  2. def contains[A1 >: A](a: A1)(implicit A: Equal[A1], F: ForEach[F]): Boolean
  3. def count(f: (A) => Boolean)(implicit F: ForEach[F]): Int
  4. def exists(f: (A) => Boolean)(implicit F: ForEach[F]): Boolean
  5. def find(f: (A) => Boolean)(implicit F: ForEach[F]): Option[A]
  6. def foldLeft[S](s: S)(f: (S, A) => S)(implicit F: ForEach[F]): S
  7. def foldLeftM[G[+_], S](s: S)(f: (S, A) => G[S])(implicit arg0: IdentityFlatten[G], arg1: Covariant[G], F: ForEach[F]): G[S]
  8. def foldMap[B](f: (A) => B)(implicit arg0: Identity[B], F: ForEach[F]): B
  9. def foldMapM[G[+_], B](f: (A) => G[B])(implicit arg0: Covariant[G], arg1: IdentityFlatten[G], arg2: Identity[B], F: ForEach[F]): G[B]
  10. def foldRight[S](s: S)(f: (A, S) => S)(implicit F: ForEach[F]): S
  11. def foldRightM[G[+_], S](s: S)(f: (A, S) => G[S])(implicit arg0: IdentityFlatten[G], arg1: Covariant[G], F: ForEach[F]): G[S]
  12. def forEach[G[+_], B](f: (A) => G[B])(implicit arg0: IdentityBoth[G], arg1: Covariant[G], F: ForEach[F]): G[F[B]]
  13. def forEach_[G[+_]](f: (A) => G[Any])(implicit arg0: IdentityBoth[G], arg1: Covariant[G], F: ForEach[F]): G[Unit]
  14. def forall(f: (A) => Boolean)(implicit F: ForEach[F]): Boolean
  15. def intersperse[A1 >: A](middle: A1)(implicit F: ForEach[F], I: Identity[A1]): A1
  16. def isEmpty(implicit F: ForEach[F]): Boolean
  17. def mapAccum[S, B](s: S)(f: (S, A) => (S, B))(implicit F: ForEach[F]): (S, F[B])
  18. def maxByOption[B](f: (A) => B)(implicit arg0: Ord[B], F: ForEach[F]): Option[A]
  19. def maxOption(implicit A: Ord[A], F: ForEach[F]): Option[A]
  20. def minByOption[B](f: (A) => B)(implicit arg0: Ord[B], F: ForEach[F]): Option[A]
  21. def minOption(implicit A: Ord[A], F: ForEach[F]): Option[A]
  22. def nonEmpty(implicit F: ForEach[F]): Boolean
  23. def product(implicit A: Identity[Prod[A]], F: ForEach[F]): A
  24. def reduceAssociative(implicit F: ForEach[F], A: Associative[A]): Option[A]
  25. def reduceIdempotent(implicit F: ForEach[F], ia: Idempotent[A], ea: Equal[A]): Option[A]
  26. def reduceIdentity(implicit F: ForEach[F], A: Identity[A]): A
  27. def reduceMapOption[B](f: (A) => B)(implicit arg0: Associative[B], F: ForEach[F]): Option[B]
  28. def reduceOption(f: (A, A) => A)(implicit F: ForEach[F]): Option[A]
  29. def reverse(implicit F: ForEach[F]): F[A]
  30. def size(implicit F: ForEach[F]): Int
  31. def sum(implicit A: Identity[Sum[A]], F: ForEach[F]): A
  32. def toChunk(implicit F: ForEach[F]): Chunk[A]
  33. def zipAll[B](that: F[B])(implicit F: ForEach[F], both: IdentityBoth[F], either: IdentityEither[F]): F[These[A, B]]
  34. def zipAllWith[B, C](that: F[B])(f: (These[A, B]) => C)(implicit F: ForEach[F], both: IdentityBoth[F], either: IdentityEither[F]): F[C]
  35. def zipWithIndex(implicit F: ForEach[F]): F[(A, Int)]