io.atlassian.fugue.optic

Class Fold<S,A>

java.lang.Object

io.atlassian.fugue.optic.Fold<S,A>

Type Parameters:

S - the source of a Fold

A - the target of a Fold

public abstract class Fold<S,A>
extends Object

A Fold can be seen as a Getter with many targets or a weaker PTraversal which cannot modify its target.

Fold is on the top of the Optic hierarchy which means that Getter, PTraversal, POptional, PLens, PPrism and PIso are valid Fold

Constructor Summary

Constructors

Constructor and Description
Fold()

Method Summary

Modifier and Type	Method and Description
Function<S,Boolean>	all(Predicate<A> p) check if all targets satisfy the predicate
static <A> Fold<Either<A,A>,A>	codiagonal()
<B> Fold<S,B>	composeFold(Fold<A,B> other) compose a Fold with a Fold
<C> Fold<S,C>	composeGetter(Getter<A,C> other) compose a Fold with a Getter
<B,C,D> Fold<S,C>	composeIso(PIso<A,B,C,D> other) compose a Fold with a PIso
<B,C,D> Fold<S,C>	composeLens(PLens<A,B,C,D> other) compose a Fold with a PLens
<B,C,D> Fold<S,C>	composeOptional(POptional<A,B,C,D> other) compose a Fold with a POptional
<B,C,D> Fold<S,C>	composePrism(PPrism<A,B,C,D> other) compose a Fold with a PPrism
Predicate<S>	exist(Predicate<A> p) check if at least one target satisfies the predicate
Function<S,Option<A>>	find(Predicate<A> p) find the first target of a Fold matching the predicate
Function<S,A>	fold(Monoid<A> monoid) combine all targets using a target's Monoid
abstract <M> Function<S,M>	foldMap(Monoid<M> monoid, Function<A,M> f) map each target to a Monoid and combine the results underlying representation of Fold, all Fold methods are defined in terms of foldMap
Iterable<A>	getAll(S s) get all the targets of a Fold
Option<A>	headOption(S s) get the first target of a Fold
static <A> Fold<A,A>	id()
<S1> Fold<Either<S,S1>,A>	sum(Fold<S1,A> other) join two Fold with the same target

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Fold

public Fold()

Method Detail

foldMap

public abstract <M> Function<S,M> foldMap(Monoid<M> monoid,
                                          Function<A,M> f)

map each target to a Monoid and combine the results underlying representation of Fold, all Fold methods are defined in terms of foldMap

fold

public final Function<S,A> fold(Monoid<A> monoid)

combine all targets using a target's Monoid

getAll

public final Iterable<A> getAll(S s)

get all the targets of a Fold

find

public final Function<S,Option<A>> find(Predicate<A> p)

find the first target of a Fold matching the predicate

headOption

public final Option<A> headOption(S s)

get the first target of a Fold

exist

public final Predicate<S> exist(Predicate<A> p)

check if at least one target satisfies the predicate

all

public final Function<S,Boolean> all(Predicate<A> p)

check if all targets satisfy the predicate

sum

public final <S1> Fold<Either<S,S1>,A> sum(Fold<S1,A> other)

join two Fold with the same target

composeFold

public final <B> Fold<S,B> composeFold(Fold<A,B> other)

compose a Fold with a Fold

composeGetter

public final <C> Fold<S,C> composeGetter(Getter<A,C> other)

compose a Fold with a Getter

composeOptional

public final <B,C,D> Fold<S,C> composeOptional(POptional<A,B,C,D> other)

compose a Fold with a POptional

composePrism

public final <B,C,D> Fold<S,C> composePrism(PPrism<A,B,C,D> other)

compose a Fold with a PPrism

composeLens

public final <B,C,D> Fold<S,C> composeLens(PLens<A,B,C,D> other)

compose a Fold with a PLens

composeIso

public final <B,C,D> Fold<S,C> composeIso(PIso<A,B,C,D> other)

compose a Fold with a PIso

id

public static <A> Fold<A,A> id()

codiagonal

public static <A> Fold<Either<A,A>,A> codiagonal()