t

cats

Traverse 

Companion object Traverse

trait Traverse[F[_]] extends Functor[F] with Foldable[F] with UnorderedTraverse[F]

Traverse, also known as Traversable.

Traversal over a structure with an effect.

Traversing with the cats.Id effect is equivalent to cats.Functor#map. Traversing with the cats.data.Const effect where the first type parameter has a cats.Monoid instance is equivalent to cats.Foldable#fold.

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

Abstract Value Members

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

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

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

Example:

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

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

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

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

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

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

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

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

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

Example:

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

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

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

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

To get past this and make sure you're getting the lazy `foldRight` defined
in `Foldable`, there's an alias `foldr`:
scala> val folded3 = fa.foldr(Eval.now(0))((n, a) => a.map(_ + n))
scala> folded3.value
res1: Int = 1```
Definition Classes
Foldable
3. abstract def 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```

Concrete Value Members

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

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

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

Example:

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

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

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

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

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

Monadic version of `collectFirstSome`.

Monadic version of `collectFirstSome`.

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

For example:

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

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

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

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

Tear down a subset of this structure using a `PartialFunction`.

Tear down a subset of this structure using a `PartialFunction`.

```scala> import cats.implicits._
scala> val xs = List(1, 2, 3, 4)
scala> Foldable[List].collectFold(xs) { case n if n % 2 == 0 => n }
res0: Int = 6```
Definition Classes
Foldable
Annotations
@noop()
11. def collectFoldSome[A, B](fa: F[A])(f: (A) ⇒ Option[B])(implicit B: Monoid[B]): B

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

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

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

Alias for fold.

Alias for fold.

Definition Classes
Foldable
13. def combineAllOption[A](fa: F[A])(implicit ev: Semigroup[A]): Option[A]
Definition Classes
Foldable
14. def compose[G[_]](implicit arg0: Traverse[G]): Traverse[[α]F[G[α]]]
15. def compose[G[_]](implicit arg0: Foldable[G]): Foldable[[α]F[G[α]]]
Definition Classes
Foldable
16. def compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
Definition Classes
Functor
17. 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
18. 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
19. 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
20. 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()
21. 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
22. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
23. def equals(arg0: Any)
Definition Classes
AnyRef → Any
24. def exists[A](fa: F[A])(p: (A) ⇒ Boolean)

Check whether at least one element satisfies the predicate.

Check whether at least one element satisfies the predicate.

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

Definition Classes
FoldableUnorderedFoldable
25. 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
26. 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
27. 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
28. 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()
29. 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```
30. 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))```
31. 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
32. 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
33. 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()
34. 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
35. 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
36. 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
37. 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
38. 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
39. 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()
40. 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
41. 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
42. def forall[A](fa: F[A])(p: (A) ⇒ Boolean)

Check whether all elements satisfy the predicate.

Check whether all elements satisfy the predicate.

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

Definition Classes
FoldableUnorderedFoldable
43. 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
44. 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
45. 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
46. 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
47. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native() @IntrinsicCandidate()
48. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native() @IntrinsicCandidate()
49. 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()
50. 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
51. 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
52. def intersperseList[A](xs: List[A], x: A): List[A]
Attributes
protected
Definition Classes
Foldable
53. def isEmpty[A](fa: F[A])

Returns true if there are no elements.

Returns true if there are no elements. Otherwise false.

Definition Classes
FoldableUnorderedFoldable
54. final def isInstanceOf[T0]
Definition Classes
Any
55. 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
56. def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
Definition Classes
TraverseFunctor
57. 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.

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

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

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

Definition Classes
Foldable

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

minimumByList for minimum instead of maximum.

59. def maximumByOption[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

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

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

returns

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

Definition Classes
Foldable

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

minimumByOption for minimum instead of maximum.

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

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

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

Definition Classes
Foldable

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

minimumList for minimum instead of maximum.

61. 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
Foldable

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.

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

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

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

Definition Classes
Foldable

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

maximumByList for maximum instead of minimum.

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

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

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

returns

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

Definition Classes
Foldable

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

maximumByOption for maximum instead of minimum.

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

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

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

Definition Classes
Foldable

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

maximumList for maximum instead of minimum.

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

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.

66. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
67. def nonEmpty[A](fa: F[A])
Definition Classes
FoldableUnorderedFoldable
68. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native() @IntrinsicCandidate()
69. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native() @IntrinsicCandidate()
70. 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()
71. 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()
72. 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
73. 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()
74. def productAll[A](fa: F[A])(implicit A: Numeric[A]): A
Definition Classes
Foldable
75. def reduceLeftOption[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]

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

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

returns

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

Definition Classes
Foldable

reduceRightOption for a right-associative alternative.

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

```scala> import cats.implicits._
scala> val l = List(6, 3, 2)
This is equivalent to (6 - 3) - 2
scala> Foldable[List].reduceLeftOption(l)(_ - _)
res0: Option[Int] = Some(1)

scala> Foldable[List].reduceLeftOption(List.empty[Int])(_ - _)
res1: Option[Int] = None```
76. def reduceLeftToOption[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B, A) ⇒ B): Option[B]
Definition Classes
Foldable
77. def reduceRightOption[A](fa: F[A])(f: (A, Eval[A]) ⇒ Eval[A]): Eval[Option[A]]

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

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

returns

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

Definition Classes
Foldable

reduceLeftOption for a left-associative alternative

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

```scala> import cats.implicits._
scala> val l = List(6, 3, 2)
This is equivalent to 6 - (3 - 2)
scala> Foldable[List].reduceRightOption(l)((current, rest) => rest.map(current - _)).value
res0: Option[Int] = Some(5)

scala> Foldable[List].reduceRightOption(List.empty[Int])((current, rest) => rest.map(current - _)).value
res1: Option[Int] = None```
78. def reduceRightToOption[A, B](fa: F[A])(f: (A) ⇒ B)(g: (A, Eval[B]) ⇒ Eval[B]): Eval[Option[B]]
Definition Classes
Foldable
79. 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```
80. 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
81. 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
82. def sliding10[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A)]

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

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

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

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

Definition Classes
FoldableNFunctions
87. 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
88. 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
89. 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
90. 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
91. 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
92. def sliding2[A](fa: F[A]): List[(A, A)]

Definition Classes
FoldableNFunctions
93. 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
94. 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
95. 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
96. def sliding3[A](fa: F[A]): List[(A, A, A)]

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

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

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

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

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

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

Definition Classes
FoldableNFunctions
103. def sumAll[A](fa: F[A])(implicit A: Numeric[A]): A
Definition Classes
Foldable
104. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
105. 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
106. 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
107. 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
108. def toString(): String
Definition Classes
AnyRef → Any
109. 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))```
110. 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.

111. 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
112. 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
113. 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
114. def unorderedFold[A](fa: F[A])(implicit arg0: CommutativeMonoid[A]): A
Definition Classes
FoldableUnorderedFoldable
115. def unorderedFoldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: CommutativeMonoid[B]): B
Definition Classes
FoldableUnorderedFoldable
116. def unorderedSequence[G[_], A](fga: F[G[A]])(implicit arg0: CommutativeApplicative[G]): G[F[A]]
Definition Classes
TraverseUnorderedTraverse
117. def unorderedTraverse[G[_], A, B](sa: F[A])(f: (A) ⇒ G[B])(implicit arg0: CommutativeApplicative[G]): G[F[B]]
Definition Classes
TraverseUnorderedTraverse
118. 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()
119. 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
120. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
121. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
122. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
123. 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
124. 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`.

Deprecated Value Members

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

foldable arity

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

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

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

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