t

cats

# NonEmptyTraverse 

### Companion object NonEmptyTraverse

#### trait NonEmptyTraverse[F[_]] extends Traverse[F] with Reducible[F]

NonEmptyTraverse, also known as Traversable1.

`NonEmptyTraverse` is like a non-empty `Traverse`. In addition to the traverse and sequence methods it provides nonEmptyTraverse and nonEmptySequence methods which require an `Apply` instance instead of `Applicative`.

Self Type
NonEmptyTraverse[F]
Annotations
@implicitNotFound( ... ) @typeclass( ... , ... )
Source
NonEmptyTraverse.scala
Linear Supertypes
Ordering
1. Grouped
2. Alphabetic
3. By Inheritance
Inherited
1. NonEmptyTraverse
2. Reducible
3. Traverse
4. UnorderedTraverse
5. Foldable
6. FoldableNFunctions
7. UnorderedFoldable
8. Functor
9. Invariant
10. Serializable
11. Serializable
12. AnyRef
13. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Abstract Value Members

1. abstract def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) ⇒ B): B

Left associative fold on 'F' using the function 'f'.

Left associative fold on 'F' using the function 'f'.

Example:

```scala> import cats.Foldable, cats.implicits._
scala> val fa = Option(1)

scala> Foldable[Option].foldLeft(fa, Option(0))((a, n) => a.map(_ + n))
res0: Option[Int] = Some(1)```

With syntax extensions, `foldLeft` can be used like:

```Folding `Option` with addition from zero:
scala> fa.foldLeft(Option(0))((a, n) => a.map(_ + n))
res1: Option[Int] = Some(1)

There's also an alias `foldl` which is equivalent:
scala> fa.foldl(Option(0))((a, n) => a.map(_ + n))
res2: Option[Int] = Some(1)```
Definition Classes
Foldable
2. abstract def foldRight[A, B](fa: F[A], lb: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

Right associative lazy fold on `F` using the folding function 'f'.

Right associative lazy fold on `F` using the folding function 'f'.

This method evaluates `lb` lazily (in some cases it will not be needed), and returns a lazy value. We are using ```(A, Eval[B]) => Eval[B]``` to support laziness in a stack-safe way. Chained computation should be performed via .map and .flatMap.

For more detailed information about how this method works see the documentation for `Eval[_]`.

Example:

```scala> import cats.Foldable, cats.Eval, cats.implicits._
scala> val fa = Option(1)

scala> val folded1 = Foldable[Option].foldRight(fa, Eval.now(0))((n, a) => a.map(_ + n))
Since `foldRight` yields a lazy computation, we need to force it to inspect the result:
scala> folded1.value
res0: Int = 1

With syntax extensions, we can write the same thing like this:
scala> val folded2 = fa.foldRight(Eval.now(0))((n, a) => a.map(_ + n))
scala> folded2.value
res1: Int = 1

Unfortunately, since `foldRight` is defined on many collections - this
extension clashes with the operation defined in `Foldable`.

To get past this and make sure you're getting the lazy `foldRight` defined
in `Foldable`, there's an alias `foldr`:
scala> val folded3 = fa.foldr(Eval.now(0))((n, a) => a.map(_ + n))
scala> folded3.value
res1: Int = 1```
Definition Classes
Foldable
3. abstract def nonEmptyTraverse[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Apply[G]): G[F[B]]

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[B] in a G context.

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[B] in a G context.

Example:

```scala> import cats.implicits._
scala> import cats.data.NonEmptyList
scala> def countWords(words: List[String]): Map[String, Int] = words.groupBy(identity).map { case (k, v) => (k, v.length) }
scala> val expectedResult = Map("do" -> NonEmptyList.of(1, 2), "you" -> NonEmptyList.of(1, 1))
scala> val x = List("How", "do", "you", "fly")
scala> val y = List("What", "do", "you", "do")
scala> val result = NonEmptyList.of(x, y).nonEmptyTraverse(countWords)
scala> result === expectedResult
res0: Boolean = true```
4. abstract def reduceLeftTo[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B, A) ⇒ B): B

Apply `f` to the "initial element" of `fa` and combine it with every other value using the given function `g`.

