tech.codingzen.kata.either

Class EitherKt

tech.codingzen.kata.either.EitherKt

public class EitherKt

Constructor Detail

EitherKt

public EitherKt()

Method Detail

fold

public static <L,R,A> A fold(@NotNull
                             Either<? extends L,? extends R> $this$fold,
                             @NotNull
                             kotlin.jvm.functions.Function1<? super L,? extends A> fnL,
                             @NotNull
                             kotlin.jvm.functions.Function1<? super R,? extends A> fnR)

Type Parameters:

L -

left type

R -

right type

A -

result type

Parameters:

fnL - function to apply to the left value of the receiver

fnR - function to apply to the right value of the receiver

Returns:

the result of applying fnL or fnR to this Either

foldR

public static <L,R,A> A foldR(@NotNull
                              FoldIntermediate<L,R,A> $this$foldR,
                              @NotNull
                              kotlin.jvm.functions.Function1<? super R,? extends A> fnR)

Type Parameters:

L -

left type

R -

right type

A -

result type

Parameters:

fnR - right fn for the fold on this FoldIntermediate

Returns:

the result of fold'ing the Either referenced by this

foldL

@NotNull
public static <L,R,A> FoldIntermediate<L,R,A> foldL(@NotNull
                                                              Either<? extends L,? extends R> $this$foldL,
                                                              @NotNull
                                                              kotlin.jvm.functions.Function1<? super L,? extends A> fnL)

Type Parameters:

L -

left type

R -

right type

A -

result type

Parameters:

fnL - left fn for the fold on this Either

Returns:

the result of applying fnL or fnR to this Either where fnL and fnR are defined by this method and class FoldIntermediate

isLeft

public static boolean isLeft(@NotNull
                             Either<?,?> $this$isLeft)

Returns:

true if this Either is a left, false otherwise

isRight

public static boolean isRight(@NotNull
                              Either<?,?> $this$isRight)

Returns:

true if this Either is a right, false otherwise

bindSyntax

@NotNull
public static <L,R,S> Either<L,S> bindSyntax(@NotNull
                                                       Either<? extends L,? extends R> $this$bindSyntax,
                                                       @NotNull
                                                       kotlin.jvm.functions.Function2<? super tech.codingzen.kata.either.EitherFixedLeftSyntax<L>,? super R,? extends tech.codingzen.kata.either.Either<? extends L,? extends S>> fn)

Type Parameters:

L -

left type

R -

right type

S -

new right type

Parameters:

fn - fn used to transform the right value of this Either

Returns:

the result of applying fn to the right value of this Either. If this Either is a left it is returned unchanged

bind

@NotNull
public static <L,R,S> Either<L,S> bind(@NotNull
                                                 Either<? extends L,? extends R> $this$bind,
                                                 @NotNull
                                                 kotlin.jvm.functions.Function1<? super R,? extends tech.codingzen.kata.either.Either<? extends L,? extends S>> fn)

Type Parameters:

L -

left type

R -

right type

S -

new right type

Parameters:

fn - fn used to transform the right value of this Either

Returns:

the result of applying fn to the right value of this Either. If this Either is a left it is returned unchanged

map

@NotNull
public static <L,R,S> Either<L,S> map(@NotNull
                                                Either<? extends L,? extends R> $this$map,
                                                @NotNull
                                                kotlin.jvm.functions.Function1<? super R,? extends S> fn)

Type Parameters:

L -

left type

R -

right type

S -

new right type

Parameters:

fn - fn used to transform the right value of this Either

Returns:

an Either containing a right value that is the result of applying fn to the right value of this Either. If this Either is a left it is returned unchanged

filter

@NotNull
public static <L,R> Either<L,R> filter(@NotNull
                                                 Either<? extends L,? extends R> $this$filter,
                                                 @NotNull
                                                 kotlin.jvm.functions.Function1<? super tech.codingzen.kata.either.FilterSyntax<L,R>,kotlin.Unit> body)

Type Parameters:

L -

left type

R -

right type

Parameters:

body - used to facilitate a more vertical syntax for the filter operation

Returns:

this Either if it passed the filter test or contained a left value, otherwise the result of applying handler (defined by body) to the right value that did not pass the filter test

peekRight

@NotNull
public static <L,R> Either<L,R> peekRight(@NotNull
                                                    Either<? extends L,? extends R> $this$peekRight,
                                                    @NotNull
                                                    kotlin.jvm.functions.Function1<? super R,kotlin.Unit> body)

Type Parameters:

L -

left type

R -

right type

