IsomorphismTraverse

implicit abstract def G: Traverse[G]

abstract def iso: Isomorphism.<~>[F, G]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

Whether all As in fa yield true from p.

def allM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

all with monadic traversal.

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

Whether any As in fa yield true from p.

def anyM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

any with monadic traversal.

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

Alias for map.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collapse[X[_], A](x: F[A])(implicit F: Foldable[F], A: ApplicativePlus[X]): X[A]

def collapse2[G[_], X[_], A](x: F[G[A]])(implicit F: Foldable[F], G: Foldable[G], A: ApplicativePlus[X]): X[A]

def collapse3[G[_], H[_], X[_], A](x: F[G[H[A]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], A: ApplicativePlus[X]): X[A]

def collapse4[G[_], H[_], I[_], X[_], A](x: F[G[H[I[A]]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], I: Foldable[I], A: ApplicativePlus[X]): X[A]

def collapse5[G[_], H[_], I[_], J[_], X[_], A](x: F[G[H[I[J[A]]]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], I: Foldable[I], J: Foldable[J], A: ApplicativePlus[X]): X[A]

def collapse6[G[_], H[_], I[_], J[_], K[_], X[_], A](x: F[G[H[I[J[K[A]]]]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], I: Foldable[I], J: Foldable[J], K: Foldable[K], A: ApplicativePlus[X]): X[A]

def collapse7[G[_], H[_], I[_], J[_], K[_], L[_], X[_], A](x: F[G[H[I[J[K[L[A]]]]]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], I: Foldable[I], J: Foldable[J], K: Foldable[K], L: Foldable[L], A: ApplicativePlus[X]): X[A]

def compose[G[_]](implicit G0: Traverse[G]): Traverse[[α]F[G[α]]]

The composition of Traverses F and G, [x]F[G[x]], is a Traverse

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

The composition of Foldables F and G, [x]F[G[x]], is a Foldable

def compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[G[α]]]

The composition of Functors F and G, [x]F[G[x]], is a Functor

def count[A](fa: F[A]): Int

Deforested alias for toStream(fa).size.

def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]

def element[A](fa: F[A], a: A)(implicit arg0: Equal[A]): Boolean

Whether a is an element of fa.

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

Deforested alias for toStream(fa).isEmpty.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def fold[M](t: F[M])(implicit arg0: Monoid[M]): M

Combine the elements of a structure using a monoid.

def foldLShape[A, B](fa: F[A], z: B)(f: (B, A) ⇒ B): (B, F[Unit])

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

Left-associative fold of a structure.

def foldLeftM[G[_], A, B](fa: F[A], z: B)(f: (B, A) ⇒ G[B])(implicit M: Monad[G]): G[B]

Left-associative, monadic fold of a structure.

def foldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Monoid[B]): B

Map each element of the structure to a scalaz.Monoid, and combine the results.

def foldMapIdentity[A, B](fa: F[A])(implicit F: Monoid[A]): A

Unbiased sum of monoidal values.

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

Right-associative fold of a structure.

def foldRightM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

Right-associative, monadic fold of a structure.

val foldableSyntax: FoldableSyntax[F]

final def foldl[A, B](fa: F[A], z: B)(f: (B) ⇒ (A) ⇒ B): B

Curred version of foldLeft

final def foldlM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (B) ⇒ (A) ⇒ G[B])(implicit M: Monad[G]): G[B]

Curried version of foldLeftM

final def foldr[A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ B): B

Curried version of foldRight

final def foldrM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

Curried version of foldRightM

def fpair[A](fa: F[A]): F[(A, A)]

Twin all As in fa.

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

Pair all As in fa with the result of function application.

def functorLaw: FunctorLaw

val functorSyntax: FunctorSyntax[F]

final def getClass(): Class[_]

def hashCode(): Int

def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A

Insert an A between every A, yielding the sum.

final def isInstanceOf[T0]: Boolean

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

Lift f into F.

def longDigits[A](fa: F[A])(implicit d: <:<[A, Digit]): Long

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

Lift f into F and apply to F[A].

def mapAccumL[S, A, B](fa: F[A], z: S)(f: (S, A) ⇒ (S, B)): (S, F[B])

def mapAccumR[S, A, B](fa: F[A], z: S)(f: (S, A) ⇒ (S, B)): (S, F[B])

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

Lift apply(a), and apply the result to f.

def maximum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

The greatest element of fa, or None if fa is empty.

def minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

The smallest element of fa, or None if fa is empty.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def product[G[_]](implicit G0: Traverse[G]): Traverse[[α](F[α], G[α])]

The product of Traverses F and G, [x](F[x], G[x]]), is a Traverse

