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]
- Source
- NonEmptyTraverse.scala
- Grouped
- Alphabetic
- By Inheritance
- NonEmptyTraverse
- Reducible
- Traverse
- UnorderedTraverse
- Foldable
- FoldableNFunctions
- UnorderedFoldable
- Functor
- Invariant
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
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
-
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
-
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.syntax.all._ 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
-
abstract
def
reduceLeftTo[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B, A) ⇒ B): B
Apply
f
to the "initial element" offa
and combine it with every other value using the given functiong
.Apply
f
to the "initial element" offa
and combine it with every other value using the given functiong
.- Definition Classes
- Reducible
-
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" offa
and lazily combine it with every other value using the given functiong
.Apply
f
to the "initial element" offa
and lazily combine it with every other value using the given functiong
.- Definition Classes
- Reducible
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
as[A, B](fa: F[A], b: B): F[B]
Replaces the
A
value inF[A]
with the supplied value.Replaces the
A
value inF[A]
with the supplied value.Example:
scala> import cats.syntax.all._ scala> List(1,2,3).as("hello") res0: List[String] = List(hello, hello, hello)
- Definition Classes
- Functor
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
collectFirst[A, B](fa: F[A])(pf: PartialFunction[A, B]): Option[B]
- Definition Classes
- Foldable
-
def
collectFirstSome[A, B](fa: F[A])(f: (A) ⇒ Option[B]): Option[B]
Like
collectFirst
fromscala.collection.Traversable
but takesA => Option[B]
instead ofPartialFunction
s.Like
collectFirst
fromscala.collection.Traversable
but takesA => Option[B]
instead ofPartialFunction
s.scala> import cats.syntax.all._ 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
-
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.syntax.all._ 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
-
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.syntax.all._ 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
-
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.syntax.all._ 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
-
def
combineAll[A](fa: F[A])(implicit arg0: Monoid[A]): A
Alias for fold.
-
def
combineAllOption[A](fa: F[A])(implicit ev: Semigroup[A]): Option[A]
- Definition Classes
- Foldable
- def compose[G[_]](implicit arg0: NonEmptyTraverse[G]): NonEmptyTraverse[[α]F[G[α]]]
-
def
compose[G[_]](implicit arg0: Reducible[G]): Reducible[[α]F[G[α]]]
- Definition Classes
- Reducible
-
def
compose[G[_]](implicit arg0: Traverse[G]): Traverse[[α]F[G[α]]]
- Definition Classes
- Traverse
-
def
compose[G[_]](implicit arg0: Foldable[G]): Foldable[[α]F[G[α]]]
- Definition Classes
- Foldable
-
def
compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
- Definition Classes
- Functor
-
def
compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[G[α]]]
Compose Invariant
F[_]
andG[_]
then produceInvariant[F[G[_]]]
using theirimap
.Compose Invariant
F[_]
andG[_]
then produceInvariant[F[G[_]]]
using theirimap
.Example:
scala> import cats.syntax.all._ 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
-
def
composeBifunctor[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β]]]
- Definition Classes
- Functor
-
def
composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[G[α]]]
Compose Invariant
F[_]
and ContravariantG[_]
then produceInvariant[F[G[_]]]
using F'simap
and G'scontramap
.Compose Invariant
F[_]
and ContravariantG[_]
then produceInvariant[F[G[_]]]
using F'simap
and G'scontramap
.Example:
scala> import cats.syntax.all._ 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
-
def
composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[G[α]]]
Compose Invariant
F[_]
and FunctorG[_]
then produceInvariant[F[G[_]]]
using F'simap
and G'smap
.Compose Invariant
F[_]
and FunctorG[_]
then produceInvariant[F[G[_]]]
using F'simap
and G'smap
.Example:
scala> import cats.syntax.all._ 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
-
def
contains_[A](fa: F[A], v: A)(implicit ev: Eq[A]): Boolean
Tests if
fa
containsv
using theEq
instance forA
Tests if
fa
containsv
using theEq
instance forA
- Definition Classes
- UnorderedFoldable
-
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.syntax.all._ 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
-
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
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
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
- Foldable → UnorderedFoldable
-
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 atrue
result is encountered, no further effects are produced.For example:
scala> import cats.syntax.all._ 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
-
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
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
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
-
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.syntax.all._ 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
-
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.syntax.all._ 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
-
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.syntax.all._ 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
-
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.syntax.all._ 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
-
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
-
def
foldA[G[_], A](fga: F[G[A]])(implicit G: Applicative[G], A: Monoid[A]): G[A]
Fold implemented using the given
Applicative[G]
andMonoid[A]
instance.Fold implemented using the given
Applicative[G]
andMonoid[A]
instance.This method is similar to fold, but may short-circuit.
For example:
scala> import cats.syntax.all._ 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)
- Definition Classes
- Foldable
-
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 aMonoid[G[A]]
instance.For example:
scala> import cats.syntax.all._ 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
-
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.
-
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 monadG
.Perform a stack-safe monadic left fold from the source context
F
into the target monadG
.This method can express short-circuiting semantics. Even when
fa
is an infinite structure, this method can potentially terminate if thefoldRight
implementation forF
and thetailRecM
implementation forG
are sufficiently lazy.Instances for concrete structures (e.g.
List
) will often have a more efficient implementation than the default one in terms offoldRight
.- Definition Classes
- Foldable
-
def
foldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit B: Monoid[B]): B
Fold implemented by mapping
A
values intoB
and then combining them using the givenMonoid[B]
instance.Fold implemented by mapping
A
values intoB
and then combining them using the givenMonoid[B]
instance.- Definition Classes
- Foldable
-
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 toG[B]
.Fold in an Applicative context by mapping the
A
values toG[B]
. combining theB
values using the givenMonoid[B]
instance.Similar to foldMapM, but will typically be less efficient.
scala> import cats.Foldable scala> import cats.syntax.all._ 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
-
def
foldMapK[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: MonoidK[G]): G[B]
Fold implemented by mapping
A
values intoB
in a contextG
and then combining them using theMonoidK[G]
instance.Fold implemented by mapping
A
values intoB
in a contextG
and then combining them using theMonoidK[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
-
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 mappingA
values toG[B]
, combining theB
values using the givenMonoid[B]
instance.Monadic folding on
F
by mappingA
values toG[B]
, combining theB
values using the givenMonoid[B]
instance.Similar to foldM, but using a
Monoid[B]
. Will typically be more efficient than foldMapA.scala> import cats.Foldable scala> import cats.syntax.all._ 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
-
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
-
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
- Foldable → UnorderedFoldable
-
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 afalse
result is encountered, no further effects are produced.For example:
scala> import cats.syntax.all._ 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
-
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.syntax.all._ scala> Option(42).fproduct(_.toString) res0: Option[(Int, String)] = Some((42,42))
- Definition Classes
- Functor
-
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.syntax.all._ scala> Option(42).fproductLeft(_.toString) res0: Option[(String, Int)] = Some((42,42))
- Definition Classes
- Functor
-
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
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
ifF[A](fb: F[Boolean])(ifTrue: ⇒ A, ifFalse: ⇒ A): F[A]
Lifts
if
to FunctorLifts
if
to FunctorExample:
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
-
def
imap[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B) ⇒ A): F[B]
Transform an
F[A]
into anF[B]
by providing a transformation fromA
toB
and one fromB
toA
.Transform an
F[A]
into anF[B]
by providing a transformation fromA
toB
and one fromB
toA
.Example:
scala> import cats.syntax.all._ 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
-
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.syntax.all._ 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
-
def
intersperseList[A](xs: List[A], x: A): List[A]
- Attributes
- protected
- Definition Classes
- Foldable
-
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
- Reducible → Foldable → UnorderedFoldable
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
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
- def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
-
def
mapAccumulate[S, A, B](init: S, fa: F[A])(f: (S, A) ⇒ (S, B)): (S, F[B])
Akin to map, but allows to keep track of a state value when calling the function.
-
def
mapOrKeep[A, A1 >: A](fa: F[A])(pf: PartialFunction[A, A1]): F[A1]
Modifies the
A
value inF[A]
with the supplied function, if the function is defined for the value.Modifies the
A
value inF[A]
with the supplied function, if the function is defined for the value. Example:scala> import cats.syntax.all._ scala> List(1, 2, 3).mapOrKeep { case 2 => 42 } res0: List[Int] = List(1, 42, 3)
- Definition Classes
- Functor
-
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.
-
def
mapWithLongIndex[A, B](fa: F[A])(f: (A, Long) ⇒ B): F[B]
Same as mapWithIndex but the index type is Long instead of Int.
Same as mapWithIndex but the index type is Long instead of Int.
- Definition Classes
- Traverse
-
def
maximum[A](fa: F[A])(implicit A: Order[A]): A
- Definition Classes
- Reducible
-
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 anOrder.by(f)
. -
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 anOrder.by(f)
.Find all the maximum
A
items in this structure according to anOrder.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.
-
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 anOrder.by(f)
.Find all the maximum
A
items in this structure according to anOrder.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.
-
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 anOrder.by(f)
.Find the maximum
A
item in this structure according to anOrder.by(f)
.- returns
None
if the structure is empty, otherwise the maximum element wrapped in aSome
.
- 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.
-
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.
-
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.
-
def
maximumOption[A](fa: F[A])(implicit A: Order[A]): Option[A]
Find the maximum
A
item in this structure according to theOrder[A]
.Find the maximum
A
item in this structure according to theOrder[A]
.- returns
None
if the structure is empty, otherwise the maximum element wrapped in aSome
.
- Definition Classes
- Reducible → Foldable
- 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.
-
def
minimum[A](fa: F[A])(implicit A: Order[A]): A
- Definition Classes
- Reducible
-
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 anOrder.by(f)
. -
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 anOrder.by(f)
.Find all the minimum
A
items in this structure according to anOrder.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.
-
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 anOrder.by(f)
.Find all the minimum
A
items in this structure according to anOrder.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.
-
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 anOrder.by(f)
.Find the minimum
A
item in this structure according to anOrder.by(f)
.- returns
None
if the structure is empty, otherwise the minimum element wrapped in aSome
.
- 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.
-
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.
-
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.
-
def
minimumOption[A](fa: F[A])(implicit A: Order[A]): Option[A]
Find the minimum
A
item in this structure according to theOrder[A]
.Find the minimum
A
item in this structure according to theOrder[A]
.- returns
None
if the structure is empty, otherwise the minimum element wrapped in aSome
.
- Definition Classes
- Reducible → Foldable
- 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.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
nonEmpty[A](fa: F[A]): Boolean
- Definition Classes
- Reducible → Foldable → UnorderedFoldable
-
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.syntax.all._ 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()
-
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.syntax.all._ 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))
-
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.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
-
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
-
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.syntax.all._ 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()
-
def
nonEmptySequence_[G[_], A](fga: F[G[A]])(implicit G: Apply[G]): G[Unit]
Sequence
F[G[A]]
usingApply[G]
.Sequence
F[G[A]]
usingApply[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
-
def
nonEmptyTraverse_[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: Apply[G]): G[Unit]
Traverse
F[A]
usingApply[G]
.Traverse
F[A]
usingApply[G]
.A
values will be mapped intoG[B]
and combined usingApply#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 forG
and want to take advantage of short-circuiting the traversal.- Definition Classes
- Reducible
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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 someBifoldable[H]
Equivalent toFunctor#map
and thenAlternative#separate
.Separate this Foldable into a Tuple by a separating function
A => H[B, C]
for someBifoldable[H]
Equivalent toFunctor#map
and thenAlternative#separate
.scala> import cats.syntax.all._, 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
-
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 someBifoldable[H]
Equivalent toTraverse#traverse
overAlternative#separate
Separate this Foldable into a Tuple by an effectful separating function
A => G[H[B, C]]
for someBifoldable[H]
Equivalent toTraverse#traverse
overAlternative#separate
scala> import cats.syntax.all._, 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
-
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 toFunctor#map
and thenAlternative#separate
.Separate this Foldable into a Tuple by a separating function
A => Either[B, C]
Equivalent toFunctor#map
and thenAlternative#separate
.scala> import cats.syntax.all._ 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
-
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 toTraverse#traverse
overAlternative#separate
Separate this Foldable into a Tuple by an effectful separating function
A => G[Either[B, C]]
Equivalent toTraverse#traverse
overAlternative#separate
scala> import cats.syntax.all._, 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
-
def
productAll[A](fa: F[A])(implicit A: Numeric[A]): A
- Definition Classes
- Foldable
-
def
reduce[A](fa: F[A])(implicit A: Semigroup[A]): A
Reduce a
F[A]
value using the givenSemigroup[A]
.Reduce a
F[A]
value using the givenSemigroup[A]
.- Definition Classes
- Reducible
-
def
reduceA[G[_], A](fga: F[G[A]])(implicit G: Apply[G], A: Semigroup[A]): G[A]
Reduce a
F[G[A]]
value usingApplicative[G]
andSemigroup[A]
, a universal semigroup forG[_]
. -
def
reduceK[G[_], A](fga: F[G[A]])(implicit G: SemigroupK[G]): G[A]
Reduce a
F[G[A]]
value usingSemigroupK[G]
, a universal semigroup forG[_]
.Reduce a
F[G[A]]
value usingSemigroupK[G]
, a universal semigroup forG[_]
.This method is a generalization of
reduce
.scala> import cats.Reducible scala> import cats.data._ scala> Reducible[NonEmptyVector].reduceK(NonEmptyVector.of(NonEmptyList.of(1, 2, 3), NonEmptyList.of(4, 5, 6), NonEmptyList.of(7, 8, 9))) res0: NonEmptyList[Int] = NonEmptyList(1, 2, 3, 4, 5, 6, 7, 8, 9)
- Definition Classes
- Reducible
-
def
reduceLeft[A](fa: F[A])(f: (A, A) ⇒ A): A
Left-associative reduction on
F
using the functionf
.Left-associative reduction on
F
using the functionf
.Implementations should override this method when possible.
- Definition Classes
- Reducible
-
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
-
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 thef
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.syntax.all._ 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
-
def
reduceLeftToOption[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B, A) ⇒ B): Option[B]
Overridden from Foldable for efficiency.
-
def
reduceMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit B: Semigroup[B]): B
Apply
f
to each element offa
and combine them using the givenSemigroup[B]
.Apply
f
to each element offa
and combine them using the givenSemigroup[B]
.scala> import cats.Reducible scala> import cats.data.NonEmptyList scala> Reducible[NonEmptyList].reduceMap(NonEmptyList.of(1, 2, 3))(v => v.toString * v) res0: String = 122333 scala> val gt5: Int => Option[Int] = (num: Int) => Some(num).filter(_ > 5) scala> Reducible[NonEmptyList].reduceMap(NonEmptyList.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))(gt5) res1: Option[Int] = Some(40)
- Definition Classes
- Reducible
-
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 toG[B]
.Reduce in an Apply context by mapping the
A
values toG[B]
. combining theB
values using the givenSemigroup[B]
instance.Similar to reduceMapM, but may be less efficient.
scala> import cats.Reducible scala> import cats.data.NonEmptyList 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
-
def
reduceMapK[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: SemigroupK[G]): G[B]
Apply
f
to each element offa
and combine them using the givenSemigroupK[G]
.Apply
f
to each element offa
and combine them using the givenSemigroupK[G]
.scala> import cats._, cats.data._ 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
-
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 toG[B]
.Reduce in an FlatMap context by mapping the
A
values toG[B]
. combining theB
values using the givenSemigroup[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> 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
-
def
reduceRight[A](fa: F[A])(f: (A, Eval[A]) ⇒ Eval[A]): Eval[A]
Right-associative reduction on
F
using the functionf
.Right-associative reduction on
F
using the functionf
.- Definition Classes
- Reducible
-
def
reduceRightOption[A](fa: F[A])(f: (A, Eval[A]) ⇒ Eval[A]): Eval[Option[A]]
Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.
Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.
- returns
None
if the structure is empty, otherwise the result of combining the cumulative right-associative result of thef
operation over theA
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.syntax.all._ 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
-
def
reduceRightToOption[A, B](fa: F[A])(f: (A) ⇒ B)(g: (A, Eval[B]) ⇒ Eval[B]): Eval[Option[B]]
Overridden from Foldable for efficiency.
-
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.syntax.all._ 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
-
def
sequence_[G[_], A](fga: F[G[A]])(implicit arg0: Applicative[G]): G[Unit]
Sequence
F[G[A]]
usingApplicative[G]
.Sequence
F[G[A]]
usingApplicative[G]
.This is similar to
traverse_
except it operates onF[G[A]]
values, so no additional functions are needed.For example:
scala> import cats.syntax.all._ 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
-
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
-
def
sliding10[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding11[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding12[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding13[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding14[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
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
-
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
-
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
-
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
-
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
-
def
sliding2[A](fa: F[A]): List[(A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding20[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding21[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding22[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding3[A](fa: F[A]): List[(A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding4[A](fa: F[A]): List[(A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding5[A](fa: F[A]): List[(A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding6[A](fa: F[A]): List[(A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding7[A](fa: F[A]): List[(A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding8[A](fa: F[A]): List[(A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sliding9[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
-
def
sumAll[A](fa: F[A])(implicit A: Numeric[A]): A
- Definition Classes
- Foldable
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
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
-
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
-
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
-
def
toNonEmptyList[A](fa: F[A]): NonEmptyList[A]
- Definition Classes
- Reducible
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
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.syntax.all._ 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
- NonEmptyTraverse → Traverse
-
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.syntax.all._ 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
-
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
-
def
traverseWithLongIndexM[G[_], A, B](fa: F[A])(f: (A, Long) ⇒ G[B])(implicit G: Monad[G]): G[F[B]]
Same as traverseWithIndexM but the index type is Long instead of Int.
Same as traverseWithIndexM but the index type is Long instead of Int.
- Definition Classes
- Traverse
-
def
traverse_[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: Applicative[G]): G[Unit]
Traverse
F[A]
usingApplicative[G]
.Traverse
F[A]
usingApplicative[G]
.A
values will be mapped intoG[B]
and combined usingApplicative#map2
.For example:
scala> import cats.syntax.all._ 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 specificA
aspect ofG[A]
is not otherwise needed.- Definition Classes
- Foldable
-
def
tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Tuples the
A
value inF[A]
with the suppliedB
value, with theB
value on the left.Tuples the
A
value inF[A]
with the suppliedB
value, with theB
value on the left.Example:
scala> import scala.collection.immutable.Queue scala> import cats.syntax.all._ scala> Queue("hello", "world").tupleLeft(42) res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
- Definition Classes
- Functor
-
def
tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Tuples the
A
value inF[A]
with the suppliedB
value, with theB
value on the right.Tuples the
A
value inF[A]
with the suppliedB
value, with theB
value on the right.Example:
scala> import scala.collection.immutable.Queue scala> import cats.syntax.all._ scala> Queue("hello", "world").tupleRight(42) res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
- Definition Classes
- Functor
-
def
unorderedFold[A](fa: F[A])(implicit arg0: CommutativeMonoid[A]): A
- Definition Classes
- Foldable → UnorderedFoldable
-
def
unorderedFoldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: CommutativeMonoid[B]): B
- Definition Classes
- Foldable → UnorderedFoldable
-
def
unorderedSequence[G[_], A](fga: F[G[A]])(implicit arg0: CommutativeApplicative[G]): G[F[A]]
- Definition Classes
- Traverse → UnorderedTraverse
-
def
unorderedTraverse[G[_], A, B](sa: F[A])(f: (A) ⇒ G[B])(implicit arg0: CommutativeApplicative[G]): G[F[B]]
- Definition Classes
- Traverse → UnorderedTraverse
-
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
-
def
updated_[A, B >: A](fa: F[A], idx: Long, b: B): Option[F[B]]
If
fa
contains the element at indexidx
, return the copy offa
where the element atidx
is replaced withb
.If
fa
contains the element at indexidx
, return the copy offa
where the element atidx
is replaced withb
. If there is no element with such an index, returnNone
.The behavior is consistent with the Scala collection library's
updated
for collections such asList
.- Definition Classes
- Traverse
-
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.syntax.all._ scala> List(1,2,3).void res0: List[Unit] = List((), (), ())
- Definition Classes
- Functor
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
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 asmap(identity)
, but according to the functor laws, that should be equal tofa
, and a type cast is often much more performant. See this example ofwiden
creating aClassCastException
.Example:
scala> import cats.syntax.all._ scala> val l = List(Some(42)) scala> l.widen[Option[Int]] res0: List[Option[Int]] = List(Some(42))
- Definition Classes
- Functor
-
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 asList
.- Definition Classes
- Traverse
-
def
zipWithLongIndex[A](fa: F[A]): F[(A, Long)]
Same as zipWithIndex but the index type is Long instead of Int.
Same as zipWithIndex but the index type is Long instead of Int.
- 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()