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 java.lang.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 Description

Fold()

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`java.util.function.Function<S,java.lang.Boolean>`	`all(java.util.function.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`
`java.util.function.Predicate<S>`	`exist(java.util.function.Predicate<A> p)`	check if at least one target satisfies the predicate
`java.util.function.Function<S,Option<A>>`	`find(java.util.function.Predicate<A> p)`	find the first target of a `Fold` matching the predicate
`java.util.function.Function<S,A>`	`fold(Monoid<A> monoid)`	combine all targets using a target's `Monoid`
`abstract <M> java.util.function.Function<S,M>`	`foldMap(Monoid<M> monoid, java.util.function.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
`java.lang.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> java.util.function.Function<S,M> foldMap(Monoid<M> monoid,
                                                                   java.util.function.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 java.util.function.Function<S,A> fold(Monoid<A> monoid)

combine all targets using a target's Monoid

getAll

public final java.lang.Iterable<A> getAll(S s)

get all the targets of a Fold

find

public final java.util.function.Function<S,Option<A>> find(java.util.function.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 java.util.function.Predicate<S> exist(java.util.function.Predicate<A> p)

check if at least one target satisfies the predicate

all

public final java.util.function.Function<S,java.lang.Boolean> all(java.util.function.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()

Class Fold<S,​A>

Constructor Summary