Parameters:

body - block of code that is executed if this Either contains a right value

Returns:

this Either unchanged

peekLeft

@NotNull
public static <L,R> Either<L,R> peekLeft(@NotNull
                                                   Either<? extends L,? extends R> $this$peekLeft,
                                                   @NotNull
                                                   kotlin.jvm.functions.Function1<? super L,kotlin.Unit> body)

Type Parameters:

L -

left type

R -

right type

Parameters:

body - block of code that is executed if this Either contains a left value

Returns:

this Either unchanged

onLeft

public static <L,R> R onLeft(@NotNull
                             Either<? extends L,? extends R> $this$onLeft,
                             @NotNull
                             kotlin.jvm.functions.Function1 block)

Type Parameters:

L -

left type

R -

right type

Parameters:

block - block of code that is executed if this Either contains a left value

Returns:

right value of this Either

onRight

public static <L,R> L onRight(@NotNull
                              Either<? extends L,? extends R> $this$onRight,
                              @NotNull
                              kotlin.jvm.functions.Function1 block)

Type Parameters:

L -

left type

R -

right type

Parameters:

block - block of code that is executed if this Either contains a left value

Returns:

right value of this Either

get

public static <T> T get(@NotNull
                        Either<? extends T,? extends T> $this$get)

Type Parameters:

T -

both left and right type

Returns:

the left or right value of this Either

getLeft

public static <L> L getLeft(@NotNull
                            Either<? extends L,?> $this$left)

Type Parameters:

L - left type

Returns:

the left value of this Either, otherwise throws NoSuchElementException

Throws:

NoSuchElementException - if this Either contains a right value

getRight

public static <R> R getRight(@NotNull
                             Either<?,? extends R> $this$right)

Type Parameters:

R - right type

Returns:

the right value of this Either, otherwise throws NoSuchElementException

Throws:

NoSuchElementException - if this Either contains a left value

orElse

public static <R> R orElse(@NotNull
                           Either<?,? extends R> $this$orElse,
                           R p)

Type Parameters:

R -

right type

Parameters:

p - value to return if this Either contains a left value

Returns:

this Either's right value or default if this Either contains a left value

orElseMap

public static <L,R> R orElseMap(@NotNull
                                Either<? extends L,? extends R> $this$orElseMap,
                                @NotNull
                                kotlin.jvm.functions.Function1<? super L,? extends R> fn)

Type Parameters:

L -

left type

R -

right type

Parameters:

fn - mapping function to transform the left value to an instance of R

Returns:

this Either's right value or the value of applying fn to this Either's left value

orElseGet

public static <L,R> R orElseGet(@NotNull
                                Either<? extends L,? extends R> $this$orElseGet,
                                @NotNull
                                kotlin.jvm.functions.Function0<? extends R> fn)

Type Parameters:

L -

left type

R -

right type

Parameters:

fn - function that produces a default value

Returns:

this Either's right value or the value of applying fn

orThrow

public static <R> R orThrow(@NotNull
                            Either<?,? extends R> $this$orThrow,
                            @NotNull
                            kotlin.jvm.functions.Function0<? extends java.lang.Throwable> fn)

Type Parameters:

R -

right type

Parameters:

fn - function that produces the Throwable to throw

Returns:

this Either's right value or throws the exception produced by fn

Throws:

Exception - produced by fn

bindLeftSyntax

@NotNull
public static <L,R,M> Either<M,R> bindLeftSyntax(@NotNull
                                                           Either<? extends L,? extends R> $this$bindLeftSyntax,
                                                           @NotNull
                                                           kotlin.jvm.functions.Function2<? super tech.codingzen.kata.either.EitherFixedRightSyntax<R>,? super L,? extends tech.codingzen.kata.either.Either<? extends M,? extends R>> fn)

Type Parameters:

L -

left type

R -

right type

M -

new left type

Parameters:

fn - fn used to transform the left value of this Either

Returns:

the result of applying fn to the left value of this Either. If this Either is a right it is returned unchanged

bindLeft

@NotNull
public static <L,R,M> Either<M,R> bindLeft(@NotNull
                                                     Either<? extends L,? extends R> $this$bindLeft,
                                                     @NotNull
                                                     kotlin.jvm.functions.Function1<? super L,? extends tech.codingzen.kata.either.Either<? extends M,? extends R>> fn)

Type Parameters:

L -

left type

R -

right type

M -

new left type

Parameters:

fn - fn used to transform the left value of this Either

Returns:

the result of applying fn to the left value of this Either. If this Either is a right it is returned unchanged