Apply `f` to the "initial element" of `fa` and combine it with every other value using the given function `g`.

Definition Classes
Reducible
5. abstract def reduceRightTo[A, B](fa: F[A])(f: (A) ⇒ B)(g: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

Apply `f` to the "initial element" of `fa` and lazily combine it with every other value using the given function `g`.

Apply `f` to the "initial element" of `fa` and lazily combine it with every other value using the given function `g`.

Definition Classes
Reducible

### Concrete Value Members

1. final def !=(arg0: Any)
Definition Classes
AnyRef → Any
2. final def ##(): Int
Definition Classes
AnyRef → Any
3. final def ==(arg0: Any)
Definition Classes
AnyRef → Any
4. def as[A, B](fa: F[A], b: B): F[B]

Replaces the `A` value in `F[A]` with the supplied value.

Replaces the `A` value in `F[A]` with the supplied value.

Example:

```scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].as(List(1,2,3), "hello")
res0: List[String] = List(hello, hello, hello)```
Definition Classes
Functor
5. final def asInstanceOf[T0]: T0
Definition Classes
Any
6. def clone()
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native() @IntrinsicCandidate()
7. def collectFirst[A, B](fa: F[A])(pf: PartialFunction[A, B]): Option[B]
Definition Classes
Foldable
8. 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 `PartialFunction`s.

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

```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```
Definition Classes
Foldable
9. def collectFirstSomeM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[Option[B]])(implicit 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))```
Definition Classes
Foldable
Annotations
@noop()
10. def collectFold[A, B](fa: F[A])(f: PartialFunction[A, B])(implicit 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```
Definition Classes
Foldable
Annotations
@noop()
11. def collectFoldSome[A, B](fa: F[A])(f: (A) ⇒ Option[B])(implicit 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```
Definition Classes
Foldable
12. def combineAll[A](fa: F[A])(implicit arg0: Monoid[A]): A

Alias for fold.

Alias for fold.

Definition Classes
Foldable
13. def combineAllOption[A](fa: F[A])(implicit ev: Semigroup[A]): Option[A]
Definition Classes
Foldable
14. def compose[G[_]](implicit arg0: NonEmptyTraverse[G]): NonEmptyTraverse[[α]F[G[α]]]
15. def compose[G[_]](implicit arg0: Reducible[G]): Reducible[[α]F[G[α]]]
Definition Classes
Reducible
16. def compose[G[_]](implicit arg0: Traverse[G]): Traverse[[α]F[G[α]]]
Definition Classes
Traverse
17. def compose[G[_]](implicit arg0: Foldable[G]): Foldable[[α]F[G[α]]]
Definition Classes
Foldable
18. def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
Definition Classes
Functor
19. def compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[G[α]]]

Compose Invariant `F[_]` and `G[_]` then produce `Invariant[F[G[_]]]` using their `imap`.

Compose Invariant `F[_]` and `G[_]` then produce `Invariant[F[G[_]]]` using their `imap`.

Example:

```scala> import cats.implicits._
scala> import scala.concurrent.duration._

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)```
Definition Classes
Invariant
20. def composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[G[α]]]

Compose Invariant `F[_]` and Contravariant `G[_]` then produce `Invariant[F[G[_]]]` using F's `imap` and G's `contramap`.

Compose Invariant `F[_]` and Contravariant `G[_]` then produce `Invariant[F[G[_]]]` using F's `imap` and G's `contramap`.

Example:

```scala> import cats.implicits._
scala> import scala.concurrent.duration._

