Packages

trait NonEmptyForEach[F[+_]] extends ForEach[F]

A NonEmptyForEach describes a ForEach that is guaranteed to contain at least one element, such as a NonEmptyList, a NonEmptyChunk, or certain tree like data structures.

Because of the additional information that there is always at least one element, certain operations are available on a NonEmptyForEach that are not available on a ForEach. For example, if an ordering is defined on the elements of a NonEmptyForEach then min and max are defined, whereas for a ForEach only minOption and maxOption would be, since the collection might not contain any elements at all.

Linear Supertypes
ForEach[F], Covariant[F], Invariant[F], CovariantSubset[F, AnyType], AnyRef, Any
Known Subclasses
DeriveEqualNonEmptyForEach
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. NonEmptyForEach
  2. ForEach
  3. Covariant
  4. Invariant
  5. CovariantSubset
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def forEach1[G[+_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: AssociativeBoth[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.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native() @HotSpotIntrinsicCandidate()
  6. def collect[A, B](fa: F[A])(pf: PartialFunction[A, B])(implicit identityBoth: IdentityBoth[F], identityEither: IdentityEither[F]): F[B]

    Collects elements of the collection for which the partial functionpf is defined.

    Collects elements of the collection for which the partial functionpf is defined.

    Definition Classes
    ForEach
  7. def collectM[G[+_], A, B](fa: F[A])(f: (A) ⇒ G[Option[B]])(implicit arg0: IdentityBoth[G], arg1: Covariant[G], identityBoth: IdentityBoth[F], identityEither: IdentityEither[F]): G[F[B]]

    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.

    Definition Classes
    ForEach
  8. final def compose[G[+_]](implicit arg0: ForEach[G]): ForEach[[+A]F[G[A]]]
    Definition Classes
    ForEach
  9. final def compose[G[-_]](implicit g: Contravariant[G]): Contravariant[[-A]F[G[A]]]

    Compose covariant and contravariant functors.

    Compose covariant and contravariant functors.

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

    Compose two covariant functors.

    Compose two covariant functors.

    Definition Classes
    Covariant
  11. final def compose[G[_]](implicit g: Invariant[G]): Invariant[[A]F[G[A]]]

    Compose two invariant functors.

    Compose two invariant functors.

    Definition Classes
    Invariant
  12. def compositionLaw[A, B, C](fa: F[A], f: <=>[A, B], g: <=>[B, C])(implicit equal: Equal[F[C]]): Boolean
    Definition Classes
    Invariant
  13. def concatenate[A](fa: F[A])(implicit arg0: Identity[A]): A

    Reduces the collection to a summary value using the associative operation.

    Reduces the collection to a summary value using the associative operation. Alias for fold.

    Definition Classes
    ForEach
  14. def contains[A, A1 >: A](fa: F[A])(a: A1)(implicit A: Equal[A1]): Boolean

    Returns whether the collection contains the specified element.

    Returns whether the collection contains the specified element.

    Definition Classes
    ForEach
  15. def count[A](fa: F[A])(f: (A) ⇒ Boolean): Int

    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.

    Definition Classes
    ForEach
  16. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  17. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  18. def exists[A](fa: F[A])(f: (A) ⇒ Boolean): Boolean

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

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

    Definition Classes
    ForEach
  19. def filter[A](fa: F[A])(f: (A) ⇒ Boolean)(implicit identityBoth: IdentityBoth[F], identityEither: IdentityEither[F]): F[A]

    Filters the collection with the predicate f.

    Filters the collection with the predicate f.

    Definition Classes
    ForEach
  20. def filterM[G[+_], A](fa: F[A])(f: (A) ⇒ G[Boolean])(implicit arg0: IdentityBoth[G], arg1: Covariant[G], identityBoth: IdentityBoth[F], identityEither: IdentityEither[F]): G[F[A]]

    Filters the collection with the effectual predicate f.

    Filters the collection with the effectual predicate f.

    Definition Classes
    ForEach
  21. 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.

    Returns the first element in the collection satisfying the specified predicate if one exists or None otherwise.

    Definition Classes
    ForEach
  22. 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.

    Converts a collection with elements that are in the context of effects to a collection of elements in the context of an effect.

    Definition Classes
    ForEach
  23. def flip1[G[+_], A](fa: F[G[A]])(implicit arg0: AssociativeBoth[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.

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

    Folds over the elements of this collection using an associative operation and an identity. Alias for reduceIdentity.

    Definition Classes
    ForEach
  25. 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.

    Folds over the elements of this collection from left to right to produce a summary value, maintaining some internal state along the way.

    Definition Classes
    ForEach
  26. 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.

    Effectually fold over the elements of this collection from left to right to produce a summary value, maintaining some internal state along the way.

    Definition Classes
    ForEach
  27. 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.

    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.

    Definition Classes
    ForEach
  28. def foldMapM[G[+_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Covariant[G], arg1: IdentityBoth[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.

    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.

    Definition Classes
    ForEach
  29. 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.

    Folds over the elements of this collection from right to left to produce a summary value, maintaining some internal state along the way.

    Definition Classes
    ForEach
  30. 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.

    Effectually fold over the elements of this collection from right to left to produce a summary value, maintaining some internal state along the way.

    Definition Classes
    ForEach
  31. 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.

    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.

    Definition Classes
    NonEmptyForEach → ForEach
  32. def forEach1_[G[+_], A](fa: F[A])(f: (A) ⇒ G[Any])(implicit arg0: AssociativeBoth[G], arg1: Covariant[G]): G[Unit]

    Traverses each element in the collection with the specified effectual function f purely for its effects.

  33. def forEachFlatten[G[+_], A, B](fa: F[A])(f: (A) ⇒ G[F[B]])(implicit arg0: IdentityBoth[G], arg1: Covariant[G], F: AssociativeFlatten[F]): G[F[B]]
    Definition Classes
    ForEach
  34. 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.

    Traverses each element in the collection with the specified effectual function f purely for its effects.

    Definition Classes
    NonEmptyForEach → ForEach
  35. def forall[A](fa: F[A])(f: (A) ⇒ Boolean): Boolean

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

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

    Definition Classes
    ForEach
  36. def fproduct[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[(A, B)]
    Definition Classes
    Covariant
  37. def fproductLeft[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[(B, A)]
    Definition Classes
    Covariant
  38. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  39. def groupByNonEmpty[V, K](fa: F[V])(f: (V) ⇒ K): Map[K, NonEmptyChunk[V]]
    Definition Classes
    ForEach
  40. def groupByNonEmptyM[G[+_], V, K](fa: F[V])(f: (V) ⇒ G[K])(implicit arg0: IdentityBoth[G], arg1: Covariant[G]): G[Map[K, NonEmptyChunk[V]]]
    Definition Classes
    ForEach
  41. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  42. def identityLaw1[A](fa: F[A])(implicit equal: Equal[F[A]]): Boolean
    Definition Classes
    Invariant
  43. 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.

    Folds over the elements of this collection using an associative operation with the middle element interspersed between every element.

    Definition Classes
    ForEach
  44. final def invmap[A, B](f: <=>[A, B]): <=>[F[A], F[B]]
    Definition Classes
    Covariant → Invariant
  45. def isEmpty[A](fa: F[A]): Boolean

    Returns whether the collection is empty.

    Returns whether the collection is empty.

    Definition Classes
    ForEach
  46. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  47. 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.

    Lifts a function operating on values to a function that operates on each element of a collection.

    Definition Classes
    ForEach → Covariant
  48. 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.

    Statefully maps over the elements of the collection, maintaining some state along the way and returning the final state along with the new collection.

    Definition Classes
    ForEach
  49. final def mapSubset[A, B](f: (A) ⇒ B)(implicit arg0: AnyType[B]): (F[A]) ⇒ F[B]
    Definition Classes
    Covariant → CovariantSubset
  50. def max[A](fa: F[A])(implicit arg0: Ord[A]): A

    Returns the largest value in the collection if one exists or None otherwise.

  51. def maxBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Ord[B]): 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.

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

    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.

    Definition Classes
    ForEach
  53. 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.

    Returns the largest value in the collection if one exists or None otherwise.

    Definition Classes
    ForEach
  54. def min[A](fa: F[A])(implicit arg0: Ord[A]): A

    Returns the smallest value in the collection if one exists or None otherwise.

  55. def minBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Ord[B]): 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.

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

    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.

    Definition Classes
    ForEach
  57. 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.

    Returns the smallest value in the collection if one exists or None otherwise.

    Definition Classes
    ForEach
  58. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  59. def nonEmpty[A](fa: F[A]): Boolean

    Returns whether the collection contains at least one element

    Returns whether the collection contains at least one element

    Definition Classes
    ForEach
  60. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  61. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  62. 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.

    Partitions the collection based on the specified function.

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

    Partitions the collection based on the specified effectual function.

    Partitions the collection based on the specified effectual function.

    Definition Classes
    ForEach
  64. 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.

    Partitions the collection based on the specified validation function.

    Definition Classes
    ForEach
  65. def product[A](fa: F[A])(implicit ev: Identity[Prod[A]]): A

    Returns the product of all elements in the collection.

    Returns the product of all elements in the collection.

    Definition Classes
    ForEach
  66. def reduce1[A](fa: F[A])(implicit arg0: Associative[A]): A

    Reduces the non-empty collection of associative elements.

  67. def reduceAll[A](fa: F[A])(f: (A, A) ⇒ A): A

    Reduces the collection to a summary value using the binary function f.

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

    Reduces the collection to a summary value using the associative operation, returning None if the collection is empty.

    Definition Classes
    ForEach
  69. 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.

    Reduces the collection to a summary value using the idempotent operation, returning None if the collection is empty.

    Definition Classes
    ForEach
  70. def reduceIdempotent1[A](fa: F[A])(implicit arg0: Idempotent[A], arg1: Equal[A]): A

    Reduces the collection to a summary value using the idempotent operation, returning None if the collection is empty.

  71. def reduceIdentity[A](fa: F[A])(implicit arg0: Identity[A]): A

    Reduces the collection to a summary value using the associative operation.

    Reduces the collection to a summary value using the associative operation. Alias for fold.

    Definition Classes
    ForEach
  72. def reduceMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Associative[B]): B

    Maps each element of the collection to a type B for which a combine operation is defined using the function f and then reduces those values to a single summary using the combine operation.

  73. def reduceMapLeft[A, B](fa: F[A])(map: (A) ⇒ B)(reduce: (B, A) ⇒ B): B

    Reduces the elements of this collection from left to right using the function map to transform the first value to the type B and then the function reduceAll to combine the B value with each other A value.

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

    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.

    Definition Classes
    ForEach
  75. def reduceMapRight[A, B](fa: F[A])(map: (A) ⇒ B)(reduce: (A, B) ⇒ B): B

    Reduces the elements of this collection from right to left using the function map to transform the first value to the type B and then the function reduceAll to combine the B value with each other A value.

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

    Reduces the collection to a summary value using the binary function f, returning None if the collection is empty.

    Definition Classes
    ForEach
  77. def reverse[A](fa: F[A]): F[A]

    Reverses the order of elements in the collection.

    Reverses the order of elements in the collection.

    Definition Classes
    ForEach
  78. def size[A](fa: F[A]): Int

    Returns the number of elements in the collection.

    Returns the number of elements in the collection.

    Definition Classes
    ForEach
  79. def sum[A](fa: F[A])(implicit ev: Identity[Sum[A]]): A

    Returns the sum of all elements in the collection.

    Returns the sum of all elements in the collection.

    Definition Classes
    ForEach
  80. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  81. def toChunk[A](fa: F[A]): Chunk[A]

    Converts the collection to a Chunk.

    Converts the collection to a Chunk.

    Definition Classes
    ForEach
  82. def toList[A](fa: F[A]): List[A]

    Converts the collection to a List.

    Converts the collection to a List.

    Definition Classes
    ForEach
  83. def toNonEmptyChunk[A](fa: F[A]): NonEmptyChunk[A]

    Converts the collection to a NonEmptyChunk.

  84. def toNonEmptyList[A](fa: F[A]): NonEmptyList[A]

    Converts the collection to a NonEmptyList.

  85. def toString(): String
    Definition Classes
    AnyRef → Any
  86. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  87. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  88. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  89. 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.

    Zips the left collection and right collection together, using None to handle the case where one collection is larger than the other.

    Definition Classes
    ForEach
  90. 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.

    Zips the left collection and right collection together, using the specified function to handle the cases where one collection is larger than the other.

    Definition Classes
    ForEach
  91. def zipWithIndex[A](fa: F[A]): F[(A, Int)]

    Zips each element of the collection with its index.

    Zips each element of the collection with its index.

    Definition Classes
    ForEach

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] ) @Deprecated
    Deprecated

Inherited from ForEach[F]

Inherited from Covariant[F]

Inherited from Invariant[F]

Inherited from CovariantSubset[F, AnyType]

Inherited from AnyRef

Inherited from Any

Ungrouped