Packages

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
Type Hierarchy
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)
    
    Folding by addition to zero:
    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)
    
    Folding by addition to zero:
    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): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    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(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  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 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
    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): Boolean
    Definition Classes
    AnyRef
  25. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  26. def exists[A](fa: F[A])(p: (A) ⇒ Boolean): 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 finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  30. 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
  31. 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()
  32. 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
  33. 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
  34. 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
  35. 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
  36. 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()
  37. 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
  38. 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
  39. 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
  40. 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
  41. 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
  42. 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()
  43. 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
  44. 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
  45. def forall[A](fa: F[A])(p: (A) ⇒ Boolean): 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
  46. 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
  47. 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
  48. 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
  49. 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
  50. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  51. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  52. 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()
  53. 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
  54. 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
  55. def intersperseList[A](xs: List[A], x: A): List[A]
    Attributes
    protected
    Definition Classes
    Foldable
  56. def isEmpty[A](fa: F[A]): Boolean

    Returns true if there are no elements.

    Returns true if there are no elements. Otherwise false.

    Definition Classes
    ReducibleFoldableUnorderedFoldable
  57. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  58. 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
  59. def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
    Definition Classes
    TraverseFunctor
  60. 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
  61. def maximum[A](fa: F[A])(implicit A: Order[A]): A
    Definition Classes
    Reducible
  62. 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
    See also

    minimumBy for minimum instead of maximum.

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

  64. 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
    See also

    minimumByNel for minimum instead of maximum.

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

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

  67. 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
    See also

    minimumNel for minimum instead of maximum.

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

    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.

  69. def minimum[A](fa: F[A])(implicit A: Order[A]): A
    Definition Classes
    Reducible
  70. 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
    See also

    maximumBy for maximum instead of minimum.

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

  72. 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
    See also

    maximumByNel for maximum instead of minimum.

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

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

  75. 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
    See also

    maximumNel for maximum instead of minimum.

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

    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.

  77. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  78. def nonEmpty[A](fa: F[A]): Boolean
    Definition Classes
    ReducibleFoldableUnorderedFoldable
  79. 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()
  80. 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))
  81. 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
  82. 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
  83. 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()
  84. 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
  85. 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
  86. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  87. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  88. 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()
  89. 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()
  90. 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
  91. 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()
  92. def productAll[A](fa: F[A])(implicit A: Numeric[A]): A
    Definition Classes
    Foldable
  93. 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
  94. 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()
  95. 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
  96. 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
  97. def reduceLeftM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(g: (B, A) ⇒ G[B])(implicit G: FlatMap[G]): G[B]

    Monadic variant of reduceLeftTo.

    Monadic variant of reduceLeftTo.

    Definition Classes
    Reducible
  98. 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
    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
  99. 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
  100. 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
  101. 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
  102. 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()
  103. 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
  104. 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
  105. 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
    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
  106. 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
  107. 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
  108. 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
  109. 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
  110. def sliding10[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A)]

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

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

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

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

    Definition Classes
    FoldableNFunctions
  115. 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
  116. 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
  117. 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
  118. 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
  119. 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
  120. def sliding2[A](fa: F[A]): List[(A, A)]

    Definition Classes
    FoldableNFunctions
  121. 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
  122. 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
  123. 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
  124. def sliding3[A](fa: F[A]): List[(A, A, A)]

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

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

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

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

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

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

    Definition Classes
    FoldableNFunctions
  131. def sumAll[A](fa: F[A])(implicit A: Numeric[A]): A
    Definition Classes
    Foldable
  132. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  133. 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
  134. 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
  135. 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
  136. def toNonEmptyList[A](fa: F[A]): NonEmptyList[A]
    Definition Classes
    Reducible
  137. def toString(): String
    Definition Classes
    AnyRef → Any
  138. 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
  139. 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
  140. 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
  141. 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
  142. 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
  143. 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
  144. def unorderedFold[A](fa: F[A])(implicit arg0: CommutativeMonoid[A]): A
    Definition Classes
    FoldableUnorderedFoldable
  145. def unorderedFoldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: CommutativeMonoid[B]): B
    Definition Classes
    FoldableUnorderedFoldable
  146. def unorderedSequence[G[_], A](fga: F[G[A]])(implicit arg0: CommutativeApplicative[G]): G[F[A]]
    Definition Classes
    TraverseUnorderedTraverse
  147. def unorderedTraverse[G[_], A, B](sa: F[A])(f: (A) ⇒ G[B])(implicit arg0: CommutativeApplicative[G]): G[F[B]]
    Definition Classes
    TraverseUnorderedTraverse
  148. 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()
  149. 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
  150. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  151. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  152. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  153. 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
  154. 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

Inherited from Reducible[F]

Inherited from Traverse[F]

Inherited from UnorderedTraverse[F]

Inherited from Foldable[F]

Inherited from FoldableNFunctions[F]

Inherited from UnorderedFoldable[F]

Inherited from Functor[F]

Inherited from Invariant[F]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped

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()