scala> type ToInt[T] = T => Int
scala> val durSemigroupToInt: Semigroup[ToInt[FiniteDuration]] =
| Invariant[Semigroup]
|   .composeContravariant[ToInt]
|   .imap(Semigroup[ToInt[Long]])(Duration.fromNanos)(_.toNanos)
// semantically equal to (2.seconds.toSeconds.toInt + 1) + (2.seconds.toSeconds.toInt * 2) = 7
scala> durSemigroupToInt.combine(_.toSeconds.toInt + 1, _.toSeconds.toInt * 2)(2.seconds)
res1: Int = 7```
Definition Classes
FunctorInvariant
21. def composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[G[α]]]

Compose Invariant `F[_]` and Functor `G[_]` then produce `Invariant[F[G[_]]]` using F's `imap` and G's `map`.

Compose Invariant `F[_]` and Functor `G[_]` then produce `Invariant[F[G[_]]]` using F's `imap` and G's `map`.

Example:

```scala> import cats.implicits._
scala> import scala.concurrent.duration._

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
| Invariant[Semigroup]
|   .composeFunctor[List]
|   .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)```
Definition Classes
Invariant
22. 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```
Definition Classes
UnorderedFoldable
Annotations
@noop()
23. def dropWhile_[A](fa: F[A])(p: (A) ⇒ Boolean): List[A]

Convert F[A] to a List[A], dropping all initial elements which match `p`.

Convert F[A] to a List[A], dropping all initial elements which match `p`.

Definition Classes
Foldable
24. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
25. def equals(arg0: Any)
Definition Classes
AnyRef → Any
26. def exists[A](fa: F[A])(p: (A) ⇒ Boolean)

Check whether at least one element satisfies the predicate.

Check whether at least one element satisfies the predicate.

If there are no elements, the result is `false`.

Definition Classes
FoldableUnorderedFoldable
27. def existsM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit 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```
Definition Classes
Foldable
28. def filter_[A](fa: F[A])(p: (A) ⇒ Boolean): List[A]

Convert F[A] to a List[A], only including elements which match `p`.

Convert F[A] to a List[A], only including elements which match `p`.

Definition Classes
Foldable
29. def find[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]

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

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

Definition Classes
Foldable
30. def findM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit 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)```
Definition Classes
Foldable
Annotations
@noop()
31. def flatSequence[G[_], A](fgfa: F[G[F[A]]])(implicit G: Applicative[G], F: FlatMap[F]): G[F[A]]

Thread all the G effects through the F structure and flatten to invert the structure from F[G[F[A]]] to G[F[A]].

Thread all the G effects through the F structure and flatten to invert the structure from F[G[F[A]]] to G[F[A]].

Example:

```scala> import cats.implicits._
scala> val x: List[Option[List[Int]]] = List(Some(List(1, 2)), Some(List(3)))
scala> val y: List[Option[List[Int]]] = List(None, Some(List(3)))
scala> x.flatSequence
res0: Option[List[Int]] = Some(List(1, 2, 3))
scala> y.flatSequence
res1: Option[List[Int]] = None```
Definition Classes
Traverse
32. def flatTraverse[G[_], A, B](fa: F[A])(f: (A) ⇒ G[F[B]])(implicit G: Applicative[G], F: FlatMap[F]): G[F[B]]

A traverse followed by flattening the inner result.

A traverse followed by flattening the inner result.

Example:

```scala> import cats.implicits._
scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption
scala> val x = Option(List("1", "two", "3"))
scala> x.flatTraverse(_.map(parseInt))
res0: List[Option[Int]] = List(Some(1), None, Some(3))```
Definition Classes
Traverse
33. final def fmap[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in `.map` method.

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in `.map` method.

Example:

```scala> import cats.implicits._

scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")

scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)```
Definition Classes
Functor
34. def fold[A](fa: F[A])(implicit A: Monoid[A]): A

Fold implemented using the given `Monoid[A]` instance.

Fold implemented using the given `Monoid[A]` instance.

Definition Classes
Foldable
35. def foldA[G[_], A](fga: F[G[A]])(implicit 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.

Definition Classes
Foldable
Annotations
@noop()
36. def foldK[G[_], A](fga: F[G[A]])(implicit 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)```
Definition Classes
Foldable
37. final def foldLeftM[G[_], A, B](fa: F[A], z: B)(f: (B, A) ⇒ G[B])(implicit G: Monad[G]): G[B]

Alias for foldM.

Alias for foldM.

Definition Classes
Foldable
38. def foldM[G[_], A, B](fa: F[A], z: B)(f: (B, A) ⇒ G[B])(implicit G: Monad[G]): G[B]

Perform a stack-safe monadic left fold from the source context `F` into the target monad `G`.

Perform a stack-safe monadic left fold from the source context `F` into the target monad `G`.

This method can express short-circuiting semantics. Even when `fa` is an infinite structure, this method can potentially terminate if the `foldRight` implementation for `F` and the `tailRecM` implementation for `G` are sufficiently lazy.

Instances for concrete structures (e.g. `List`) will often have a more efficient implementation than the default one in terms of `foldRight`.

Definition Classes
Foldable
39. def foldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit 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.

Definition Classes
Foldable
40. def foldMapA[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: Applicative[G], B: Monoid[B]): G[B]

Fold in an Applicative context by mapping the `A` values to `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.

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```
Definition Classes
Foldable
41. def foldMapK[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit 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"```
Definition Classes
Foldable
Annotations
@noop()
42. def foldMapM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit 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```
Definition Classes
Foldable
43. def foldRightDefer[G[_], A, B](fa: F[A], gb: G[B])(fn: (A, G[B]) ⇒ G[B])(implicit arg0: Defer[G]): G[B]
Definition Classes
Foldable
44. def forall[A](fa: F[A])(p: (A) ⇒ Boolean)

Check whether all elements satisfy the predicate.

Check whether all elements satisfy the predicate.

If there are no elements, the result is `true`.

Definition Classes
FoldableUnorderedFoldable
45. def forallM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit 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```
Definition Classes
Foldable
46. def fproduct[A, B](fa: F[A])(f: (A) ⇒ B): F[(A, B)]

Tuple the values in fa with the result of applying a function with the value

Tuple the values in fa with the result of applying a function with the value

Example:

```scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproduct(Option(42))(_.toString)
res0: Option[(Int, String)] = Some((42,42))```
Definition Classes
Functor
47. def fproductLeft[A, B](fa: F[A])(f: (A) ⇒ B): F[(B, A)]

Pair the result of function application with `A`.

Pair the result of function application with `A`.

Example:

```scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> Functor[Option].fproductLeft(Option(42))(_.toString)
res0: Option[(String, Int)] = Some((42,42))```
Definition Classes
Functor
48. def get[A](fa: F[A])(idx: Long): Option[A]

Get the element at the index of the `Foldable`.

Get the element at the index of the `Foldable`.

Definition Classes
Foldable
49. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native() @IntrinsicCandidate()
50. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native() @IntrinsicCandidate()
51. def ifF[A](fb: F[Boolean])(ifTrue: ⇒ A, ifFalse: ⇒ A): F[A]

Lifts `if` to Functor

Lifts `if` to Functor

Example:

```scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)```
Definition Classes
Functor
Annotations
@noop()
52. def imap[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B) ⇒ A): F[B]

Transform an `F[A]` into an `F[B]` by providing a transformation from `A` to `B` and one from `B` to `A`.

Transform an `F[A]` into an `F[B]` by providing a transformation from `A` to `B` and one from `B` to `A`.

Example:

```scala> import cats.implicits._
scala> import scala.concurrent.duration._

scala> val durSemigroup: Semigroup[FiniteDuration] =
| Invariant[Semigroup].imap(Semigroup[Long])(Duration.fromNanos)(_.toNanos)
scala> durSemigroup.combine(2.seconds, 3.seconds)
res1: FiniteDuration = 5 seconds```
Definition Classes
FunctorInvariant
53. def intercalate[A](fa: F[A], a: A)(implicit 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```
Definition Classes
Foldable
54. def intersperseList[A](xs: List[A], x: A): List[A]
Attributes
protected
Definition Classes
Foldable
55. def isEmpty[A](fa: F[A])

Returns true if there are no elements.

Returns true if there are no elements. Otherwise false.

Definition Classes
ReducibleFoldableUnorderedFoldable
56. final def isInstanceOf[T0]
Definition Classes
Any
57. def lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]

Lift a function f to operate on Functors

Lift a function f to operate on Functors

Example:

```scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)```
Definition Classes
Functor
58. def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
Definition Classes
TraverseFunctor
59. def mapWithIndex[A, B](fa: F[A])(f: (A, Int) ⇒ B): F[B]

Akin to map, but also provides the value's index in structure F when calling the function.

Akin to map, but also provides the value's index in structure F when calling the function.

Definition Classes
Traverse
60. def maximum[A](fa: F[A])(implicit A: Order[A]): A
Definition Classes
Reducible
61. def maximumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: 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)`.

Definition Classes
Reducible

minimumBy for minimum instead of maximum.

62. def maximumByList[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): List[A]

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

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.

Definition Classes
Foldable

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.

63. def maximumByNel[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): NonEmptyList[A]

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

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.

Definition Classes
Reducible

minimumByNel for minimum instead of maximum.

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

Definition Classes
Foldable

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.

65. def maximumList[A](fa: F[A])(implicit A: Order[A]): List[A]

Find all the maximum `A` items in this structure.

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

Definition Classes
Foldable

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.

66. def maximumNel[A](fa: F[A])(implicit A: Order[A]): NonEmptyList[A]

Find all the maximum `A` items in this structure.

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

Definition Classes
Reducible

minimumNel for minimum instead of maximum.

67. def maximumOption[A](fa: F[A])(implicit A: Order[A]): Option[A]

Find the maximum `A` item in this structure according to the `Order[A]`.

Find the maximum `A` item in this structure according to the `Order[A]`.

returns

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

Definition Classes
ReducibleFoldable

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

minimumOption for minimum instead of maximum.

68. def minimum[A](fa: F[A])(implicit A: Order[A]): A
Definition Classes
Reducible
69. def minimumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: 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)`.

Definition Classes
Reducible

maximumBy for maximum instead of minimum.

70. def minimumByList[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): List[A]

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

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.

Definition Classes
Foldable

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.

71. def minimumByNel[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): NonEmptyList[A]

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

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.

Definition Classes
Reducible

maximumByNel for maximum instead of minimum.

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

Definition Classes
Foldable

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.

73. def minimumList[A](fa: F[A])(implicit A: Order[A]): List[A]

Find all the minimum `A` items in this structure.

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

Definition Classes
Foldable

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.

74. def minimumNel[A](fa: F[A])(implicit A: Order[A]): NonEmptyList[A]

Find all the minimum `A` items in this structure.

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

Definition Classes
Reducible

maximumNel for maximum instead of minimum.

75. def minimumOption[A](fa: F[A])(implicit A: Order[A]): Option[A]

Find the minimum `A` item in this structure according to the `Order[A]`.

Find the minimum `A` item in this structure according to the `Order[A]`.

returns

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

Definition Classes
ReducibleFoldable

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

maximumOption for maximum instead of minimum.

76. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
77. def nonEmpty[A](fa: F[A])
Definition Classes
ReducibleFoldableUnorderedFoldable
78. def nonEmptyFlatSequence[G[_], A](fgfa: F[G[F[A]]])(implicit G: Apply[G], F: FlatMap[F]): G[F[A]]

Thread all the G effects through the F structure and flatten to invert the structure from F[G[F[A]]] to G[F[A]].

Thread all the G effects through the F structure and flatten to invert the structure from F[G[F[A]]] to G[F[A]].

Example:

```scala> import cats.implicits._
scala> import cats.data.NonEmptyList
scala> val x = NonEmptyList.of(Map(0 ->NonEmptyList.of(1, 2)), Map(0 -> NonEmptyList.of(3)))
scala> val y: NonEmptyList[Map[Int, NonEmptyList[Int]]] = NonEmptyList.of(Map(), Map(1 -> NonEmptyList.of(3)))
scala> x.nonEmptyFlatSequence
res0: Map[Int,cats.data.NonEmptyList[Int]] = Map(0 -> NonEmptyList(1, 2, 3))
scala> y.nonEmptyFlatSequence
res1: Map[Int,cats.data.NonEmptyList[Int]] = Map()```
79. def nonEmptyFlatTraverse[G[_], A, B](fa: F[A])(f: (A) ⇒ G[F[B]])(implicit G: Apply[G], F: FlatMap[F]): G[F[B]]

A nonEmptyTraverse followed by flattening the inner result.

A nonEmptyTraverse followed by flattening the inner result.

Example:

```scala> import cats.implicits._
scala> import cats.data.NonEmptyList
scala> val x = NonEmptyList.of(List("How", "do", "you", "fly"), List("What", "do", "you", "do"))
scala> x.nonEmptyFlatTraverse(_.groupByNel(identity) : Map[String, NonEmptyList[String]])
res0: Map[String,cats.data.NonEmptyList[String]] = Map(do -> NonEmptyList(do, do, do), you -> NonEmptyList(you, you))```
80. def nonEmptyIntercalate[A](fa: F[A], a: A)(implicit 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```
Definition Classes
Reducible
81. 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))```
Definition Classes
Reducible
82. def nonEmptySequence[G[_], A](fga: F[G[A]])(implicit arg0: Apply[G]): G[F[A]]

Thread all the G effects through the F structure to invert the structure from F[G[A]] to G[F[A]].

Thread all the G effects through the F structure to invert the structure from F[G[A]] to G[F[A]].

Example:

```scala> import cats.implicits._
scala> import cats.data.NonEmptyList
scala> val x = NonEmptyList.of(Map("do" -> 1, "you" -> 1), Map("do" -> 2, "you" -> 1))
scala> val y = NonEmptyList.of(Map("How" -> 3, "do" -> 1, "you" -> 1), Map[String,Int]())
scala> x.nonEmptySequence
res0: Map[String,NonEmptyList[Int]] = Map(do -> NonEmptyList(1, 2), you -> NonEmptyList(1, 1))
scala> y.nonEmptySequence
res1: Map[String,NonEmptyList[Int]] = Map()```
83. def nonEmptySequence_[G[_], A](fga: F[G[A]])(implicit 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.

Definition Classes
Reducible
84. def nonEmptyTraverse_[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit 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.

Definition Classes
Reducible
85. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native() @IntrinsicCandidate()
86. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native() @IntrinsicCandidate()
87. def partitionBifold[H[_, _], A, B, C](fa: F[A])(f: (A) ⇒ H[B, C])(implicit 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())```
Definition Classes
Foldable
Annotations
@noop()
88. def partitionBifoldM[G[_], H[_, _], A, B, C](fa: F[A])(f: (A) ⇒ G[H[B, C]])(implicit 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()))```
Definition Classes
Foldable
Annotations
@noop()
89. def partitionEither[A, B, C](fa: F[A])(f: (A) ⇒ Either[B, C])(implicit 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))```
Definition Classes
Foldable
90. def partitionEitherM[G[_], A, B, C](fa: F[A])(f: (A) ⇒ G[Either[B, C]])(implicit 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))```
Definition Classes
Foldable
Annotations
@noop()
91. def productAll[A](fa: F[A])(implicit A: Numeric[A]): A
Definition Classes
Foldable
92. def reduce[A](fa: F[A])(implicit A: Semigroup[A]): A

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

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

Definition Classes
Reducible
93. def reduceA[G[_], A](fga: F[G[A]])(implicit 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.

Definition Classes
Reducible
Annotations
@noop()
94. def reduceK[G[_], A](fga: F[G[A]])(implicit 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`.

