Package com.jnape.palatable.lambda.traversable

Interface Traversable<A,T extends Traversable<?,T>>

Type Parameters:

A - The type of the parameter

T - The unification parameter

All Superinterfaces:

Functor<A,T>

All Known Implementing Classes:

Choice2, Choice2._A, Choice2._B, Choice3, Choice3._A, Choice3._B, Choice3._C, Choice4, Choice4._A, Choice4._B, Choice4._C, Choice4._D, Choice5, Choice5._A, Choice5._B, Choice5._C, Choice5._D, Choice5._E, Choice6, Choice6._A, Choice6._B, Choice6._C, Choice6._D, Choice6._E, Choice6._F, Choice7, Choice7._A, Choice7._B, Choice7._C, Choice7._D, Choice7._E, Choice7._F, Choice7._G, Choice8, Choice8._A, Choice8._B, Choice8._C, Choice8._D, Choice8._E, Choice8._F, Choice8._G, Choice8._H, Const, Either, Either.Left, Either.Right, Identity, LambdaIterable, LambdaMap, Lazy, Lazy.Compose, Lazy.Later, Maybe, Maybe.Just, Maybe.Nothing, RecursiveResult, RecursiveResult.Recurse, RecursiveResult.Terminate, SingletonHList, Tagged, These, These._A, These._B, These.Both, Try, Try.Failure, Try.Success, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, Tuple8

public interface Traversable<A,T extends Traversable<?,T>>
extends Functor<A,T>

An interface for a class of data structures that can be "traversed from left to right" in a structure-preserving way, successively applying some applicative computation to each element and collapsing the results into a single resulting applicative.

The same rules that apply to Functor apply to Traversable, along with the following additional 3 laws:

• naturality: t.apply(trav.traverse(f, pure).<Object>fmap(id()).coerce()) .equals(trav.traverse(t.compose(f), pure2).<Object>fmap(id()).coerce())
• identity: trav.traverse(Identity::new, x -> new Identity<>(x)).equals(new Identity<>(trav)
• composition: trav.traverse(f.andThen(x -> x.fmap(g)).andThen(Compose::new), x -> new Compose<>(new Identity<>(new Identity<>(x)))).equals(new Compose<Identity, Identity, Traversable<Object, Trav>>(trav.traverse(f, x -> new Identity<>(x)).fmap(t -> t.traverse(g, x -> new Identity<>(x)))))

For more information, read about Traversables.

Method Summary

Modifier and Type	Method	Description
default <B> Traversable<B,T>	fmap(Fn1<? super A,? extends B> fn)	Covariantly transmute this functor's parameter using the given mapping function.
<B,App extends Applicative<?,App>,TravB extends Traversable<B,T>,AppTrav extends Applicative<TravB,App>> AppTrav	traverse(Fn1<? super A,? extends Applicative<B,App>> fn, Fn1<? super TravB,? extends AppTrav> pure)	Apply fn to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.

Methods inherited from interface com.jnape.palatable.lambda.functor.Functor

coerce

Method Detail

traverse

<B,App extends Applicative<?,App>,TravB extends Traversable<B,T>,AppTrav extends Applicative<TravB,App>> AppTrav traverse(Fn1<? super A,? extends Applicative<B,App>> fn,
                                                                                                                                                              Fn1<? super TravB,? extends AppTrav> pure)

Apply fn to each element of this traversable from left to right, and collapse the results into a single resulting applicative, potentially with the assistance of the applicative's pure function.

Type Parameters:

B - the resulting element type

App - the result applicative type

TravB - this Traversable instance over B

AppTrav - the full inferred resulting type from the traversal

Parameters:

fn - the function to apply

pure - the applicative pure function

Returns:

the traversed Traversable, wrapped inside an applicative

fmap

default <B> Traversable<B,T> fmap(Fn1<? super A,? extends B> fn)

Covariantly transmute this functor's parameter using the given mapping function. Generally this method is specialized to return an instance of the class implementing Functor.

Specified by:

fmap in interface Functor<A,T extends Traversable<?,T>>

Type Parameters:

B - the new parameter type

Parameters:

fn - the mapping function

Returns:

a functor over B (the new parameter type)