IsomorphismTraverse1

implicit abstract def G: Traverse1[G]

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

final def !=(arg0: Any): Boolean

final def ##(): Int

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 bicompose[G[_, _]](implicit arg0: Bitraverse[G]): Bitraverse[[α, β]F[G[α, β]]]

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

def bicompose[G[_, _]](implicit arg0: Bifoldable[G]): Bifoldable[[α, β]F[G[α, β]]]

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

def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β]]]

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

def clone(): AnyRef

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

def compose[G[_]](implicit arg0: Traverse1[G]): Traverse1[[α]F[G[α]]]

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

def compose[G[_]](implicit arg0: Foldable1[G]): Foldable1[[α]F[G[α]]]

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

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

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

Alias for length.

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

def distinct[A](fa: F[A])(implicit A: Order[A]): IList[A]

O(n log n) complexity

def distinct1[A](fa: F[A])(implicit A: Order[A]): NonEmptyList[A]

O(n log n) complexity

def distinctE[A](fa: F[A])(implicit A: Equal[A]): IList[A]

O(n2) complexity

def distinctE1[A](fa: F[A])(implicit A: Equal[A]): NonEmptyList[A]

O(n2) complexity

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

Whether a is an element of fa.

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

always return false

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterLength[A](fa: F[A])(f: (A) ⇒ Boolean): Int

def finalize(): Unit

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

final def findMapM[M[_], A, B](fa: F[A])(f: (A) ⇒ M[Option[B]])(implicit arg0: Monad[M]): M[Option[B]]

map elements in a Foldable with a monadic function and return the first element that is mapped successfully

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

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

Combine the elements of a structure using a monoid.

def fold1[M](t: F[M])(implicit arg0: Semigroup[M]): M

def fold1Opt[A](fa: F[A])(implicit arg0: Semigroup[A]): Option[A]

Like fold but returning None if the foldable is empty and Some otherwise

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 foldLeft1[A](fa: F[A])(f: (A, A) ⇒ A): A

Left-associative fold of a structure.

def foldLeft1Opt[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]

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.

final def foldMap1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Semigroup[B]): B

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

def foldMap1Opt[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): Option[B]

As foldMap but returning None if the foldable is empty and Some otherwise

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

Left-associative fold of a structure.

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

def foldMapM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit B: Monoid[B], G: Monad[G]): G[B]

Specialization of foldRightM when B has a Monoid.

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

Right-associative fold of a structure.

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

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

Right-associative fold of a structure.

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

Right-associative fold of a structure.

def foldRight1Opt[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): Option[A]

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.

def foldable1Law: Foldable1Law

val foldable1Syntax: Foldable1Syntax[F]

def foldableLaw: FoldableLaw

val foldableSyntax: FoldableSyntax[F]

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

Curried version of foldLeft

final def foldl1[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): A

Curried foldLeft1.

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

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 foldr1[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): A

Curried foldRight1.

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

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 icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]F[G[α]]]

The composition of Functor F and Contravariant G, [x]F[G[x]], is contravariant.

def index[A](fa: F[A], i: Int): Option[A]

def indexOr[A](fa: F[A], default: ⇒ A, i: Int): A

def indexed[A](fa: F[A]): F[(Int, A)]

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

Insert an A between every A, yielding the sum.

def intercalate1[A](fa: F[A], a: A)(implicit A: Semigroup[A]): A

Insert an A between every A, yielding the sum.

def invariantFunctorLaw: InvariantFunctorLaw

val invariantFunctorSyntax: InvariantFunctorSyntax[F]

final def isInstanceOf[T0]: Boolean

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

Deforested alias for toStream(fa).size.

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 maximum1[A](fa: F[A])(implicit arg0: Order[A]): A

The greatest element of fa.

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

The element a of fa which yields the greatest value of f(a), or None if fa is empty.

def maximumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): A

The element a of fa which yield the greatest value of f(a).

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

The greatest value of f(a) for each element a of fa, or None if fa is empty.

def maximumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): B

