Traverse

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

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

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

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.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def as[A, B](fa: F[A], b: B): F[B]

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

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def combineAll[A](fa: F[A])(implicit arg0: Monoid[A]): A

Alias for fold.

def compose[G[_]](implicit ev: Foldable[G]): Foldable[[α]F[G[α]]]

Compose this Foldable[F] with a Foldable[G] to create a Foldable[F[G]] instance.

def compose[G[_]](implicit GG: Functor[G]): Functor[[X]F[G[X]]]

Compose this functor F with a functor G to produce a composite Functor on G[F[_]], with a map method which uses an A => B to map a G[F[A]] to a G[F[B]].

def compose[G[_]](implicit arg0: Invariant[G], GG: Invariant[G]): Invariant[[X]F[G[X]]]

Compose 2 invariant Functors F and G to get a new Invariant Functor for F[G[_]].

def composeWithContravariant[G[_]](implicit GG: Contravariant[G]): Contravariant[[X]F[G[X]]]

Compose this functor F with a Contravariant Functor G to produce a new Contravariant Functor on F[G[_]].

def composeWithFunctor[G[_]](implicit arg0: Functor[G]): Functor[[X]F[G[X]]]

Compose the Invariant Functor F with a normal (Covariant) Functor to get a new Invariant Functor for [F[G[_]].

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.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

Check whether at least one element satisfies the predicate.

def filter_[A](fa: F[A])(p: (A) ⇒ Boolean): List[A]

Convert F[A] to a List[A], only including elements which match p.

def finalize(): Unit

def find[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]

Find the first element matching the predicate, if one exists.

def fold[A](fa: F[A])(implicit A: Monoid[A]): A

Fold implemented using the given Monoid[A] instance.

def foldK[G[_], A](fga: F[G[A]])(implicit G: MonoidK[G]): G[A]

Fold implemented using the given MonoidK[G] instance.

val F = Foldable[List]
F.foldK(List(1 :: 2 :: Nil, 3 :: 4 :: 5 :: Nil))
// List(1, 2, 3, 4, 5)

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.

def forall[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

Check whether all elements satisfy the predicate.

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

final def getClass(): Class[_]

def hashCode(): Int

def imap[A, B](fa: F[A])(f: (A) ⇒ B)(fi: (B) ⇒ A): F[B]

def isEmpty[A](fa: F[A]): Boolean

Returns true if there are no elements.

final def isInstanceOf[T0]: Boolean

def lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]

Lift a function f to operate on Functors

def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

final def ne(arg0: AnyRef): Boolean

def nonEmpty[A](fa: F[A]): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reduceLeftToOption[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B, A) ⇒ B): Option[B]

def reduceRightToOption[A, B](fa: F[A])(f: (A) ⇒ B)(g: (A, Eval[B]) ⇒ Eval[B]): Eval[Option[B]]

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

def sequenceU[GA](fga: F[GA])(implicit U: Unapply[Applicative, GA]): M[F[A]]

Behaves just like sequence, but uses Unapply to find the Applicative instance for G.

def sequence_[G[_], A, B](fga: F[G[A]])(implicit arg0: Applicative[G]): G[Unit]

Sequence F[G[A]] using Applicative[G].

val F = Foldable[List]
F.sequence_(List(Option(1), Option(2), Option(3))) // Some(())
F.sequence_(List(Option(1), None, Option(3)))      // None

final def synchronized[T0](arg0: ⇒ T0): T0

def toList[A](fa: F[A]): List[A]

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

def toStreaming[A](fa: F[A]): Streaming[A]

def toString(): String

def traverseU[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit U: Unapply[Applicative, GB]): M[F[A]]

Behaves just like traverse, but uses Unapply to find the Applicative instance for G.

def traverse_[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: Applicative[G]): G[Unit]

Traverse F[A] using Applicative[G].

def parseInt(s: String): Option[Int] = ...
val F = Foldable[List]
F.traverse_(List("333", "444"))(parseInt) // Some(())
F.traverse_(List("333", "zzz"))(parseInt) // None

def void[A](fa: F[A]): F[Unit]

Empty the fa of the values, preserving the structure

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit