NonEmptyTraverse
Related Docs:
object NonEmptyTraverse
| package cats
Left associative fold on 'F' using the function 'f'.
Left associative fold on 'F' using the function 'f'.
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[_].
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).mapValues(_.length) scala> NonEmptyList.of(List("How", "do", "you", "fly"), List("What", "do", "you", "do")).nonEmptyTraverse(countWords) res0: Map[String,cats.data.NonEmptyList[Int]] = Map(do -> NonEmptyList(1, 2), you -> NonEmptyList(1, 1))
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.
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.
Replaces the A value in F[A] with the supplied value.
Replaces the A value in F[A] with the supplied value.
Alias for fold.
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.
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.
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
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.
Find the first element matching the predicate, if one exists.
Find the first element matching the predicate, if one exists.
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
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))
Fold implemented using the given Monoid[A] instance.
Fold implemented using the given Monoid[A] instance.
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)
Alias for foldM.
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.
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.
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].
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
Check whether all elements satisfy the predicate.
Check whether all elements satisfy the predicate.
If there are no elements, the result is true.
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
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
Get the element at the index of the Foldable.
Get the element at the index of the Foldable.
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
Returns true if there are no elements.
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Akin to map, but also provides the value's index in structure F when calling the function.
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].
None if the structure is empty, otherwise the maximum element
wrapped in a Some.
minimumOption for minimum instead of maximum.
Reducible#maximum for a version that doesn't need to return an
Option for structures that are guaranteed to be non-empty.
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].
None if the structure is empty, otherwise the minimum element
wrapped in a Some.
maximumOption for maximum instead of minimum.
Reducible#minimum for a version that doesn't need to return an
Option for structures that are guaranteed to be non-empty.
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()
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))
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
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))
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()
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.
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.
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))
Reduce a F[A] value using the given Semigroup[A].
Reduce a F[A] value using the given Semigroup[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.
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.
Monadic variant of reduceLeftTo
Monadic variant of reduceLeftTo
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.
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.
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
reduceRightOption for a right-associative alternative.
Overriden from Foldable for efficiency.
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].
Monadic reducing by mapping the A values to G[B].
Monadic reducing 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].
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
Right-associative reduction on F using the function f.
Right-associative reduction on F using the function f.
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.
None if the structure is empty, otherwise the result of combining
the cumulative right-associative result of the f operation over the
A elements.
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 eqivalent 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
reduceLeftOption for a left-associative alternative
Overriden from Foldable for efficiency.
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
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
The size of this Foldable.
The size of this Foldable.
This is overriden in structures that have more efficient size implementations (e.g. Vector, Set, Map).
Note: will not terminate for infinite-sized collections.
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.
Convert F[A] to a List[A].
Convert F[A] to a List[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[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
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.
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.
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.
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.
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
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.
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.
NonEmptyTraverse, also known as Traversable1.
NonEmptyTraverseis like a non-emptyTraverse. In addition to the traverse and sequence methods it provides nonEmptyTraverse and nonEmptySequence methods which require anApplyinstance instead ofApplicative.