PIso

interface PIso<S, T, A, B> : PPrism<S, T, A, B> , PLens<S, T, A, B> , Getter<S, A> , POptional<S, T, A, B> , PSetter<S, T, A, B> , Fold<S, A> , PTraversal<S, T, A, B> , PEvery<S, T, A, B> (source)

An Iso is a loss less invertible optic that defines an isomorphism between a type S and A i.e. a data class and its properties represented by TupleN

A (polymorphic) PIso is useful when setting or modifying a value for a constructed type i.e. PIso

An PIso is also a valid PLens, PPrism

Parameters

the source of a PIso

the modified source of a PIso

the focus of a PIso

the modified target of a PIso

Types

Companion

object Companion

Properties

left

val <A, L, R> Optional<A, Either<L, R>>.left: Optional<A, L>

DSL to compose a Optional with focus Either with a Prism with a focus of Either.Left<L>

val <A, L, R> Prism<A, Either<L, R>>.left: Prism<A, L>

DSL to compose a Prism with focus Either with a Prism with a focus of Either.Left<L>

val <A, L, R> Traversal<A, Either<L, R>>.left: Traversal<A, L>

DSL to compose a Traversal with focus Either with a Prism with a focus of Either.Left<L>

right

val <A, L, R> Optional<A, Either<L, R>>.right: Optional<A, R>

DSL to compose a Optional with focus Either with a Prism with a focus of Either.Right<R>

val <A, L, R> Prism<A, Either<L, R>>.right: Prism<A, R>

DSL to compose a Prism with focus Either with a Prism with a focus of Either.Right<R>

val <A, L, R> Traversal<A, Either<L, R>>.right: Traversal<A, R>

DSL to compose a Traversal with focus Either with a Prism with a focus of Either.Right<R>

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>

val <T, S> Iso<T, Option<S>>.some: Prism<T, S>

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

val <T, S> Lens<T, Option<S>>.some: Optional<T, S>

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

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

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

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

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

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

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

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

DSL to compose a Prism with focus arrow.core.Some with a Traversal 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

DSL to compose At with a Traversal 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

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

Join two Getter with the same focus

open infix fun <S1, T1> choice(other: PLens<S1, T1, A, B>): PLens<Either<S, S1>, Either<T, T1>, A, B>

Join two PLens with the same focus in A

open infix fun <S1, T1> choice(other: POptional<S1, T1, A, B>): POptional<Either<S, S1>, Either<T, T1>, A, B>

Join two POptional with the same focus B

open infix fun <S1, T1> choice(other: POptionalGetter<S1, T1, A>): POptionalGetter<Either<S, S1>, Either<T, T1>, A>

Join two POptionalGetter with the same focus

open infix fun <U, V> choice(other: PSetter<U, V, A, B>): PSetter<Either<S, U>, Either<T, V>, A, B>

Join two PSetter with the same target

open fun <U, V> choice(other: PTraversal<U, V, A, B>): PTraversal<Either<S, U>, Either<T, V>, A, B>

compose

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

Compose a Fold with a Fold

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

Compose a Getter with a Getter

open infix fun <C, D> compose(other: PEvery<in A, out B, out C, in D>): PEvery<S, T, C, D>

Compose a PEvery with a PEvery

open infix fun <C, D> compose(other: PIso<in A, out B, out C, in D>): PIso<S, T, C, D>

Compose a PIso with a PIso

open infix fun <C, D> compose(other: PLens<in A, out B, out C, in D>): PLens<S, T, C, D>

Compose a PLens with another PLens

open infix fun <C, D> compose(other: POptional<in A, out B, out C, in D>): POptional<S, T, C, D>

Compose a POptional with a POptional

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

Compose a POptionalGetter with a POptionalGetter

open infix fun <C, D> compose(other: PPrism<in A, out B, out C, in D>): PPrism<S, T, C, D>

Compose a PPrism with another PPrism

open infix fun <C, D> compose(other: PSetter<in A, out B, out C, in D>): PSetter<S, T, C, D>

Compose a PSetter with a PSetter

open infix fun <C, D> compose(other: PTraversal<in A, out B, out C, in D>): PTraversal<S, T, C, D>

Compose a PTraversal with a PTraversal

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

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

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

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

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

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

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

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

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

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

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

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