mapLeft

@NotNull
public static <L,R,M> Either<M,R> mapLeft(@NotNull
                                                    Either<? extends L,? extends R> $this$mapLeft,
                                                    @NotNull
                                                    kotlin.jvm.functions.Function1<? super L,? extends M> fn)

Type Parameters:

L -

left type

R -

right type

M -

new right type

Parameters:

fn - fn used to transform the left value of this Either

Returns:

an Either containing a left value that is the result of applying fn to the left value of this Either. If this Either is a right it is returned unchanged

filterLeft

@NotNull
public static <L,R> Either<L,R> filterLeft(@NotNull
                                                     Either<? extends L,? extends R> $this$filterLeft,
                                                     @NotNull
                                                     kotlin.jvm.functions.Function1<? super tech.codingzen.kata.either.FilterLeftSyntax<L,R>,kotlin.Unit> body)

Type Parameters:

L -

left type

R -

right type

Parameters:

body - used to facilitate a more vertical syntax for the filterLeft operation

Returns:

this Either if it passed the filter test or contained a right value, otherwise the result of applying handler (defined by body) to the left value that did not pass the filter test

join

@NotNull
public static <L,R> Either<L,R> join(@NotNull
                                               Either<? extends L,? extends tech.codingzen.kata.either.Either<? extends L,? extends R>> $this$join)

Type Parameters:

L -

left type

R -

right type

Returns:

this Either join'ed to result in an un-nested Either type

joinViaLeft

@JvmName
 @NotNull
public static <L,R> Either<L,R> joinViaLeft(@NotNull
                                                                 Either<? extends tech.codingzen.kata.either.Either<? extends L,? extends R>,? extends R> $this$join)

Type Parameters:

L -

left type

R -

right type

Returns:

this Either join'ed to result in an un-nested Either type

bindTry

@NotNull
public static <L,R,S> EitherTryResult<L,R,S> bindTry(@NotNull
                                                               Either<? extends L,? extends R> $this$bindTry,
                                                               @NotNull
                                                               kotlin.jvm.functions.Function2<? super tech.codingzen.kata.either.EitherFixedLeftSyntax<L>,? super R,? extends tech.codingzen.kata.either.Either<? extends L,? extends S>> fn)

Type Parameters:

L -

left type

R -

right type

S -

new right type

Parameters:

fn - fn used to transform the right value of this Either. This function has a receiver type ofinterface EitherFixedLeftSyntax to provide access to the EitherFixedLeftSyntax.left and EitherFixedLeftSyntax.right

Returns:

the result of applying fn to the right value of this Either. If this Either is a left it is returned unchanged. If during the application of fn an exception is thrown then handler (defined by body) is used to convert the right value and exception into an Either

mapTry

@NotNull
public static <L,R,S> EitherTryResult<L,R,S> mapTry(@NotNull
                                                              Either<? extends L,? extends R> $this$mapTry,
                                                              @NotNull
                                                              kotlin.jvm.functions.Function1<? super R,? extends S> fn)

Type Parameters:

L -

left type

R -

right type

S -

new right type

Parameters:

fn - fn used to transform the right value of this Either

Returns:

the result of applying fn to the right value of this Either. If this Either is a left it is returned unchanged. If during the application of fn an exception is thrown then handler (defined by body) is used to convert the right value and exception into an Either

handler

@NotNull
public static <L,R,S> Either<L,S> handler(@NotNull
                                                    EitherTryResult<? extends L,? extends R,? extends S> $this$handler,
                                                    @NotNull
                                                    kotlin.jvm.functions.Function3<? super tech.codingzen.kata.either.EitherFixedLeftSyntax<L>,? super R,? super java.lang.Throwable,? extends tech.codingzen.kata.either.Either<? extends L,? extends S>> fn)

Type Parameters:

L -

left type

R -

right type

S -

new right type

Parameters:

fn - lambda with receiver type of interface EitherFixedLeftSyntax, used to transform the right value and exception into an Either

Returns:

the result of applying fn if this EitherTryResult contains a right value and exception. If this EitherTryResult contains an Either then that Either is returned unchanged

sequence

@NotNull
public static <L,R> Either<L,java.util.List> sequence(@NotNull
                                                                java.util.List<? extends tech.codingzen.kata.either.Either<? extends L,? extends R>> $this$sequence)

Type Parameters:

L -

left type

R -

right type

Returns:

an Either whose right holds a list of ALL right values in the receiver, or an Either whose left holds the first left encountered when sequenc'ing the receiver