Fold

interface Fold<S, A>(source)

A Fold is an optic that allows to focus into structure and get multiple results.

Fold is a generalisation of an instance of Foldable and is implemented in terms of foldMap.

Parameters

the source of a Fold

the target of a Fold

Inheritors

Types

Companion

object Companion

Properties

some

val <T, S> Fold<T, Option<S>>.some: Fold<T, S>

DSL to compose a Prism with focus arrow.core.Some with a Fold with a focus of Option<S>

Functions

all

open fun all(source: S, predicate: (focus: A) -> Boolean): Boolean

Check if all targets satisfy the predicate

any

open fun any(source: S, predicate: (focus: A) -> Boolean): Boolean

Returns true if at least one focus matches the given predicate.

fun <T, S, I, A> Fold<T, S>.at(AT: At<S, I, A>, i: I): Fold<T, A>

DSL to compose At with a Fold for a structure S to focus in on A at given index I.

choice

open infix fun <C> choice(other: Fold<C, A>): Fold<Either<S, C>, A>

Join two Fold with the same target

compose

open infix fun <C> compose(other: Fold<in A, out C>): Fold<S, C>

Compose a Fold with a Fold

every

fun <T, S, A> Fold<T, S>.every(TR: Every<S, A>): Fold<T, A>

DSL to compose Traversal with a Fold for a structure S to see all its foci A

exists

open fun exists(source: S, predicate: (focus: A) -> Boolean): Boolean

Check whether at least one element satisfies the predicate.

findOrNull

open fun findOrNull(source: S, predicate: (focus: A) -> Boolean): A?

Find the first element matching the predicate, if one exists.

firstOrNull

open fun firstOrNull(source: S): A?

Get the first target or null

fold

open fun fold(empty: A, combine: (A, A) -> A, source: S): A

Fold using the given empty element and combine.

foldMap

open fun <R> foldMap(empty: R, combine: (R, R) -> R, source: S, map: (focus: A) -> R): R

Map each target to a type R and combine the results as a fold.

getAll

open fun getAll(source: S): List<A>

Get all targets of the Fold

index

fun <T, S, I, A> Fold<T, S>.index(ID: Index<S, I, A>, i: I): Fold<T, A>

DSL to compose Index with a Fold for a structure S to focus in on A at given index I

isEmpty

open fun isEmpty(source: S): Boolean

Check if there is no target

isNotEmpty

open fun isNotEmpty(source: S): Boolean

Check if there is at least one target

lastOrNull

open fun lastOrNull(source: S): A?

Get the last target or null

left

open fun <C> left(): Fold<Either<S, C>, Either<A, C>>

Create a sum of the Fold and a type C

plus

open operator fun <C> plus(other: Fold<in A, out C>): Fold<S, C>

right

open fun <C> right(): Fold<Either<C, S>, Either<C, A>>

Create a sum of a type C and the Fold

size

open fun size(source: S): Int

Calculate the number of targets