The greatest value of f(a) for each element a of fa.

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

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

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

The smallest element of fa.

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

The element a of fa which yields the smallest value of f(a), or None if fa is empty.

def minimumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): A

The element a of fa which yield the smallest value of f(a).

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

The smallest value of f(a) for each element a of fa, or None if fa is empty.

def minimumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): B

The smallest value of f(a) for each element a of fa.

def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]

def msuml1[G[_], A](fa: F[G[A]])(implicit G: Plus[G]): G[A]

def msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]

final def naturalTrans: ~>[F, G]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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 product0[G[_]](implicit G0: Traverse[G]): Traverse1[[α](F[α], G[α])]

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

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

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

def product0[G[_]](implicit G0: Traverse1[G]): Traverse1[[α](F[α], G[α])]

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

def product0[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](F[α], G[α])]

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

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 scanLeft1[A](fa: F[A])(f: (A, A) ⇒ A): NonEmptyList[A]

def scanRight1[A](fa: F[A])(f: (A, A) ⇒ A): NonEmptyList[A]

def selectSplit[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[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 sequence1[G[_], A](fga: F[G[A]])(implicit arg0: Apply[G]): G[F[A]]

final def sequence1U[GA](fga: F[GA])(implicit G: Unapply[Apply, GA]): M[F[A]]

def sequence1_[M[_], A](fa: F[M[A]])(implicit a: Apply[M], x: Semigroup[M[A]]): M[Unit]

def sequenceF_[M[_], A](ffa: F[Free[M, A]]): Free[M, Unit]

sequence_ for Free.

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](fa: F[M[A]])(implicit a: Applicative[M]): M[Unit]

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

def splitBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[(B, NonEmptyList[A])]

Splits the elements into groups that produce the same result by a function f.

def splitByRelation[A](fa: F[A])(r: (A, A) ⇒ Boolean): IList[NonEmptyList[A]]

Splits into groups of elements that are transitively dependant by a relation r.

def splitWith[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[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.

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

def suml1[A](fa: F[A])(implicit A: Semigroup[A]): A

def suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]

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

def sumr1[A](fa: F[A])(implicit A: Semigroup[A]): A

def sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]

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

def to[A, G[_]](fa: F[A])(implicit c: CanBuildFrom[Nothing, A, G[A]]): G[A]

def toEphemeralStream[A](fa: F[A]): EphemeralStream[A]

def toIList[A](fa: F[A]): IList[A]

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

def toNel[A](fa: F[A]): NonEmptyList[A]

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

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

def toString(): String

def toVector[A](fa: F[A]): Vector[A]

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

def traversalS[S]: Traversal[[β$0$]IndexedStateT[[X]X, S, S, β$0$]]

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

def traverse1[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit a: Apply[G]): G[F[B]]

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

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

def traverse1Law: Traverse1Law

val traverse1Syntax: Traverse1Syntax[F]

final def traverse1U[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Apply, GB]): M[F[A]]

def traverse1_[M[_], A, B](fa: F[A])(f: (A) ⇒ M[B])(implicit a: Apply[M], x: Semigroup[M[B]]): M[Unit]

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

final def traverseM[A, G[_], B](fa: F[A])(f: (A) ⇒ G[F[B]])(implicit G: Applicative[G], F: Bind[F]): G[F[B]]

A version of traverse where a subsequent monadic join is applied to the inner result.

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](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[F[A]]

A version of traverse that infers the type constructor G.

final def traverseU_[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[Unit]

A version of traverse_ that infers the type constructor M.

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 widen[A, B](fa: F[A])(implicit ev: <~<[A, B]): F[B]

Functors are covariant by nature, so we can treat an F[A] as an F[B] if A is a subtype of B.

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

Converts ma to a value of type F[B] using the provided functions f and g.

def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]

Converts ma to a value of type F[B] using the provided bijection.

def xmapi[A, B](ma: F[A])(iso: Isomorphism.<=>[A, B]): F[B]

Converts ma to a value of type F[B] using the provided isomorphism.

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]