Definition Classes
Reducible
95. 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.

Definition Classes
Reducible
96. def reduceLeftM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(g: (B, A) ⇒ G[B])(implicit G: FlatMap[G]): G[B]

Definition Classes
Reducible
97. 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.

Definition Classes
Foldable

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```
98. 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
ReducibleFoldable
99. def reduceMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit 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]`.

Definition Classes
Reducible
100. def reduceMapA[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: Apply[G], B: Semigroup[B]): G[B]

Reduce in an Apply context by mapping the `A` values to `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.

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```
Definition Classes
Reducible
101. def reduceMapK[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit 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"```
Definition Classes
Reducible
Annotations
@noop()
102. def reduceMapM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: FlatMap[G], B: Semigroup[B]): G[B]

Reduce in an FlatMap context by mapping the `A` values to `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.

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```
Definition Classes
Reducible
103. 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`.

Definition Classes
Reducible
104. 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.

Definition Classes
Foldable

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```
105. 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
ReducibleFoldable
106. def sequence[G[_], A](fga: F[G[A]])(implicit arg0: Applicative[G]): G[F[A]]

Thread all the G effects through the F structure to invert the structure from F[G[A]] to G[F[A]].

Thread all the G effects through the F structure to invert the structure from F[G[A]] to G[F[A]].

