com.mojang.datafixers.optics

Class Affine.Instance<A2,B2>

java.lang.Object

com.mojang.datafixers.optics.Affine.Instance<A2,B2>

Type Parameters:

A2 - The input field type.

B2 - The output field type.

All Implemented Interfaces:

AffineP Affine<_::A2,_::B2>, Kind2 Affine<_::A2,_::B2>, AffineP Affine<_::A2,_::B2>, Cartesian Affine<_::A2,_::B2>, Cocartesian Affine<_::A2,_::B2>, Profunctor Affine<_::A2,_::B2>

Enclosing interface:

Affine<S,T,A,B>

public static final class Affine.Instance<A2,B2>
extends Object
implements AffineP Affine<_::A2,_::B2>

The AffineP type class instance for Affine.

Type Shape:

instance %.Type.[_::%0,_::%1]

Constructor Summary

Constructors

Constructor and Description
Instance()

Method Summary

Modifier and Type	Method and Description
<A,B,C,D> (Affine<A::A2,B::B2>) -> Affine<C::A2,D::B2>	dimap((C) -> A g, (B) -> D h) Takes a function from the output type C to the input type A and a function from the input type B to the output type D, and returns a function from a container of A, B to a container of C, D.
<A,B,C> Affine<(A,C)::A2,(B,C)::B2>	first(Affine<A::A2,B::B2> input) Converts the given transformation into one that transforms the first type of a Pair.
<A,B,C> Affine<(A|C)::A2,(B|C)::B2>	left(Affine<A::A2,B::B2> input) Converts the given transformation into one that transforms the left type of an Either.
<A,B,C> Affine<(C|A)::A2,(C|B)::B2>	right(Affine<A::A2,B::B2> input) Converts the given transformation into one that transforms the right type of an Either.
<A,B,C> Affine<(C,A)::A2,(C,B)::B2>	second(Affine<A::A2,B::B2> input) Converts the given transformation into one that transforms the second type of a Pair.

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.mojang.datafixers.optics.profunctors.Cartesian

toFP2

Methods inherited from interface com.mojang.datafixers.optics.profunctors.Cocartesian

toFP

Methods inherited from interface com.mojang.datafixers.optics.profunctors.Profunctor

dimap, dimap, lmap, rmap

Constructor Detail

Instance

public Instance()

Method Detail

dimap

public <A,B,C,D> (Affine<A::A2,B::B2>) -> Affine<C::A2,D::B2> dimap((C) -> A g,
                                                                    (B) -> D h)

Description copied from interface: Profunctor

Takes a function from the output type C to the input type A and a function from the input type B to the output type D, and returns a function from a container of A, B to a container of C, D.

A straightforward example of an implementation of dimap is the method Function.andThen(Function). For functions, the expression

 dimap(g, h).apply(f)
 

is equivalent to

 g.andThen(f).andThen(h)
 

Specified by:

dimap in interface Profunctor Affine<_::A2,_::B2>

Type Parameters:

A - The first input type.

B - The second input type.

C - The first output type.

D - The second output type.

Parameters:

g - A function from output to input.

h - A function from input to output.

Returns:

A function from an input container to an output container.

See Also:

Profunctor.dimap(App2, Function, Function)

first

public <A,B,C> Affine<(A,C)::A2,(B,C)::B2> first(Affine<A::A2,B::B2> input)

Description copied from interface: Cartesian

Converts the given transformation into one that transforms the first type of a Pair. The second type is not transformed - any values of that type are passed through the returned transformation unchanged.

Specified by:

first in interface Cartesian Affine<_::A2,_::B2>

Type Parameters:

A - The input type.

B - The output type.

C - A "pass-through" type that is not transformed.

Parameters:

input - The transformation.

Returns:

A transformation on pairs, where the first type is transformed and the second is not.

second

public <A,B,C> Affine<(C,A)::A2,(C,B)::B2> second(Affine<A::A2,B::B2> input)

Description copied from interface: Cartesian

Converts the given transformation into one that transforms the second type of a Pair. The first type is not transformed - any values of that type are passed through the returned transformation unchanged.

Specified by:

second in interface Cartesian Affine<_::A2,_::B2>

Type Parameters:

A - The input type.

B - The output type.

C - A "pass-through" type that is not transformed.

Parameters:

input - The transformation.

Returns:

A transformation on pairs, where the second type is transformed and the first is not.

left

public <A,B,C> Affine<(A|C)::A2,(B|C)::B2> left(Affine<A::A2,B::B2> input)

Description copied from interface: Cocartesian

Converts the given transformation into one that transforms the left type of an Either. The right type of the Either is left unchanged by the returned transformation.

Specified by:

left in interface Cocartesian Affine<_::A2,_::B2>

Type Parameters:

A - The input type.

B - The output type.

C - A "pass-through" type that is not transformed.

Parameters:

input - The transformation.

Returns:

A transformation on the left type of an Either.

right

public <A,B,C> Affine<(C|A)::A2,(C|B)::B2> right(Affine<A::A2,B::B2> input)

Description copied from interface: Cocartesian

Converts the given transformation into one that transforms the right type of an Either. The left type of the Either is left unchanged by the returned transformation.

Specified by:

right in interface Cocartesian Affine<_::A2,_::B2>

Type Parameters:

A - The input type.

B - The output type.

C - A "pass-through" type that is not transformed.

Parameters:

input - The transformation.

Returns:

A transformation on the right type of an Either.