implicit class ForEachOps[F[+_], A] extends AnyRef
Provides infix syntax for traversing collections.
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- ForEachOps
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- All
Instance Constructors
- new ForEachOps(self: F[A])
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- 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
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def exists(f: (A) ⇒ Boolean)(implicit F: ForEach[F]): Boolean
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- 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[+_], S](s: S)(f: (S, A) ⇒ G[S])(implicit arg0: IdentityFlatten[G], arg1: Covariant[G], F: ForEach[F]): G[S]
- def foldMap[B](f: (A) ⇒ B)(implicit arg0: Identity[B], F: ForEach[F]): B
- def foldMapM[G[+_], B](f: (A) ⇒ G[B])(implicit arg0: Covariant[G], arg1: IdentityFlatten[G], arg2: Identity[B], F: ForEach[F]): G[B]
- def foldRight[S](s: S)(f: (A, S) ⇒ S)(implicit F: ForEach[F]): S
- def foldRightM[G[+_], S](s: S)(f: (A, S) ⇒ G[S])(implicit arg0: IdentityFlatten[G], arg1: Covariant[G], F: ForEach[F]): G[S]
- def forEach[G[+_], B](f: (A) ⇒ G[B])(implicit arg0: IdentityBoth[G], arg1: Covariant[G], F: ForEach[F]): G[F[B]]
- def forEach_[G[+_]](f: (A) ⇒ G[Any])(implicit arg0: IdentityBoth[G], arg1: Covariant[G], F: ForEach[F]): G[Unit]
- def forall(f: (A) ⇒ Boolean)(implicit F: ForEach[F]): Boolean
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def intersperse[A1 >: A](middle: A1)(implicit F: ForEach[F], I: Identity[A1]): A1
- def isEmpty(implicit F: ForEach[F]): Boolean
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def mapAccum[S, B](s: S)(f: (S, A) ⇒ (S, B))(implicit F: ForEach[F]): (S, F[B])
- def maxByOption[B](f: (A) ⇒ B)(implicit arg0: Ord[B], F: ForEach[F]): Option[A]
- def maxOption(implicit A: Ord[A], F: ForEach[F]): Option[A]
- def minByOption[B](f: (A) ⇒ B)(implicit arg0: Ord[B], F: ForEach[F]): Option[A]
- def minOption(implicit A: Ord[A], F: ForEach[F]): Option[A]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nonEmpty(implicit F: ForEach[F]): Boolean
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def product(implicit A: Identity[Prod[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](f: (A) ⇒ B)(implicit arg0: 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[Sum[A]], F: ForEach[F]): A
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def toChunk(implicit F: ForEach[F]): Chunk[A]
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- 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)]