def product[G[_]](implicit G0: Foldable[G]): Foldable[[α](F[α], G[α])]

The product of Foldables F and G, [x](F[x], G[x]]), is a Foldable

def product[G[_]](implicit G0: Functor[G]): Functor[[α](F[α], G[α])]

The product of Functors F and G, [x](F[x], G[x]]), is a Functor

def reverse[A](fa: F[A]): F[A]

def runTraverseS[S, A, B](fa: F[A], s: S)(f: (A) ⇒ State[S, B]): (S, F[B])

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

Selects groups of elements that satisfy p and discards others.

def sequence[G[_], A](fga: F[G[A]])(implicit arg0: Applicative[G]): G[F[A]]

Traverse with the identity function.

def sequenceS[S, A](fga: F[State[S, A]]): State[S, F[A]]

Traverse with State.

def sequenceS_[S, A](fga: F[State[S, A]]): State[S, Unit]

sequence_ specialized to State *

final def sequenceU[A](self: F[A])(implicit G: Unapply[Applicative, A]): M[F[A]]

A version of sequence that infers the nested type constructor.

def sequence_[M[_], A, B](fa: F[M[A]])(implicit a: Applicative[M]): M[Unit]

Strict sequencing in an applicative functor M that ignores the value in fa.

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

Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.

def strengthL[A, B](a: A, f: F[B]): F[(A, B)]

Inject a to the left of Bs in f.

def strengthR[A, B](f: F[A], b: B): F[(A, B)]

Inject b to the right of As in f.

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

def toIndexedSeq[A](fa: F[A]): IndexedSeq[A]

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

def toSet[A](fa: F[A]): Set[A]

def toStream[A](fa: F[A]): Stream[A]

def toString(): String

def traversal[G[_]](implicit arg0: Applicative[G]): Traversal[G]

def traversalS[S]: Traversal[[x]IndexedStateT[[+X]X, S, S, x]]

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

def traverseImpl[H[_], A, B](fa: F[A])(f: (A) ⇒ H[B])(implicit arg0: Applicative[H]): H[F[B]]

Transform fa using f, collecting all the Gs with ap.

def traverseKTrampoline[S, G[+_], A, B](fa: F[A])(f: (A) ⇒ Kleisli[G, S, B])(implicit arg0: Applicative[G]): Kleisli[G, S, F[B]]

Traverse fa with a Kleisli[G, S, B], internally using a Trampoline to avoid stack overflow.

def traverseLaw: TraverseLaw

def traverseS[S, A, B](fa: F[A])(f: (A) ⇒ State[S, B]): State[S, F[B]]

Traverse with State.

def traverseSTrampoline[S, G[+_], A, B](fa: F[A])(f: (A) ⇒ State[S, G[B]])(implicit arg0: Applicative[G]): State[S, G[F[B]]]

Traverse fa with a State[S, G[B]], internally using a Trampoline to avoid stack overflow.

def traverseS_[S, A, B](fa: F[A])(f: (A) ⇒ State[S, B]): State[S, Unit]

traverse_ specialized to State *

val traverseSyntax: TraverseSyntax[F]

final def traverseU[A, GB](self: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[F[A]]

A version of traverse that infers the type constructor G.

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

Strict traversal in an applicative functor M that ignores the result of f.

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

Empty fa of meaningful pure values, preserving its structure.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zipL[A, B](fa: F[A], fb: F[B]): F[(A, Option[B])]

def zipR[A, B](fa: F[A], fb: F[B]): F[(Option[A], B)]

def zipWith[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) ⇒ C): (List[B], F[C])

def zipWithL[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) ⇒ C): F[C]

def zipWithR[A, B, C](fa: F[A], fb: F[B])(f: (Option[A], B) ⇒ C): F[C]