Example:

```scala> import cats.implicits._
scala> val x: List[Option[Int]] = List(Some(1), Some(2))
scala> val y: List[Option[Int]] = List(None, Some(2))
scala> x.sequence
res0: Option[List[Int]] = Some(List(1, 2))
scala> y.sequence
res1: Option[List[Int]] = None```
Definition Classes
Traverse
107. def sequence_[G[_], A](fga: F[G[A]])(implicit arg0: 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```
Definition Classes
Foldable
108. def size[A](fa: F[A]): Long

The size of this UnorderedFoldable.

The size of this UnorderedFoldable.

This is overridden in structures that have more efficient size implementations (e.g. Vector, Set, Map).

Note: will not terminate for infinite-sized collections.

Definition Classes
UnorderedFoldable
109. def sliding10[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
110. def sliding11[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
111. def sliding12[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
112. def sliding13[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
113. def sliding14[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
114. def sliding15[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
115. def sliding16[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
116. def sliding17[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
117. 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)]

Definition Classes
FoldableNFunctions
118. 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)]

Definition Classes
FoldableNFunctions
119. def sliding2[A](fa: F[A]): List[(A, A)]

Definition Classes
FoldableNFunctions
120. 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)]

Definition Classes
FoldableNFunctions
121. 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)]

Definition Classes
FoldableNFunctions
122. 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)]

Definition Classes
FoldableNFunctions
123. def sliding3[A](fa: F[A]): List[(A, A, A)]

Definition Classes
FoldableNFunctions
124. def sliding4[A](fa: F[A]): List[(A, A, A, A)]

Definition Classes
FoldableNFunctions
125. def sliding5[A](fa: F[A]): List[(A, A, A, A, A)]

Definition Classes
FoldableNFunctions
126. def sliding6[A](fa: F[A]): List[(A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
127. def sliding7[A](fa: F[A]): List[(A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
128. def sliding8[A](fa: F[A]): List[(A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
129. def sliding9[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A)]

Definition Classes
FoldableNFunctions
130. def sumAll[A](fa: F[A])(implicit A: Numeric[A]): A
Definition Classes
Foldable
131. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
132. def takeWhile_[A](fa: F[A])(p: (A) ⇒ Boolean): List[A]

Convert F[A] to a List[A], retaining only initial elements which match `p`.

Convert F[A] to a List[A], retaining only initial elements which match `p`.

Definition Classes
Foldable
133. 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.

Definition Classes
Foldable
134. def toList[A](fa: F[A]): List[A]

Convert F[A] to a List[A].

Convert F[A] to a List[A].

Definition Classes
Foldable
135. def toNonEmptyList[A](fa: F[A]): NonEmptyList[A]
Definition Classes
Reducible
136. def toString(): String
Definition Classes
AnyRef → Any
137. def traverse[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Applicative[G]): G[F[B]]

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[B] in a G context.

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[B] in a G context.

Example:

```scala> import cats.implicits._
scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption
scala> List("1", "2", "3").traverse(parseInt)
res0: Option[List[Int]] = Some(List(1, 2, 3))
scala> List("1", "two", "3").traverse(parseInt)
res1: Option[List[Int]] = None```
Definition Classes
NonEmptyTraverseTraverse
138. def traverseTap[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Applicative[G]): G[F[A]]

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[A] in a G context, ignoring the values returned by provided function.

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[A] in a G context, ignoring the values returned by provided function.

Example:

```scala> import cats.implicits._
scala> import java.io.IOException
scala> type IO[A] = Either[IOException, A]
scala> def debug(msg: String): IO[Unit] = Right(())
scala> List("1", "2", "3").traverseTap(debug)
res1: IO[List[String]] = Right(List(1, 2, 3))```
Definition Classes
Traverse
139. def traverseWithIndexM[G[_], A, B](fa: F[A])(f: (A, Int) ⇒ G[B])(implicit G: Monad[G]): G[F[B]]

Akin to traverse, but also provides the value's index in structure F when calling the function.

Akin to traverse, but also provides the value's index in structure F when calling the function.

This performs the traversal in a single pass but requires that effect G is monadic. An applicative traversal can be performed in two passes using zipWithIndex followed by traverse.

Definition Classes
Traverse
140. def traverse_[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit 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.

Definition Classes
Foldable
141. def tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]

Tuples the `A` value in `F[A]` with the supplied `B` value, with the `B` value on the left.

Tuples the `A` value in `F[A]` with the supplied `B` value, with the `B` value on the left.

Example:

```scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))```
Definition Classes
Functor
142. def tupleRight[A, B](fa: F[A], b: B): F[(A, B)]

Tuples the `A` value in `F[A]` with the supplied `B` value, with the `B` value on the right.

Tuples the `A` value in `F[A]` with the supplied `B` value, with the `B` value on the right.

Example:

```scala> import scala.collection.immutable.Queue
scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForQueue

scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))```
Definition Classes
Functor
143. def unorderedFold[A](fa: F[A])(implicit arg0: CommutativeMonoid[A]): A
Definition Classes
FoldableUnorderedFoldable
144. def unorderedFoldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: CommutativeMonoid[B]): B
Definition Classes
FoldableUnorderedFoldable
145. def unorderedSequence[G[_], A](fga: F[G[A]])(implicit arg0: CommutativeApplicative[G]): G[F[A]]
Definition Classes
TraverseUnorderedTraverse
146. def unorderedTraverse[G[_], A, B](sa: F[A])(f: (A) ⇒ G[B])(implicit arg0: CommutativeApplicative[G]): G[F[B]]
Definition Classes
TraverseUnorderedTraverse
147. def unzip[A, B](fab: F[(A, B)]): (F[A], F[B])

Un-zips an `F[(A, B)]` consisting of element pairs or Tuple2 into two separate F's tupled.

Un-zips an `F[(A, B)]` consisting of element pairs or Tuple2 into two separate F's tupled.

NOTE: Check for effect duplication, possibly memoize before

```scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))```
Definition Classes
Functor
Annotations
@noop()
148. def void[A](fa: F[A]): F[Unit]

Empty the fa of the values, preserving the structure

Empty the fa of the values, preserving the structure

Example:

```scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForList

scala> Functor[List].void(List(1,2,3))
res0: List[Unit] = List((), (), ())```
Definition Classes
Functor
149. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
150. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
151. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
152. def widen[A, B >: A](fa: F[A]): F[B]

Lifts natural subtyping covariance of covariant Functors.

Lifts natural subtyping covariance of covariant Functors.

NOTE: In certain (perhaps contrived) situations that rely on universal equality this can result in a `ClassCastException`, because it is implemented as a type cast. It could be implemented as `map(identity)`, but according to the functor laws, that should be equal to `fa`, and a type cast is often much more performant. See this example of `widen` creating a `ClassCastException`.

Example:

```scala> import cats.Functor
scala> import cats.implicits.catsStdInstancesForOption

scala> val s = Some(42)
scala> Functor[Option].widen(s)
res0: Option[Int] = Some(42)```
Definition Classes
Functor
153. def zipWithIndex[A](fa: F[A]): F[(A, Int)]

Traverses through the structure F, pairing the values with assigned indices.

Traverses through the structure F, pairing the values with assigned indices.

The behavior is consistent with the Scala collection library's `zipWithIndex` for collections such as `List`.

Definition Classes
Traverse

### Deprecated Value Members

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

### foldable arity

Group sequential elements into fixed sized tuples by passing a "sliding window" over them. A foldable with fewer elements than the window size will return an empty list unlike `Iterable#sliding(size: Int)`. Example:

```import cats.Foldable
scala> Foldable[List].sliding2((1 to 10).toList)
val res0: List[(Int, Int)] = List((1,2), (2,3), (3,4), (4,5), (5,6), (6,7), (7,8), (8,9), (9,10))

scala> Foldable[List].sliding4((1 to 10).toList)
val res1: List[(Int, Int, Int, Int)] = List((1,2,3,4), (2,3,4,5), (3,4,5,6), (4,5,6,7), (5,6,7,8), (6,7,8,9), (7,8,9,10))

scala> Foldable[List].sliding4((1 to 2).toList)
val res2: List[(Int, Int, Int, Int)] = List()```