Cats core/cats/NonEmptyReducible

NonEmptyReducible

abstract class NonEmptyReducible[F[_], G[_]](G: Foldable[G]) extends Reducible[F]

This class defines a Reducible[F] in terms of a Foldable[G] together with a split method, F[A] => (A, G[A]).

This class defines a Reducible[F] in terms of a Foldable[G] together with a split method, F[A] => (A, G[A]).

This class can be used on any type where the first value (A) and the "rest" of the values (G[A]) can be easily found.

This class is only a helper, does not define a typeclass and should not be used outside of Cats. Also see the discussion: PR #3541 and issue #3069.

trait Reducible[F]
trait Foldable[F]
trait Serializable
class Object
trait Matchable
class Any

Document{}

def sliding18[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding13[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding10[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding6[A](fa: F[A]): List[(A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding19[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding17[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding11[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding3[A](fa: F[A]): List[(A, A, A)]
Inherited from
FoldableNFunctions
def sliding20[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding2[A](fa: F[A]): List[(A, A)]
Inherited from
FoldableNFunctions
def sliding15[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding7[A](fa: F[A]): List[(A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding12[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding16[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding5[A](fa: F[A]): List[(A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding14[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding21[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding22[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding9[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding8[A](fa: F[A]): List[(A, A, A, A, A, A, A, A)]
Inherited from
FoldableNFunctions
def sliding4[A](fa: F[A]): List[(A, A, A, A)]
Inherited from
FoldableNFunctions

Value members

Abstract methods

def split[A](fa: F[A]): (A, G[A])

Concrete methods

override def dropWhile_[A](fa: F[A])(p: A => Boolean): List[A]
Definition Classes
override def exists[A](fa: F[A])(p: A => Boolean): Boolean
Definition Classes
override def filter_[A](fa: F[A])(p: A => Boolean): List[A]
Definition Classes
override def find[A](fa: F[A])(f: A => Boolean): Option[A]
Definition Classes
override def fold[A](fa: F[A])(A: Monoid[A]): A
Definition Classes
def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) => B): B
override def foldM[H[_], A, B](fa: F[A], z: B)(f: (B, A) => H[B])(H: Monad[H]): H[B]
Definition Classes
def foldRight[A, B](fa: F[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B]
override def forall[A](fa: F[A])(p: A => Boolean): Boolean
Definition Classes
override def get[A](fa: F[A])(idx: Long): Option[A]
Definition Classes
def reduceLeftTo[A, B](fa: F[A])(f: A => B)(g: (B, A) => B): B
def reduceRightTo[A, B](fa: F[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[B]
override def size[A](fa: F[A]): Long
Definition Classes
override def takeWhile_[A](fa: F[A])(p: A => Boolean): List[A]
Definition Classes
override def toList[A](fa: F[A]): List[A]
Definition Classes
override def toNonEmptyList[A](fa: F[A]): NonEmptyList[A]
Definition Classes

Inherited methods

def collectFirst[A, B](fa: F[A])(pf: PartialFunction[A, B]): Option[B]
Inherited from
Foldable
def collectFirstSome[A, B](fa: F[A])(f: A => Option[B]): Option[B]

Like collectFirst from scala.collection.Traversable but takes A => Option[B] instead of PartialFunctions.

Like collectFirst from scala.collection.Traversable but takes A => Option[B] instead of PartialFunctions.

scala> import cats.implicits._
scala> val keys = List(1, 2, 4, 5)
scala> val map = Map(4 -> "Four", 5 -> "Five")
scala> keys.collectFirstSome(map.get)
res0: Option[String] = Some(Four)
scala> val map2 = Map(6 -> "Six", 7 -> "Seven")
scala> keys.collectFirstSome(map2.get)
res1: Option[String] = None
Inherited from
Foldable
@noop
def collectFirstSomeM[G[_], A, B](fa: F[A])(f: A => G[Option[B]])(G: Monad[G]): G[Option[B]]

Monadic version of collectFirstSome.

Monadic version of collectFirstSome.

If there are no elements, the result is None. collectFirstSomeM short-circuits, i.e. once a Some element is found, no further effects are produced.

For example:

scala> import cats.implicits._
scala> def parseInt(s: String): Either[String, Int] = Either.catchOnly[NumberFormatException](s.toInt).leftMap(_.getMessage)
scala> val keys1 = List("1", "2", "4", "5")
scala> val map1 = Map(4 -> "Four", 5 -> "Five")
scala> Foldable[List].collectFirstSomeM(keys1)(parseInt(_) map map1.get)
res0: scala.util.Either[String,Option[String]] = Right(Some(Four))

scala> val map2 = Map(6 -> "Six", 7 -> "Seven")
scala> Foldable[List].collectFirstSomeM(keys1)(parseInt(_) map map2.get)
res1: scala.util.Either[String,Option[String]] = Right(None)

scala> val keys2 = List("1", "x", "4", "5")
scala> Foldable[List].collectFirstSomeM(keys2)(parseInt(_) map map1.get)
res2: scala.util.Either[String,Option[String]] = Left(For input string: "x")

scala> val keys3 = List("1", "2", "4", "x")
scala> Foldable[List].collectFirstSomeM(keys3)(parseInt(_) map map1.get)
res3: scala.util.Either[String,Option[String]] = Right(Some(Four))
Inherited from
Foldable
@noop
def collectFold[A, B](fa: F[A])(f: PartialFunction[A, B])(B: Monoid[B]): B

Tear down a subset of this structure using a PartialFunction.

Tear down a subset of this structure using a PartialFunction.

scala> import cats.implicits._
scala> val xs = List(1, 2, 3, 4)
scala> Foldable[List].collectFold(xs) { case n if n % 2 == 0 => n }
res0: Int = 6
Inherited from
Foldable
def collectFoldSome[A, B](fa: F[A])(f: A => Option[B])(B: Monoid[B]): B

Tear down a subset of this structure using a A => Option[M].

Tear down a subset of this structure using a A => Option[M].

scala> import cats.implicits._
scala> val xs = List(1, 2, 3, 4)
scala> def f(n: Int): Option[Int] = if (n % 2 == 0) Some(n) else None
scala> Foldable[List].collectFoldSome(xs)(f)
res0: Int = 6
Inherited from
Foldable
def combineAll[A](fa: F[A])(`evidence$6`: Monoid[A]): A

Alias for fold.

Alias for fold.

Inherited from
Foldable
def combineAllOption[A](fa: F[A])(ev: Semigroup[A]): Option[A]
Inherited from
Foldable
def compose[G[_]](`evidence$1`: Reducible[G]): Reducible[[α] =>> F[G[α]]]
Inherited from
Reducible
def compose[G[_]](`evidence$8`: Foldable[G]): Foldable[[α] =>> F[G[α]]]
Inherited from
Foldable
@noop
def count[A](fa: F[A])(p: A => Boolean): Long

Count the number of elements in the structure that satisfy the given predicate.

Count the number of elements in the structure that satisfy the given predicate.

For example:

scala> import cats.implicits._
scala> val map1 = Map[Int, String]()
scala> val p1: String => Boolean = _.length > 0
scala> UnorderedFoldable[Map[Int, *]].count(map1)(p1)
res0: Long = 0

scala> val map2 = Map(1 -> "hello", 2 -> "world", 3 -> "!")
scala> val p2: String => Boolean = _.length > 1
scala> UnorderedFoldable[Map[Int, *]].count(map2)(p2)
res1: Long = 2
Inherited from
UnorderedFoldable
def existsM[G[_], A](fa: F[A])(p: A => G[Boolean])(G: Monad[G]): G[Boolean]

Check whether at least one element satisfies the effectful predicate.

Check whether at least one element satisfies the effectful predicate.

If there are no elements, the result is false. existsM short-circuits, i.e. once a true result is encountered, no further effects are produced.

For example:

scala> import cats.implicits._
scala> val F = Foldable[List]
scala> F.existsM(List(1,2,3,4))(n => Option(n <= 4))
res0: Option[Boolean] = Some(true)

scala> F.existsM(List(1,2,3,4))(n => Option(n > 4))
res1: Option[Boolean] = Some(false)

scala> F.existsM(List(1,2,3,4))(n => if (n <= 2) Option(true) else Option(false))
res2: Option[Boolean] = Some(true)

scala> F.existsM(List(1,2,3,4))(n => if (n <= 2) Option(true) else None)
res3: Option[Boolean] = Some(true)

scala> F.existsM(List(1,2,3,4))(n => if (n <= 2) None else Option(true))
res4: Option[Boolean] = None
Inherited from
Foldable
@noop
def findM[G[_], A](fa: F[A])(p: A => G[Boolean])(G: Monad[G]): G[Option[A]]

Find the first element matching the effectful predicate, if one exists.

Find the first element matching the effectful predicate, if one exists.

If there are no elements, the result is None. findM short-circuits, i.e. once an element is found, no further effects are produced.

For example:

scala> import cats.implicits._
scala> val list = List(1,2,3,4)
scala> Foldable[List].findM(list)(n => (n >= 2).asRight[String])
res0: Either[String,Option[Int]] = Right(Some(2))

scala> Foldable[List].findM(list)(n => (n > 4).asRight[String])
res1: Either[String,Option[Int]] = Right(None)

scala> Foldable[List].findM(list)(n => Either.cond(n < 3, n >= 2, "error"))
res2: Either[String,Option[Int]] = Right(Some(2))

scala> Foldable[List].findM(list)(n => Either.cond(n < 3, false, "error"))
res3: Either[String,Option[Int]] = Left(error)
Inherited from
Foldable
@noop
def foldA[G[_], A](fga: F[G[A]])(G: Applicative[G], A: Monoid[A]): G[A]

Fold implemented using the given Applicative[G] and Monoid[A] instance.

Fold implemented using the given Applicative[G] and Monoid[A] instance.

This method is similar to fold, but may short-circuit.

For example:

scala> import cats.implicits._
scala> val F = Foldable[List]
scala> F.foldA(List(Either.right[String, Int](1), Either.right[String, Int](2)))
res0: Either[String, Int] = Right(3)

See this issue for an explanation of @noop usage.

Inherited from
Foldable
def foldK[G[_], A](fga: F[G[A]])(G: MonoidK[G]): G[A]

Fold implemented using the given MonoidK[G] instance.

Fold implemented using the given MonoidK[G] instance.

This method is identical to fold, except that we use the universal monoid (MonoidK[G]) to get a Monoid[G[A]] instance.

For example:

scala> import cats.implicits._
scala> val F = Foldable[List]
scala> F.foldK(List(1 :: 2 :: Nil, 3 :: 4 :: 5 :: Nil))
res0: List[Int] = List(1, 2, 3, 4, 5)
Inherited from
Foldable
final def foldLeftM[G[_], A, B](fa: F[A], z: B)(f: (B, A) => G[B])(G: Monad[G]): G[B]

Alias for foldM.

Alias for foldM.

Inherited from
Foldable
def foldMap[A, B](fa: F[A])(f: A => B)(B: Monoid[B]): B

Fold implemented by mapping A values into B and then combining them using the given Monoid[B] instance.

Fold implemented by mapping A values into B and then combining them using the given Monoid[B] instance.

Inherited from
Foldable
def foldMapA[G[_], A, B](fa: F[A])(f: A => G[B])(G: Applicative[G], B: Monoid[B]): G[B]

Fold in an Applicative context by mapping the A values to G[B]. combining the B values using the given Monoid[B] instance.

Fold in an Applicative context by mapping the A values to G[B]. combining the B values using the given Monoid[B] instance.

Similar to foldMapM, but will typically be less efficient.

scala> import cats.Foldable
scala> import cats.implicits._
scala> val evenNumbers = List(2,4,6,8,10)
scala> val evenOpt: Int => Option[Int] =
    |   i => if (i % 2 == 0) Some(i) else None
scala> Foldable[List].foldMapA(evenNumbers)(evenOpt)
res0: Option[Int] = Some(30)
scala> Foldable[List].foldMapA(evenNumbers :+ 11)(evenOpt)
res1: Option[Int] = None
Inherited from
Foldable
@noop
def foldMapK[G[_], A, B](fa: F[A])(f: A => G[B])(G: MonoidK[G]): G[B]

Fold implemented by mapping A values into B in a context G and then combining them using the MonoidK[G] instance.

Fold implemented by mapping A values into B in a context G and then combining them using the MonoidK[G] instance.

scala> import cats._, cats.implicits._
scala> val f: Int => Endo[String] = i => (s => s + i)
scala> val x: Endo[String] = Foldable[List].foldMapK(List(1, 2, 3))(f)
scala> val a = x("foo")
a: String = "foo321"
Inherited from
Foldable
def foldMapM[G[_], A, B](fa: F[A])(f: A => G[B])(G: Monad[G], B: Monoid[B]): G[B]

Monadic folding on F by mapping A values to G[B], combining the B values using the given Monoid[B] instance.

Monadic folding on F by mapping A values to G[B], combining the B values using the given Monoid[B] instance.

Similar to foldM, but using a Monoid[B]. Will typically be more efficient than foldMapA.

scala> import cats.Foldable
scala> import cats.implicits._
scala> val evenNumbers = List(2,4,6,8,10)
scala> val evenOpt: Int => Option[Int] =
    |   i => if (i % 2 == 0) Some(i) else None
scala> Foldable[List].foldMapM(evenNumbers)(evenOpt)
res0: Option[Int] = Some(30)
scala> Foldable[List].foldMapM(evenNumbers :+ 11)(evenOpt)
res1: Option[Int] = None
Inherited from
Foldable
def foldRightDefer[G[_], A, B](fa: F[A], gb: G[B])(fn: (A, G[B]) => G[B])(`evidence$1`: Defer[G]): G[B]
Inherited from
Foldable
def forallM[G[_], A](fa: F[A])(p: A => G[Boolean])(G: Monad[G]): G[Boolean]

Check whether all elements satisfy the effectful predicate.

Check whether all elements satisfy the effectful predicate.

If there are no elements, the result is true. forallM short-circuits, i.e. once a false result is encountered, no further effects are produced.

For example:

scala> import cats.implicits._
scala> val F = Foldable[List]
scala> F.forallM(List(1,2,3,4))(n => Option(n <= 4))
res0: Option[Boolean] = Some(true)

scala> F.forallM(List(1,2,3,4))(n => Option(n <= 1))
res1: Option[Boolean] = Some(false)

scala> F.forallM(List(1,2,3,4))(n => if (n <= 2) Option(true) else Option(false))
res2: Option[Boolean] = Some(false)

scala> F.forallM(List(1,2,3,4))(n => if (n <= 2) Option(false) else None)
res3: Option[Boolean] = Some(false)

scala> F.forallM(List(1,2,3,4))(n => if (n <= 2) None else Option(false))
res4: Option[Boolean] = None
Inherited from
Foldable
def intercalate[A](fa: F[A], a: A)(A: Monoid[A]): A

Intercalate/insert an element between the existing elements while folding.

Intercalate/insert an element between the existing elements while folding.

scala> import cats.implicits._
scala> Foldable[List].intercalate(List("a","b","c"), "-")
res0: String = a-b-c
scala> Foldable[List].intercalate(List("a"), "-")
res1: String = a
scala> Foldable[List].intercalate(List.empty[String], "-")
res2: String = ""
scala> Foldable[Vector].intercalate(Vector(1,2,3), 1)
res3: Int = 8
Inherited from
Foldable
override def isEmpty[A](fa: F[A]): Boolean
Definition Classes
Inherited from
Reducible
def maximum[A](fa: F[A])(A: Order[A]): A
Inherited from
Reducible
def maximumBy[A, B](fa: F[A])(f: A => B)(`evidence$3`: Order[B]): A

Find the maximum A item in this structure according to an Order.by(f).

Find the maximum A item in this structure according to an Order.by(f).

See also

minimumBy for minimum instead of maximum.

Inherited from
Reducible
def maximumByList[A, B](fa: F[A])(f: A => B)(`evidence$5`: Order[B]): List[A]

Find all the maximum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the maximum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

See also

Reducible#maximumByNel for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

minimumByList for minimum instead of maximum.

Inherited from
Foldable
def maximumByNel[A, B](fa: F[A])(f: A => B)(`evidence$5`: Order[B]): NonEmptyList[A]

Find all the maximum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the maximum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

See also

minimumByNel for minimum instead of maximum.

Inherited from
Reducible
def maximumByOption[A, B](fa: F[A])(f: A => B)(`evidence$3`: Order[B]): Option[A]

Find the maximum A item in this structure according to an Order.by(f).

Find the maximum A item in this structure according to an Order.by(f).

Returns

None if the structure is empty, otherwise the maximum element wrapped in a Some.

See also

Reducible#maximumBy for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

minimumByOption for minimum instead of maximum.

Inherited from
Foldable
def maximumList[A](fa: F[A])(A: Order[A]): List[A]

Find all the maximum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the maximum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

See also

Reducible#maximumNel for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

minimumList for minimum instead of maximum.

Inherited from
Foldable
def maximumNel[A](fa: F[A])(A: Order[A]): NonEmptyList[A]

Find all the maximum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the maximum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

See also

minimumNel for minimum instead of maximum.

Inherited from
Reducible
override def maximumOption[A](fa: F[A])(A: Order[A]): Option[A]
Definition Classes
Inherited from
Reducible
def minimum[A](fa: F[A])(A: Order[A]): A
Inherited from
Reducible
def minimumBy[A, B](fa: F[A])(f: A => B)(`evidence$2`: Order[B]): A

Find the minimum A item in this structure according to an Order.by(f).

Find the minimum A item in this structure according to an Order.by(f).

See also

maximumBy for maximum instead of minimum.

Inherited from
Reducible
def minimumByList[A, B](fa: F[A])(f: A => B)(`evidence$4`: Order[B]): List[A]

Find all the minimum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the minimum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

See also

Reducible#minimumByNel for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

maximumByList for maximum instead of minimum.

Inherited from
Foldable
def minimumByNel[A, B](fa: F[A])(f: A => B)(`evidence$4`: Order[B]): NonEmptyList[A]

Find all the minimum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the minimum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

See also

maximumByNel for maximum instead of minimum.

Inherited from
Reducible
def minimumByOption[A, B](fa: F[A])(f: A => B)(`evidence$2`: Order[B]): Option[A]

Find the minimum A item in this structure according to an Order.by(f).

Find the minimum A item in this structure according to an Order.by(f).

Returns

None if the structure is empty, otherwise the minimum element wrapped in a Some.

See also

Reducible#minimumBy for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

maximumByOption for maximum instead of minimum.

Inherited from
Foldable
def minimumList[A](fa: F[A])(A: Order[A]): List[A]

Find all the minimum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the minimum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

See also

Reducible#minimumNel for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

maximumList for maximum instead of minimum.

Inherited from
Foldable
def minimumNel[A](fa: F[A])(A: Order[A]): NonEmptyList[A]

Find all the minimum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the minimum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

See also

maximumNel for maximum instead of minimum.

Inherited from
Reducible
override def minimumOption[A](fa: F[A])(A: Order[A]): Option[A]
Definition Classes
Inherited from
Reducible
override def nonEmpty[A](fa: F[A]): Boolean
Definition Classes
Inherited from
Reducible
def nonEmptyIntercalate[A](fa: F[A], a: A)(A: Semigroup[A]): A

Intercalate/insert an element between the existing elements while reducing.

Intercalate/insert an element between the existing elements while reducing.

scala> import cats.implicits._
scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of("a", "b", "c")
scala> Reducible[NonEmptyList].nonEmptyIntercalate(nel, "-")
res0: String = a-b-c
scala> Reducible[NonEmptyList].nonEmptyIntercalate(NonEmptyList.of("a"), "-")
res1: String = a
Inherited from
Reducible
def nonEmptyPartition[A, B, C](fa: F[A])(f: A => Either[B, C]): Ior[NonEmptyList[B], NonEmptyList[C]]

Partition this Reducible by a separating function A => Either[B, C]

Partition this Reducible by a separating function A => Either[B, C]

scala> import cats.data.NonEmptyList
scala> val nel = NonEmptyList.of(1,2,3,4)
scala> Reducible[NonEmptyList].nonEmptyPartition(nel)(a => if (a % 2 == 0) Left(a.toString) else Right(a))
res0: cats.data.Ior[cats.data.NonEmptyList[String],cats.data.NonEmptyList[Int]] = Both(NonEmptyList(2, 4),NonEmptyList(1, 3))
scala> Reducible[NonEmptyList].nonEmptyPartition(nel)(a => Right(a * 4))
res1: cats.data.Ior[cats.data.NonEmptyList[Nothing],cats.data.NonEmptyList[Int]] = Right(NonEmptyList(4, 8, 12, 16))
Inherited from
Reducible
def nonEmptySequence_[G[_], A](fga: F[G[A]])(G: Apply[G]): G[Unit]

Sequence F[G[A]] using Apply[G].

Sequence F[G[A]] using Apply[G].

This method is similar to Foldable.sequence_ but requires only an Apply instance for G instead of Applicative. See the nonEmptyTraverse_ documentation for a description of the differences.

Inherited from
Reducible
def nonEmptyTraverse_[G[_], A, B](fa: F[A])(f: A => G[B])(G: Apply[G]): G[Unit]

Traverse F[A] using Apply[G].

Traverse F[A] using Apply[G].

A values will be mapped into G[B] and combined using Apply#map2.

This method is similar to Foldable.traverse_. There are two main differences:

  1. We only need an Apply instance for G here, since we don't need to call Applicative.pure for a starting value.
  2. This performs a strict left-associative traversal and thus must always traverse the entire data structure. Prefer Foldable.traverse_ if you have an Applicative instance available for G and want to take advantage of short-circuiting the traversal.
Inherited from
Reducible
@noop
def partitionBifold[H[_, _], A, B, C](fa: F[A])(f: A => H[B, C])(A: Alternative[F], H: Bifoldable[H]): (F[B], F[C])

Separate this Foldable into a Tuple by a separating function A => H[B, C] for some Bifoldable[H] Equivalent to Functor#map and then Alternative#separate.

Separate this Foldable into a Tuple by a separating function A => H[B, C] for some Bifoldable[H] Equivalent to Functor#map and then Alternative#separate.

scala> import cats.implicits._, cats.Foldable, cats.data.Const
scala> val list = List(1,2,3,4)
scala> Foldable[List].partitionBifold(list)(a => ("value " + a.toString(), if (a % 2 == 0) -a else a))
res0: (List[String], List[Int]) = (List(value 1, value 2, value 3, value 4),List(1, -2, 3, -4))
scala> Foldable[List].partitionBifold(list)(a => Const[Int, Nothing with Any](a))
res1: (List[Int], List[Nothing with Any]) = (List(1, 2, 3, 4),List())
Inherited from
Foldable
@noop
def partitionBifoldM[G[_], H[_, _], A, B, C](fa: F[A])(f: A => G[H[B, C]])(A: Alternative[F], M: Monad[G], H: Bifoldable[H]): G[(F[B], F[C])]

Separate this Foldable into a Tuple by an effectful separating function A => G[H[B, C]] for some Bifoldable[H] Equivalent to Traverse#traverse over Alternative#separate

Separate this Foldable into a Tuple by an effectful separating function A => G[H[B, C]] for some Bifoldable[H] Equivalent to Traverse#traverse over Alternative#separate

scala> import cats.implicits._, cats.Foldable, cats.data.Const
scala> val list = List(1,2,3,4)
`Const`'s second parameter is never instantiated, so we can use an impossible type:
scala> Foldable[List].partitionBifoldM(list)(a => Option(Const[Int, Nothing with Any](a)))
res0: Option[(List[Int], List[Nothing with Any])] = Some((List(1, 2, 3, 4),List()))
Inherited from
Foldable
def partitionEither[A, B, C](fa: F[A])(f: A => Either[B, C])(A: Alternative[F]): (F[B], F[C])

Separate this Foldable into a Tuple by a separating function A => Either[B, C] Equivalent to Functor#map and then Alternative#separate.

Separate this Foldable into a Tuple by a separating function A => Either[B, C] Equivalent to Functor#map and then Alternative#separate.

scala> import cats.implicits._
scala> val list = List(1,2,3,4)
scala> Foldable[List].partitionEither(list)(a => if (a % 2 == 0) Left(a.toString) else Right(a))
res0: (List[String], List[Int]) = (List(2, 4),List(1, 3))
scala> Foldable[List].partitionEither(list)(a => Right(a * 4))
res1: (List[Nothing], List[Int]) = (List(),List(4, 8, 12, 16))
Inherited from
Foldable
@noop
def partitionEitherM[G[_], A, B, C](fa: F[A])(f: A => G[Either[B, C]])(A: Alternative[F], M: Monad[G]): G[(F[B], F[C])]

Separate this Foldable into a Tuple by an effectful separating function A => G[Either[B, C]] Equivalent to Traverse#traverse over Alternative#separate

Separate this Foldable into a Tuple by an effectful separating function A => G[Either[B, C]] Equivalent to Traverse#traverse over Alternative#separate

scala> import cats.implicits._, cats.Foldable, cats.Eval
scala> val list = List(1,2,3,4)
scala> val partitioned1 = Foldable[List].partitionEitherM(list)(a => if (a % 2 == 0) Eval.now(Either.left[String, Int](a.toString)) else Eval.now(Either.right[String, Int](a)))
Since `Eval.now` yields a lazy computation, we need to force it to inspect the result:
scala> partitioned1.value
res0: (List[String], List[Int]) = (List(2, 4),List(1, 3))
scala> val partitioned2 = Foldable[List].partitionEitherM(list)(a => Eval.later(Either.right(a * 4)))
scala> partitioned2.value
res1: (List[Nothing], List[Int]) = (List(),List(4, 8, 12, 16))
Inherited from
Foldable
def productAll[A](fa: F[A])(A: Numeric[A]): A
Inherited from
Foldable
def reduce[A](fa: F[A])(A: Semigroup[A]): A

Reduce a F[A] value using the given Semigroup[A].

Reduce a F[A] value using the given Semigroup[A].

Inherited from
Reducible
@noop
def reduceA[G[_], A](fga: F[G[A]])(G: Apply[G], A: Semigroup[A]): G[A]

Reduce a F[G[A]] value using Applicative[G] and Semigroup[A], a universal semigroup for G[_].

Reduce a F[G[A]] value using Applicative[G] and Semigroup[A], a universal semigroup for G[_].

This method is similar to reduce, but may short-circuit.

See this issue for an explanation of @noop usage.

Inherited from
Reducible
def reduceK[G[_], A](fga: F[G[A]])(G: SemigroupK[G]): G[A]

Reduce a F[G[A]] value using SemigroupK[G], a universal semigroup for G[_].

Reduce a F[G[A]] value using SemigroupK[G], a universal semigroup for G[_].

This method is a generalization of reduce.

Inherited from
Reducible
def reduceLeft[A](fa: F[A])(f: (A, A) => A): A

Left-associative reduction on F using the function f.

Left-associative reduction on F using the function f.

Implementations should override this method when possible.

Inherited from
Reducible
def reduceLeftM[G[_], A, B](fa: F[A])(f: A => G[B])(g: (B, A) => G[B])(G: FlatMap[G]): G[B]

Monadic variant of reduceLeftTo.

Monadic variant of reduceLeftTo.

Inherited from
Reducible
def reduceLeftOption[A](fa: F[A])(f: (A, A) => A): Option[A]

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a left-associative manner.

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a left-associative manner.

Returns

None if the structure is empty, otherwise the result of combining the cumulative left-associative result of the f operation over all of the elements.

See also

reduceRightOption for a right-associative alternative.

Reducible#reduceLeft for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty. Example:

scala> import cats.implicits._
scala> val l = List(6, 3, 2)
This is equivalent to (6 - 3) - 2
scala> Foldable[List].reduceLeftOption(l)(_ - _)
res0: Option[Int] = Some(1)
scala> Foldable[List].reduceLeftOption(List.empty[Int])(_ - _)
res1: Option[Int] = None
Inherited from
Foldable
override def reduceLeftToOption[A, B](fa: F[A])(f: A => B)(g: (B, A) => B): Option[B]

Overridden from Foldable for efficiency.

Overridden from Foldable for efficiency.

Definition Classes
Inherited from
Reducible
def reduceMap[A, B](fa: F[A])(f: A => B)(B: Semigroup[B]): B

Apply f to each element of fa and combine them using the given Semigroup[B].

Apply f to each element of fa and combine them using the given Semigroup[B].

Inherited from
Reducible
def reduceMapA[G[_], A, B](fa: F[A])(f: A => G[B])(G: Apply[G], B: Semigroup[B]): G[B]

Reduce in an Apply context by mapping the A values to G[B]. combining the B values using the given Semigroup[B] instance.

Reduce in an Apply context by mapping the A values to G[B]. combining the B values using the given Semigroup[B] instance.

Similar to reduceMapM, but may be less efficient.

scala> import cats.Reducible
scala> import cats.data.NonEmptyList
scala> import cats.implicits._
scala> val evenOpt: Int => Option[Int] =
    |   i => if (i % 2 == 0) Some(i) else None
scala> val allEven = NonEmptyList.of(2,4,6,8,10)
allEven: cats.data.NonEmptyList[Int] = NonEmptyList(2, 4, 6, 8, 10)
scala> val notAllEven = allEven ++ List(11)
notAllEven: cats.data.NonEmptyList[Int] = NonEmptyList(2, 4, 6, 8, 10, 11)
scala> Reducible[NonEmptyList].reduceMapA(allEven)(evenOpt)
res0: Option[Int] = Some(30)
scala> Reducible[NonEmptyList].reduceMapA(notAllEven)(evenOpt)
res1: Option[Int] = None
Inherited from
Reducible
@noop
def reduceMapK[G[_], A, B](fa: F[A])(f: A => G[B])(G: SemigroupK[G]): G[B]

Apply f to each element of fa and combine them using the given SemigroupK[G].

Apply f to each element of fa and combine them using the given SemigroupK[G].

scala> import cats._, cats.data._, cats.implicits._
scala> val f: Int => Endo[String] = i => (s => s + i)
scala> val x: Endo[String] = Reducible[NonEmptyList].reduceMapK(NonEmptyList.of(1, 2, 3))(f)
scala> val a = x("foo")
a: String = "foo321"
Inherited from
Reducible
def reduceMapM[G[_], A, B](fa: F[A])(f: A => G[B])(G: FlatMap[G], B: Semigroup[B]): G[B]

Reduce in an FlatMap context by mapping the A values to G[B]. combining the B values using the given Semigroup[B] instance.

Reduce in an FlatMap context by mapping the A values to G[B]. combining the B values using the given Semigroup[B] instance.

Similar to reduceLeftM, but using a Semigroup[B]. May be more efficient than reduceMapA.

scala> import cats.Reducible
scala> import cats.data.NonEmptyList
scala> import cats.implicits._
scala> val evenOpt: Int => Option[Int] =
    |   i => if (i % 2 == 0) Some(i) else None
scala> val allEven = NonEmptyList.of(2,4,6,8,10)
allEven: cats.data.NonEmptyList[Int] = NonEmptyList(2, 4, 6, 8, 10)
scala> val notAllEven = allEven ++ List(11)
notAllEven: cats.data.NonEmptyList[Int] = NonEmptyList(2, 4, 6, 8, 10, 11)
scala> Reducible[NonEmptyList].reduceMapM(allEven)(evenOpt)
res0: Option[Int] = Some(30)
scala> Reducible[NonEmptyList].reduceMapM(notAllEven)(evenOpt)
res1: Option[Int] = None
Inherited from
Reducible
def reduceRight[A](fa: F[A])(f: (A, Eval[A]) => Eval[A]): Eval[A]

Right-associative reduction on F using the function f.

Right-associative reduction on F using the function f.

Inherited from
Reducible
def reduceRightOption[A](fa: F[A])(f: (A, Eval[A]) => Eval[A]): Eval[Option[A]]

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.

Returns

None if the structure is empty, otherwise the result of combining the cumulative right-associative result of the f operation over the A elements.

See also

reduceLeftOption for a left-associative alternative

Reducible#reduceRight for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty. Example:

scala> import cats.implicits._
scala> val l = List(6, 3, 2)
This is equivalent to 6 - (3 - 2)
scala> Foldable[List].reduceRightOption(l)((current, rest) => rest.map(current - _)).value
res0: Option[Int] = Some(5)
scala> Foldable[List].reduceRightOption(List.empty[Int])((current, rest) => rest.map(current - _)).value
res1: Option[Int] = None
Inherited from
Foldable
override def reduceRightToOption[A, B](fa: F[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[Option[B]]

Overridden from Foldable for efficiency.

Overridden from Foldable for efficiency.

Definition Classes
Inherited from
Reducible
def sequence_[G[_], A](fga: F[G[A]])(`evidence$7`: Applicative[G]): G[Unit]

Sequence F[G[A]] using Applicative[G].

Sequence F[G[A]] using Applicative[G].

This is similar to traverse_ except it operates on F[G[A]] values, so no additional functions are needed.

For example:

scala> import cats.implicits._
scala> val F = Foldable[List]
scala> F.sequence_(List(Option(1), Option(2), Option(3)))
res0: Option[Unit] = Some(())
scala> F.sequence_(List(Option(1), None, Option(3)))
res1: Option[Unit] = None
Inherited from
Foldable
def sumAll[A](fa: F[A])(A: Numeric[A]): A
Inherited from
Foldable
def toIterable[A](fa: F[A]): Iterable[A]

Convert F[A] to an Iterable[A].

Convert F[A] to an Iterable[A].

This method may be overridden for the sake of performance, but implementers should take care not to force a full materialization of the collection.

Inherited from
Foldable
def traverse_[G[_], A, B](fa: F[A])(f: A => G[B])(G: Applicative[G]): G[Unit]

Traverse F[A] using Applicative[G].

Traverse F[A] using Applicative[G].

A values will be mapped into G[B] and combined using Applicative#map2.

For example:

scala> import cats.implicits._
scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption
scala> val F = Foldable[List]
scala> F.traverse_(List("333", "444"))(parseInt)
res0: Option[Unit] = Some(())
scala> F.traverse_(List("333", "zzz"))(parseInt)
res1: Option[Unit] = None

This method is primarily useful when G[_] represents an action or effect, and the specific A aspect of G[A] is not otherwise needed.

Inherited from
Foldable
override def unorderedFold[A](fa: F[A])(`evidence$9`: CommutativeMonoid[A]): A
Definition Classes
Inherited from
Foldable
override def unorderedFoldMap[A, B](fa: F[A])(f: A => B)(`evidence$10`: CommutativeMonoid[B]): B
Definition Classes
Inherited from
Foldable