DSL to compose Traversal with a Traversal 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.

first

open override fun <C> first(): PIso<Pair<S, C>, Pair<T, C>, Pair<A, C>, Pair<B, C>>

Create a pair of the PIso and a type C

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.

open override fun <R> foldMap(M: Monoid<R>, source: S, map: (focus: A) -> R): R

Map each target to a type R and use a Monoid to fold the results

get

abstract override fun get(source: S): A

Get the focus of a PIso

get

operator fun <A, T> PLens<T, T, List<A>, List<A>>.get(i: Int): POptional<T, T, A, A>

getAll

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

Get all targets of the Fold

getOrModify

open override fun getOrModify(source: S): Either<T, A>

Get the focus of a POptional or return the original value while allowing the type to change if it does not match

getOrNull

open fun getOrNull(source: S): A?

Get the focus of an OptionalGetter or null if the is not there

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

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

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

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

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

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

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

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

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

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

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

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

DSL to compose Index with a Traversal 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 override fun <C> left(): PIso<Either<S, C>, Either<T, C>, Either<A, C>, Either<B, C>>

Create a sum of the PIso and a type C

lift

open fun lift(map: (focus: A) -> B): (source: S) -> T

Lift a function map: (A) -> B to the context of S: (S) -> T`

liftNullable

open fun liftNullable(f: (focus: A) -> B): (source: S) -> T?

Lift a function f: (A) -> B to the context of S: (S) -> T?`

modify

open override fun modify(source: S, map: (focus: A) -> B): T

Modify polymorphically the focus of a PIso with a function

modifyNullable

open fun modifyNullable(source: S, map: (focus: A) -> B): T?

Modify the focus of a POptional with a function map

plus

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

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

open operator fun <C, D> plus(other: PEvery<in A, out B, out C, in D>): PEvery<S, T, C, D>

open operator fun <C, D> plus(other: PIso<in A, out B, out C, in D>): PIso<S, T, C, D>

open operator fun <C, D> plus(other: PLens<in A, out B, out C, in D>): PLens<S, T, C, D>

open operator fun <C, D> plus(other: POptional<in A, out B, out C, in D>): POptional<S, T, C, D>

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

open operator fun <C, D> plus(other: PPrism<in A, out B, out C, in D>): PPrism<S, T, C, D>

open operator fun <C, D> plus(other: PSetter<in A, out B, out C, in D>): PSetter<S, T, C, D>

open operator fun <C, D> plus(other: PTraversal<in A, out B, out C, in D>): PTraversal<S, T, C, D>

reverse

open fun reverse(): PIso<B, A, T, S>

Reverse a PIso: the source becomes the target and the target becomes the source

reverseGet

abstract override fun reverseGet(focus: B): T

Get the modified focus of a PIso

right

open override fun <C> right(): PIso<Either<C, S>, Either<C, T>, Either<C, A>, Either<C, B>>

Create a sum of a type C and the PIso

second

open override fun <C> second(): PIso<Pair<C, S>, Pair<C, T>, Pair<C, A>, Pair<C, B>>

Create a pair of a type C and the PIso

set

open fun set(b: B): T

Set polymorphically the focus of a PIso with a value

open override fun set(source: S, focus: B): T

Set the focus of a PPrism with a value

setNullable

open fun setNullable(source: S, b: B): T?

Set the focus of a POptional with a value.

size

open fun size(source: S): Int

Calculate the number of targets

split

open infix fun <C, D> split(other: Getter<C, D>): Getter<Pair<S, C>, Pair<A, D>>

Pair two disjoint Getter

open infix fun <S1, T1, A1, B1> split(other: PIso<S1, T1, A1, B1>): PIso<Pair<S, S1>, Pair<T, T1>, Pair<A, A1>, Pair<B, B1>>

Pair two disjoint PIso

open infix fun <S1, T1, A1, B1> split(other: PLens<S1, T1, A1, B1>): PLens<Pair<S, S1>, Pair<T, T1>, Pair<A, A1>, Pair<B, B1>>

Pair two disjoint PLens

zip

open infix fun <C> zip(other: Getter<S, C>): Getter<S, Pair<A, C>>

Zip two Getter optics with the same source S