model/clue.data/Input/InputCats

InputCats

object InputCats extends Monad[Input] with Traverse[Input] with Align[Input]
trait Align[Input]
trait Monad[Input]
trait FlatMap[Input]
trait Apply[Input]
trait Functor[Input]
trait Serializable
class Object
trait Matchable
class Any

Value members

Concrete methods

override def align[A, B](fa: Input[A], fb: Input[B]): Input[Ior[A, B]]
Definition Classes
override def alignWith[A, B, C](fa: Input[A], fb: Input[B])(f: Ior[A, B] => C): Input[C]
Definition Classes
override def flatMap[A, B](fa: Input[A])(f: A => Input[B]): Input[B]
Definition Classes
override def foldLeft[A, B](fa: Input[A], b: B)(f: (B, A) => B): B
Definition Classes
override def foldRight[A, B](fa: Input[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B]
Definition Classes
override def functor: Functor[Input]
Definition Classes
override def pure[A](a: A): Input[A]
Definition Classes
override def tailRecM[A, B](a: A)(f: A => Input[Either[A, B]]): Input[B]
Definition Classes
override def traverse[F[_], A, B](fa: Input[A])(f: A => F[B])(implicit F: Applicative[F]): F[Input[B]]
Definition Classes

Inherited methods

final def *>[A, B](fa: Input[A])(fb: Input[B]): Input[B]

Alias for productR.

Alias for productR.

Inherited from:
Apply
final def <*[A, B](fa: Input[A])(fb: Input[B]): Input[A]

Alias for productL.

Alias for productL.

Inherited from:
Apply
final def <*>[A, B](ff: Input[A => B])(fa: Input[A]): Input[B]

Alias for ap.

Alias for ap.

Inherited from:
Apply
def alignCombine[A : Semigroup](fa1: Input[A], fa2: Input[A]): Input[A]

Align two structures with the same element, combining results according to their semigroup instances.

Align two structures with the same element, combining results according to their semigroup instances.

Example:

scala> import cats.implicits._
scala> Align[List].alignCombine(List(1, 2), List(10, 11, 12))
res0: List[Int] = List(11, 13, 12)
Inherited from:
Align
def alignMergeWith[A](fa1: Input[A], fa2: Input[A])(f: (A, A) => A): Input[A]

Align two structures with the same element, combining results according to the given function.

Align two structures with the same element, combining results according to the given function.

Example:

scala> import cats.implicits._
scala> Align[List].alignMergeWith(List(1, 2), List(10, 11, 12))(_ + _)
res0: List[Int] = List(11, 13, 12)
Inherited from:
Align
override def ap[A, B](ff: Input[A => B])(fa: Input[A]): Input[B]
Definition Classes
Inherited from:
FlatMap
def ap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18]): Input[Z]
Inherited from:
ApplyArityFunctions
override def ap2[A, B, Z](ff: Input[(A, B) => Z])(fa: Input[A], fb: Input[B]): Input[Z]
Definition Classes
Inherited from:
FlatMap
def ap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19], f20: Input[A20]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19], f20: Input[A20], f21: Input[A21]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap3[A0, A1, A2, Z](f: Input[(A0, A1, A2) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap4[A0, A1, A2, A3, Z](f: Input[(A0, A1, A2, A3) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap5[A0, A1, A2, A3, A4, Z](f: Input[(A0, A1, A2, A3, A4) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap6[A0, A1, A2, A3, A4, A5, Z](f: Input[(A0, A1, A2, A3, A4, A5) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap7[A0, A1, A2, A3, A4, A5, A6, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7]): Input[Z]
Inherited from:
ApplyArityFunctions
def ap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f: Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z])(f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8]): Input[Z]
Inherited from:
ApplyArityFunctions
def as[A, B](fa: Input[A], b: B): Input[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)
Inherited from:
Functor
def collectFirst[A, B](fa: Input[A])(pf: PartialFunction[A, B]): Option[B]
Inherited from:
Foldable
def collectFirstSome[A, B](fa: Input[A])(f: A => Option[B]): Option[B]

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

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

scala> import cats.implicits._
scala> val keys = List(1, 2, 4, 5)
scala> val map = Map(4 -> "Four", 5 -> "Five")
scala> keys.collectFirstSome(map.get)
res0: Option[String] = Some(Four)
scala> val map2 = Map(6 -> "Six", 7 -> "Seven")
scala> keys.collectFirstSome(map2.get)
res1: Option[String] = None
Inherited from:
Foldable
def collectFirstSomeM[G[_], A, B](fa: Input[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))
Inherited from:
Foldable
def collectFold[A, B](fa: Input[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
Inherited from:
Foldable
def collectFoldSome[A, B](fa: Input[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
Inherited from:
Foldable
def combineAll[A : Monoid](fa: Input[A]): A

Alias for fold.

Alias for fold.

Inherited from:
Foldable
def combineAllOption[A](fa: Input[A])(implicit ev: Semigroup[A]): Option[A]
Inherited from:
Foldable
def compose[G[_] : Traverse]: Traverse[[α] =>> Input[G[α]]]
Inherited from:
Traverse
def compose[G[_] : Foldable]: Foldable[[α] =>> Input[G[α]]]
Inherited from:
Foldable
def compose[G[_] : Functor]: Functor[[α] =>> Input[G[α]]]
Inherited from:
Functor
def compose[G[_] : Invariant]: Invariant[[α] =>> Input[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)
Inherited from:
Invariant
def compose[G[_] : Applicative]: Applicative[[α] =>> Input[G[α]]]

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Compose an Applicative[F] and an Applicative[G] into an Applicative[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Applicative[List].compose[Option]

scala> alo.pure(3)
res0: List[Option[Int]] = List(Some(3))

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from:
Applicative
def compose[G[_] : Apply]: Apply[[α] =>> Input[G[α]]]

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Compose an Apply[F] and an Apply[G] into an Apply[λ[α => F[G[α]]]].

Example:

scala> import cats.implicits._

scala> val alo = Apply[List].compose[Option]

scala> alo.product(List(None, Some(true), Some(false)), List(Some(2), None))
res1: List[Option[(Boolean, Int)]] = List(None, None, Some((true,2)), None, Some((false,2)), None)
Inherited from:
Apply
def composeApply[G[_] : Apply]: InvariantSemigroupal[[α] =>> Input[G[α]]]
Inherited from:
InvariantSemigroupal
override def composeContravariant[G[_] : Contravariant]: Contravariant[[α] =>> Input[G[α]]]
Definition Classes
Inherited from:
Functor
def composeContravariantMonoidal[G[_] : ContravariantMonoidal]: ContravariantMonoidal[[α] =>> Input[G[α]]]

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Compose an Applicative[F] and a ContravariantMonoidal[G] into a ContravariantMonoidal[λ[α => F[G[α]]]].

Example:

scala> import cats.kernel.Comparison
scala> import cats.implicits._

// compares strings by alphabetical order
scala> val alpha: Order[String] = Order[String]

// compares strings by their length
scala> val strLength: Order[String] = Order.by[String, Int](_.length)

scala> val stringOrders: List[Order[String]] = List(alpha, strLength)

// first comparison is with alpha order, second is with string length
scala> stringOrders.map(o => o.comparison("abc", "de"))
res0: List[Comparison] = List(LessThan, GreaterThan)

scala> val le = Applicative[List].composeContravariantMonoidal[Order]

// create Int orders that convert ints to strings and then use the string orders
scala> val intOrders: List[Order[Int]] = le.contramap(stringOrders)(_.toString)

// first comparison is with alpha order, second is with string length
scala> intOrders.map(o => o.comparison(12, 3))
res1: List[Comparison] = List(LessThan, GreaterThan)

// create the `product` of the string order list and the int order list
// `p` contains a list of the following orders:
// 1. (alpha comparison on strings followed by alpha comparison on ints)
// 2. (alpha comparison on strings followed by length comparison on ints)
// 3. (length comparison on strings followed by alpha comparison on ints)
// 4. (length comparison on strings followed by length comparison on ints)
scala> val p: List[Order[(String, Int)]] = le.product(stringOrders, intOrders)

scala> p.map(o => o.comparison(("abc", 12), ("def", 3)))
res2: List[Comparison] = List(LessThan, LessThan, LessThan, GreaterThan)
Inherited from:
Applicative
def composeFunctor[G[_] : Functor]: Invariant[[α] =>> Input[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)
Inherited from:
Invariant
def contains_[A](fa: Input[A], v: A)(implicit ev: Eq[A]): Boolean

Tests if fa contains v using the Eq instance for A

Tests if fa contains v using the Eq instance for A

Inherited from:
UnorderedFoldable
def count[A](fa: Input[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
Inherited from:
UnorderedFoldable
def dropWhile_[A](fa: Input[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.

Inherited from:
Foldable
override def exists[A](fa: Input[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
Inherited from:
Foldable
def existsM[G[_], A](fa: Input[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
Inherited from:
Foldable
def filter_[A](fa: Input[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.

Inherited from:
Foldable
def find[A](fa: Input[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.

Inherited from:
Foldable
def findM[G[_], A](fa: Input[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)
Inherited from:
Foldable
def flatMap10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap2[A0, A1, Z](f0: Input[A0], f1: Input[A1])(f: (A0, A1) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19], f20: Input[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19], f20: Input[A20], f21: Input[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap3[A0, A1, A2, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2])(f: (A0, A1, A2) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap4[A0, A1, A2, A3, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3])(f: (A0, A1, A2, A3) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap5[A0, A1, A2, A3, A4, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4])(f: (A0, A1, A2, A3, A4) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap6[A0, A1, A2, A3, A4, A5, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5])(f: (A0, A1, A2, A3, A4, A5) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap7[A0, A1, A2, A3, A4, A5, A6, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatMap9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Input[Z]): Input[Z]
Inherited from:
FlatMapArityFunctions
def flatSequence[G[_], A](fgfa: Input[G[Input[A]]])(implicit G: Applicative[G], F: FlatMap[Input]): G[Input[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
Inherited from:
Traverse
def flatTap[A, B](fa: Input[A])(f: A => Input[B]): Input[A]

Apply a monadic function and discard the result while keeping the effect.

Apply a monadic function and discard the result while keeping the effect.

scala> import cats._, implicits._
scala> Option(1).flatTap(_ => None)
res0: Option[Int] = None
scala> Option(1).flatTap(_ => Some("123"))
res1: Option[Int] = Some(1)
scala> def nCats(n: Int) = List.fill(n)("cat")
nCats: (n: Int)List[String]
scala> List[Int](0).flatTap(nCats)
res2: List[Int] = List()
scala> List[Int](4).flatTap(nCats)
res3: List[Int] = List(4, 4, 4, 4)
Inherited from:
FlatMap
def flatTraverse[G[_], A, B](fa: Input[A])(f: A => G[Input[B]])(implicit G: Applicative[G], F: FlatMap[Input]): G[Input[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))
Inherited from:
Traverse
def flatten[A](ffa: Input[Input[A]]): Input[A]

"flatten" a nested F of F structure into a single-layer F structure.

"flatten" a nested F of F structure into a single-layer F structure.

This is also commonly called join.

Example:

scala> import cats.Eval
scala> import cats.implicits._

scala> val nested: Eval[Eval[Int]] = Eval.now(Eval.now(3))
scala> val flattened: Eval[Int] = nested.flatten
scala> flattened.value
res0: Int = 3
Inherited from:
FlatMap
final def fmap[A, B](fa: Input[A])(f: A => B): Input[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!)
Inherited from:
Functor
def fold[A](fa: Input[A])(implicit A: Monoid[A]): A

Fold implemented using the given Monoid[A] instance.

Fold implemented using the given Monoid[A] instance.

Inherited from:
Foldable
def foldA[G[_], A](fga: Input[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)
Inherited from:
Foldable
def foldK[G[_], A](fga: Input[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)
Inherited from:
Foldable
final def foldLeftM[G[_], A, B](fa: Input[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]

Alias for foldM.

Alias for foldM.

Inherited from:
Foldable
def foldM[G[_], A, B](fa: Input[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.

Inherited from:
Foldable
def foldMap[A, B](fa: Input[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.

Inherited from:
Foldable
def foldMapA[G[_], A, B](fa: Input[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]. combining the B values using the given Monoid[B] instance.

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
Inherited from:
Foldable
def foldMapK[G[_], A, B](fa: Input[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"
Inherited from:
Foldable
def foldMapM[G[_], A, B](fa: Input[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
Inherited from:
Foldable
def foldRightDefer[G[_] : Defer, A, B](fa: Input[A], gb: G[B])(fn: (A, G[B]) => G[B]): G[B]
Inherited from:
Foldable
override def forall[A](fa: Input[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
Inherited from:
Foldable
def forallM[G[_], A](fa: Input[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
Inherited from:
Foldable
def foreverM[A, B](fa: Input[A]): Input[B]

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

Like an infinite loop of >> calls. This is most useful effect loops that you want to run forever in for instance a server.

This will be an infinite loop, or it will return an F[Nothing].

Be careful using this. For instance, a List of length k will produce a list of length k^n at iteration n. This means if k = 0, we return an empty list, if k = 1, we loop forever allocating single element lists, but if we have a k > 1, we will allocate exponentially increasing memory and very quickly OOM.

Inherited from:
FlatMap
def fproduct[A, B](fa: Input[A])(f: A => B): Input[(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))
Inherited from:
Functor
def fproductLeft[A, B](fa: Input[A])(f: A => B): Input[(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))
Inherited from:
Functor
def get[A](fa: Input[A])(idx: Long): Option[A]

Get the element at the index of the Foldable.

Get the element at the index of the Foldable.

Inherited from:
Foldable
def ifElseM[A](branches: (Input[Boolean], Input[A])*)(els: Input[A]): Input[A]

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

Simulates an if/else-if/else in the context of an F. It evaluates conditions until one evaluates to true, and returns the associated F[A]. If no condition is true, returns els.

scala> import cats._
scala> Monad[Eval].ifElseM(Eval.later(false) -> Eval.later(1), Eval.later(true) -> Eval.later(2))(Eval.later(5)).value
res0: Int = 2

Based on a gist by Daniel Spiewak with a stack-safe implementation due to P. Oscar Boykin

See also:
Inherited from:
Monad
def ifF[A](fb: Input[Boolean])(ifTrue: => A, ifFalse: => A): Input[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)
Inherited from:
Functor
def ifM[B](fa: Input[Boolean])(ifTrue: => Input[B], ifFalse: => Input[B]): Input[B]

if lifted into monad.

if lifted into monad.

Inherited from:
FlatMap
override def imap[A, B](fa: Input[A])(f: A => B)(g: B => A): Input[B]
Definition Classes
Inherited from:
Functor
def intercalate[A](fa: Input[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
Inherited from:
Foldable
override def isEmpty[A](fa: Input[A]): Boolean

Returns true if there are no elements. Otherwise false.

Returns true if there are no elements. Otherwise false.

Definition Classes
Inherited from:
Foldable
def iterateForeverM[A, B](a: A)(f: A => Input[A]): Input[B]

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

iterateForeverM is almost exclusively useful for effect types. For instance, A may be some state, we may take the current state, run some effect to get a new state and repeat.

Inherited from:
FlatMap
def iterateUntil[A](f: Input[A])(p: A => Boolean): Input[A]

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Inherited from:
Monad
def iterateUntilM[A](init: A)(f: A => Input[A])(p: A => Boolean): Input[A]

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Apply a monadic function iteratively until its result satisfies the given predicate and return that result.

Inherited from:
Monad
def iterateWhile[A](f: Input[A])(p: A => Boolean): Input[A]

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Inherited from:
Monad
def iterateWhileM[A](init: A)(f: A => Input[A])(p: A => Boolean): Input[A]

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Apply a monadic function iteratively until its result fails to satisfy the given predicate and return that result.

Inherited from:
Monad
def lift[A, B](f: A => B): Input[A] => Input[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)
Inherited from:
Functor
override def map[A, B](fa: Input[A])(f: A => B): Input[B]
Definition Classes
Inherited from:
Traverse
def map10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
override def map2[A, B, Z](fa: Input[A], fb: Input[B])(f: (A, B) => Z): Input[Z]
Definition Classes
Inherited from:
FlatMap
def map20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19], f20: Input[A20])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19], f20: Input[A20], f21: Input[A21])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
override def map2Eval[A, B, Z](fa: Input[A], fb: Eval[Input[B]])(f: (A, B) => Z): Eval[Input[Z]]
Definition Classes
Inherited from:
FlatMap
def map3[A0, A1, A2, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2])(f: (A0, A1, A2) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map4[A0, A1, A2, A3, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3])(f: (A0, A1, A2, A3) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map5[A0, A1, A2, A3, A4, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4])(f: (A0, A1, A2, A3, A4) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map6[A0, A1, A2, A3, A4, A5, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5])(f: (A0, A1, A2, A3, A4, A5) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map7[A0, A1, A2, A3, A4, A5, A6, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6])(f: (A0, A1, A2, A3, A4, A5, A6) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map8[A0, A1, A2, A3, A4, A5, A6, A7, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7])(f: (A0, A1, A2, A3, A4, A5, A6, A7) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def map9[A0, A1, A2, A3, A4, A5, A6, A7, A8, Z](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8])(f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) => Z): Input[Z]
Inherited from:
ApplyArityFunctions
def mapAccumulate[S, A, B](init: S, fa: Input[A])(f: (S, A) => (S, B)): (S, Input[B])

Akin to map, but allows to keep track of a state value when calling the function.

Akin to map, but allows to keep track of a state value when calling the function.

Inherited from:
Traverse
def mapWithIndex[A, B](fa: Input[A])(f: (A, Int) => B): Input[B]

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

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

Inherited from:
Traverse
def maximumByList[A, B : Order](fa: Input[A])(f: A => B): List[A]

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.

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.

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.

Inherited from:
Foldable
def maximumByOption[A, B : Order](fa: Input[A])(f: A => 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.

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.

Inherited from:
Foldable
def maximumList[A](fa: Input[A])(implicit A: Order[A]): List[A]

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

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

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.

Inherited from:
Foldable
def maximumOption[A](fa: Input[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.

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.

Inherited from:
Foldable
def minimumByList[A, B : Order](fa: Input[A])(f: A => B): List[A]

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.

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.

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.

Inherited from:
Foldable
def minimumByOption[A, B : Order](fa: Input[A])(f: A => 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.

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.

Inherited from:
Foldable
def minimumList[A](fa: Input[A])(implicit A: Order[A]): List[A]

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

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

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.

Inherited from:
Foldable
def minimumOption[A](fa: Input[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.

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.

Inherited from:
Foldable
def mproduct[A, B](fa: Input[A])(f: A => Input[B]): Input[(A, B)]

Pair A with the result of function application.

Pair A with the result of function application.

Example:

scala> import cats.implicits._
scala> List("12", "34", "56").mproduct(_.toList)
res0: List[(String, Char)] = List((12,1), (12,2), (34,3), (34,4), (56,5), (56,6))
Inherited from:
FlatMap
override def nonEmpty[A](fa: Input[A]): Boolean
Definition Classes
Inherited from:
Foldable
def padZip[A, B](fa: Input[A], fb: Input[B]): Input[(Option[A], Option[B])]

Same as align, but forgets from the type that one of the two elements must be present.

Same as align, but forgets from the type that one of the two elements must be present.

Example:

scala> import cats.implicits._
scala> Align[List].padZip(List(1, 2), List(10))
res0: List[(Option[Int], Option[Int])] = List((Some(1),Some(10)), (Some(2),None))
Inherited from:
Align
def padZipWith[A, B, C](fa: Input[A], fb: Input[B])(f: (Option[A], Option[B]) => C): Input[C]

Same as alignWith, but forgets from the type that one of the two elements must be present.

Same as alignWith, but forgets from the type that one of the two elements must be present.

Example:

scala> import cats.implicits._
scala> Align[List].padZipWith(List(1, 2), List(10, 11, 12))(_ |+| _)
res0: List[Option[Int]] = List(Some(11), Some(13), Some(12))
Inherited from:
Align
def partitionBifold[H[_, _], A, B, C](fa: Input[A])(f: A => H[B, C])(implicit A: Alternative[Input], H: Bifoldable[H]): (Input[B], Input[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())
Inherited from:
Foldable
def partitionBifoldM[G[_], H[_, _], A, B, C](fa: Input[A])(f: A => G[H[B, C]])(implicit A: Alternative[Input], M: Monad[G], H: Bifoldable[H]): G[(Input[B], Input[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()))
Inherited from:
Foldable
def partitionEither[A, B, C](fa: Input[A])(f: A => Either[B, C])(implicit A: Alternative[Input]): (Input[B], Input[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))
Inherited from:
Foldable
def partitionEitherM[G[_], A, B, C](fa: Input[A])(f: A => G[Either[B, C]])(implicit A: Alternative[Input], M: Monad[G]): G[(Input[B], Input[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))
Inherited from:
Foldable
def point[A](a: A): Input[A]

point lifts any value into a Monoidal Functor.

point lifts any value into a Monoidal Functor.

Example:

scala> import cats.implicits._

scala> InvariantMonoidal[Option].point(10)
res0: Option[Int] = Some(10)
Inherited from:
InvariantMonoidal
override def product[A, B](fa: Input[A], fb: Input[B]): Input[(A, B)]
Definition Classes
Inherited from:
FlatMap
def productAll[A](fa: Input[A])(implicit A: Numeric[A]): A
Inherited from:
Foldable
override def productL[A, B](fa: Input[A])(fb: Input[B]): Input[A]
Definition Classes
Inherited from:
FlatMap
def productLEval[A, B](fa: Input[A])(fb: Eval[Input[B]]): Input[A]

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the second. This variant of productL also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> var count = 0
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[Unit] = Some(count += 1)
scala> fa.productLEval(Eval.later(fb))
res0: Option[Int] = Some(3)
scala> assert(count == 1)
scala> none[Int].productLEval(Eval.later(fb))
res1: Option[Int] = None
scala> assert(count == 1)
Inherited from:
FlatMap
override def productR[A, B](fa: Input[A])(fb: Input[B]): Input[B]
Definition Classes
Inherited from:
FlatMap
def productREval[A, B](fa: Input[A])(fb: Eval[Input[B]]): Input[B]

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

Sequentially compose two actions, discarding any value produced by the first. This variant of productR also lets you define the evaluation strategy of the second action. For instance you can evaluate it only ''after'' the first action has finished:

scala> import cats.Eval
scala> import cats.implicits._
scala> val fa: Option[Int] = Some(3)
scala> def fb: Option[String] = Some("foo")
scala> fa.productREval(Eval.later(fb))
res0: Option[String] = Some(foo)
Inherited from:
FlatMap
def reduceLeftOption[A](fa: Input[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.

See also:

reduceRightOption for a right-associative alternative.

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

scala> import cats.implicits._
scala> val l = List(6, 3, 2)
This is equivalent to (6 - 3) - 2
scala> Foldable[List].reduceLeftOption(l)(_ - _)
res0: Option[Int] = Some(1)
scala> Foldable[List].reduceLeftOption(List.empty[Int])(_ - _)
res1: Option[Int] = None
Inherited from:
Foldable
def reduceLeftToOption[A, B](fa: Input[A])(f: A => B)(g: (B, A) => B): Option[B]
Inherited from:
Foldable
def reduceRightOption[A](fa: Input[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.

See also:

reduceLeftOption for a left-associative alternative

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

scala> import cats.implicits._
scala> val l = List(6, 3, 2)
This is equivalent to 6 - (3 - 2)
scala> Foldable[List].reduceRightOption(l)((current, rest) => rest.map(current - _)).value
res0: Option[Int] = Some(5)
scala> Foldable[List].reduceRightOption(List.empty[Int])((current, rest) => rest.map(current - _)).value
res1: Option[Int] = None
Inherited from:
Foldable
def reduceRightToOption[A, B](fa: Input[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[Option[B]]
Inherited from:
Foldable
def replicateA[A](n: Int, fa: Input[A]): Input[List[A]]

Given fa and n, apply fa n times to construct an F[List[A]] value.

Given fa and n, apply fa n times to construct an F[List[A]] value.

Example:

scala> import cats.data.State

scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[List[Int]] =
    | Applicative[Counter].replicateA(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, List[Int]) = (5,List(0, 1, 2, 3, 4))
Inherited from:
Applicative
def replicateA_[A](n: Int, fa: Input[A]): Input[Unit]

Given fa and n, apply fa n times discarding results to return F[Unit].

Given fa and n, apply fa n times discarding results to return F[Unit].

Example:

scala> import cats.data.State

scala> type Counter[A] = State[Int, A]
scala> val getAndIncrement: Counter[Int] = State { i => (i + 1, i) }
scala> val getAndIncrement5: Counter[Unit] =
    | Applicative[Counter].replicateA_(5, getAndIncrement)
scala> getAndIncrement5.run(0).value
res0: (Int, Unit) = (5,())
Inherited from:
Applicative
def sequence[G[_] : Applicative, A](fga: Input[G[A]]): G[Input[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
Inherited from:
Traverse
def sequence_[G[_] : Applicative, A](fga: Input[G[A]]): 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
Inherited from:
Foldable
def size[A](fa: Input[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.

Inherited from:
UnorderedFoldable
def sliding10[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding11[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding12[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding13[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding14[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding15[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding16[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding17[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding18[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding19[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding2[A](fa: Input[A]): List[(A, A)]
Inherited from:
FoldableNFunctions
def sliding20[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding21[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding22[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding3[A](fa: Input[A]): List[(A, A, A)]
Inherited from:
FoldableNFunctions
def sliding4[A](fa: Input[A]): List[(A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding5[A](fa: Input[A]): List[(A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding6[A](fa: Input[A]): List[(A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding7[A](fa: Input[A]): List[(A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding8[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sliding9[A](fa: Input[A]): List[(A, A, A, A, A, A, A, A, A)]
Inherited from:
FoldableNFunctions
def sumAll[A](fa: Input[A])(implicit A: Numeric[A]): A
Inherited from:
Foldable
def takeWhile_[A](fa: Input[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.

Inherited from:
Foldable
def toIterable[A](fa: Input[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.

Inherited from:
Foldable
def toList[A](fa: Input[A]): List[A]

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

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

Inherited from:
Foldable
def traverseTap[G[_] : Applicative, A, B](fa: Input[A])(f: A => G[B]): G[Input[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))
Inherited from:
Traverse
def traverseWithIndexM[G[_], A, B](fa: Input[A])(f: (A, Int) => G[B])(implicit G: Monad[G]): G[Input[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.

Inherited from:
Traverse
def traverse_[G[_], A, B](fa: Input[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.

Inherited from:
Foldable
def tuple10[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)]
Inherited from:
ApplyArityFunctions
def tuple11[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]
Inherited from:
ApplyArityFunctions
def tuple12[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]
Inherited from:
ApplyArityFunctions
def tuple13[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]
Inherited from:
ApplyArityFunctions
def tuple14[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]
Inherited from:
ApplyArityFunctions
def tuple15[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]
Inherited from:
ApplyArityFunctions
def tuple16[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]
Inherited from:
ApplyArityFunctions
def tuple17[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]
Inherited from:
ApplyArityFunctions
def tuple18[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]
Inherited from:
ApplyArityFunctions
def tuple19[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]
Inherited from:
ApplyArityFunctions
def tuple2[A, B](f1: Input[A], f2: Input[B]): Input[(A, B)]
Inherited from:
ApplyArityFunctions
def tuple20[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]
Inherited from:
ApplyArityFunctions
def tuple21[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19], f20: Input[A20]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]
Inherited from:
ApplyArityFunctions
def tuple22[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8], f9: Input[A9], f10: Input[A10], f11: Input[A11], f12: Input[A12], f13: Input[A13], f14: Input[A14], f15: Input[A15], f16: Input[A16], f17: Input[A17], f18: Input[A18], f19: Input[A19], f20: Input[A20], f21: Input[A21]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]
Inherited from:
ApplyArityFunctions
def tuple3[A0, A1, A2](f0: Input[A0], f1: Input[A1], f2: Input[A2]): Input[(A0, A1, A2)]
Inherited from:
ApplyArityFunctions
def tuple4[A0, A1, A2, A3](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3]): Input[(A0, A1, A2, A3)]
Inherited from:
ApplyArityFunctions
def tuple5[A0, A1, A2, A3, A4](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4]): Input[(A0, A1, A2, A3, A4)]
Inherited from:
ApplyArityFunctions
def tuple6[A0, A1, A2, A3, A4, A5](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5]): Input[(A0, A1, A2, A3, A4, A5)]
Inherited from:
ApplyArityFunctions
def tuple7[A0, A1, A2, A3, A4, A5, A6](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6]): Input[(A0, A1, A2, A3, A4, A5, A6)]
Inherited from:
ApplyArityFunctions
def tuple8[A0, A1, A2, A3, A4, A5, A6, A7](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7]): Input[(A0, A1, A2, A3, A4, A5, A6, A7)]
Inherited from:
ApplyArityFunctions
def tuple9[A0, A1, A2, A3, A4, A5, A6, A7, A8](f0: Input[A0], f1: Input[A1], f2: Input[A2], f3: Input[A3], f4: Input[A4], f5: Input[A5], f6: Input[A6], f7: Input[A7], f8: Input[A8]): Input[(A0, A1, A2, A3, A4, A5, A6, A7, A8)]
Inherited from:
ApplyArityFunctions
def tupleLeft[A, B](fa: Input[A], b: B): Input[(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))
Inherited from:
Functor
def tupleRight[A, B](fa: Input[A], b: B): Input[(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))
Inherited from:
Functor
def unit: Input[Unit]

Returns an F[Unit] value, equivalent with pure(()).

Returns an F[Unit] value, equivalent with pure(()).

A useful shorthand, also allowing implementations to optimize the returned reference (e.g. it can be a val).

Example:

scala> import cats.implicits._

scala> Applicative[Option].unit
res0: Option[Unit] = Some(())
Inherited from:
Applicative
def unlessA[A](cond: Boolean)(f: => Input[A]): Input[Unit]

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is false, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].unlessA(true)(List(1, 2, 3))
res0: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List(1, 2, 3))
res1: List[Unit] = List((), (), ())

scala> Applicative[List].unlessA(true)(List.empty[Int])
res2: List[Unit] = List(())

scala> Applicative[List].unlessA(false)(List.empty[Int])
res3: List[Unit] = List()
Inherited from:
Applicative
override def unorderedFold[A : CommutativeMonoid](fa: Input[A]): A
Definition Classes
Inherited from:
Foldable
override def unorderedFoldMap[A, B : CommutativeMonoid](fa: Input[A])(f: A => B): B
Definition Classes
Inherited from:
Foldable
override def unorderedSequence[G[_] : CommutativeApplicative, A](fga: Input[G[A]]): G[Input[A]]
Definition Classes
Inherited from:
Traverse
override def unorderedTraverse[G[_] : CommutativeApplicative, A, B](sa: Input[A])(f: A => G[B]): G[Input[B]]
Definition Classes
Inherited from:
Traverse
def untilDefinedM[A](foa: Input[Option[A]]): Input[A]

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

This repeats an F until we get defined values. This can be useful for polling type operations on State (or RNG) Monads, or in effect monads.

Inherited from:
FlatMap
def untilM[G[_], A](f: Input[A])(cond: => Input[Boolean])(implicit G: Alternative[G]): Input[G[A]]

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Collects results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from:
Monad
def untilM_[A](f: Input[A])(cond: => Input[Boolean]): Input[Unit]

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Execute an action repeatedly until the Boolean condition returns true. The condition is evaluated after the loop body. Discards results.

Inherited from:
Monad
def unzip[A, B](fab: Input[(A, B)]): (Input[A], Input[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))
Inherited from:
Functor
def void[A](fa: Input[A]): Input[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((), (), ())
Inherited from:
Functor
def whenA[A](cond: Boolean)(f: => Input[A]): Input[Unit]

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Returns the given argument (mapped to Unit) if cond is true, otherwise, unit lifted into F.

Example:

scala> import cats.implicits._

scala> Applicative[List].whenA(true)(List(1, 2, 3))
res0: List[Unit] = List((), (), ())

scala> Applicative[List].whenA(false)(List(1, 2, 3))
res1: List[Unit] = List(())

scala> Applicative[List].whenA(true)(List.empty[Int])
res2: List[Unit] = List()

scala> Applicative[List].whenA(false)(List.empty[Int])
res3: List[Unit] = List(())
Inherited from:
Applicative
def whileM[G[_], A](p: Input[Boolean])(body: => Input[A])(implicit G: Alternative[G]): Input[G[A]]

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Collects the results into an arbitrary Alternative value, such as a Vector. This implementation uses append on each evaluation result, so avoid data structures with non-constant append performance, e.g. List.

Inherited from:
Monad
def whileM_[A](p: Input[Boolean])(body: => Input[A]): Input[Unit]

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Execute an action repeatedly as long as the given Boolean expression returns true. The condition is evaluated before the loop body. Discards results.

Inherited from:
Monad
def widen[A, B >: A](fa: Input[A]): Input[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)
Inherited from:
Functor
def zipAll[A, B](fa: Input[A], fb: Input[B], a: A, b: B): Input[(A, B)]

Pairs elements of two structures along the union of their shapes, using placeholders for missing values.

Pairs elements of two structures along the union of their shapes, using placeholders for missing values.

Example:

scala> import cats.implicits._
scala> Align[List].zipAll(List(1, 2), List(10, 11, 12), 20, 21)
res0: List[(Int, Int)] = List((1,10), (2,11), (20,12))
Inherited from:
Align
def zipWithIndex[A](fa: Input[A]): Input[(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.

Inherited from:
Traverse

Deprecated and Inherited methods

@deprecated("Dangerous method, use ifM (a flatMap) or ifF (a map) instead", "2.6.2")
def ifA[A](fcond: Input[Boolean])(ifTrue: Input[A], ifFalse: Input[A]): Input[A]
Deprecated
Inherited from:
Apply