eu.lunisolar.magma.func.operator.binary

Interface LCharBinaryOperator

All Superinterfaces:

Codomain<aType.aChar>, Domain, Domain2<aType.aChar,aType.aChar>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaOperator

All Known Implementing Classes:

LCharBinaryOperator.LCharBinaryOperatorSingle

@FunctionalInterface
public interface LCharBinaryOperator
extends MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aChar>, Domain2<aType.aChar,aType.aChar>

Non-throwing functional interface (lambda) LCharBinaryOperator for Java 8.

Type: operator

Domain (lvl: 2): char a1,char a2

Co-domain: char

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LCharBinaryOperator.LCharBinaryOperatorSingle

Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Field Summary

Fields

Modifier and Type	Field and Description
static String	DESCRIPTION

Method Summary

Modifier and Type	Method and Description
static LCharBinaryOperator	apply1stAsChar(LCharUnaryOperator func) Captures single parameter function into this interface where only 1st parameter will be used.
static LCharBinaryOperator	apply2ndAsChar(LCharUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
default char	applyAsChar(char a1, char a2)
default char	applyAsChar(char a1, char a2, ExWF<RuntimeException> exF)
default char	applyAsChar(char a1, char a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default char	applyAsCharThen(char a1, char a2, LToCharFunction<Throwable> handler)
char	applyAsCharX(char a1, char a2) Implement this, but call applyAsChar(char a1,char a2)
static char	call(char a1, char a2, LCharBinaryOperator lambda)
default LCharSupplier	capture(char a1, char a2) Captures arguments but delays the evaluation.
static LCharBinaryOperator	charBinaryOp(LCharBinaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V1,V2> LToCharBiFunction<V1,V2>	charBinaryOpCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
static LCharBinaryOperator	charBinaryOpThrowing(ExF<Throwable> exF)
static LCharBinaryOperator	charBinaryOpThrowing(String message, ExMF<Throwable> exF)
default LCharBinaryOperator	compose(LCharUnaryOperator before1, LCharUnaryOperator before2) Allows to manipulate the domain of the function.
static LCharBinaryOperator	composed(LCharUnaryOperator before1, LCharUnaryOperator before2, LCharBinaryOperator after)
static <V1,V2> LToCharBiFunction<V1,V2>	composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LCharBinaryOperator after)
static LCharBinaryOperator	constant(char r) Creates function that always returns the same value.
static LCharBinaryOperator	failSafe(LCharBinaryOperator func, LCharBinaryOperator failSafe)
default char	failSafeApplyAsChar(char a1, char a2, LCharBinaryOperator failSafe)
static char	failSafeApplyAsChar(char a1, char a2, LCharBinaryOperator func, LCharBinaryOperator failSafe)
default <C1,C2> void	forEach(IndexedRead<C1,aType.aChar> ia1, C1 source1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LCharConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static void	fromTill(int min_i, int max_i, char a1, char a2, LCharBinaryOperator func) From-To.
static void	fromTo(int min_i, int max_i, char a1, char a2, LCharBinaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LCharBinaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default char	handlingApplyAsChar(char a1, char a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static char	handlingApplyAsChar(char a1, char a2, LCharBinaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C1,C2,I2> void	iterate(IndexedRead<C1,aType.aChar> ia1, C1 source1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LCharConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	iterate(SequentialRead<C1,I1,aType.aChar> sa1, C1 source1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LCharConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	iterate(SequentialRead<C1,I1,aType.aChar> sa1, C1 source1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LCharConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LCharUnaryOperator	lShrink(LCharUnaryOperator left)
default LCharUnaryOperator	lShrinkc(char a1)
static LCharUnaryOperator	lShrinked(LCharUnaryOperator left, LCharBinaryOperator func)
static LCharUnaryOperator	lShrinkedc(char a1, LCharBinaryOperator func)
static LCharBinaryOperator	max() Returns function that returns the higher value.
static LCharBinaryOperator	maxBy(Comparator<Character> comparator) Creates function that returns the lesser value according to the comparator.
static LCharBinaryOperator	min() Returns function that returns the lower value.
static LCharBinaryOperator	minBy(Comparator<Character> comparator) Creates function that returns the lesser value according to the comparator.
default char	nestingApplyAsChar(char a1, char a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default char	nonNullApplyAsChar(char a1, char a2) Just to mirror the method: Ensures the result is not null
static char	produceChar(char a1, char a2) Does nothing (LCharBinaryOperator) Operator
static LCharBinaryOperator	recursive(LFunction<LCharBinaryOperator,LCharBinaryOperator> selfLambda)
default LCharUnaryOperator	rShrink(LCharUnaryOperator right)
default LCharUnaryOperator	rShrinkc(char a2)
static LCharUnaryOperator	rShrinked(LCharUnaryOperator right, LCharBinaryOperator func)
static LCharUnaryOperator	rShrinkedc(char a2, LCharBinaryOperator func)
static LCharBinaryOperator	safe() Safe instance.
static LCharBinaryOperator	safe(LCharBinaryOperator other) Safe wrapping.
static LSupplier<LCharBinaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LCharBinaryOperator>	safeSupplier(LSupplier<LCharBinaryOperator> supplier) Safe supplier.
default char	shovingApplyAsChar(char a1, char a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LBiCharFunction<V>	then(LCharFunction<? extends V> after) Combines two functions together in a order.
default LBiCharPredicate	thenToBool(LCharPredicate after) Combines two functions together in a order.
default LCharBinaryOperator	thenToChar(LCharUnaryOperator after) Combines two functions together in a order.
static void	times(int max_i, char a1, char a2, LCharBinaryOperator func) From-To.
static char	tryApplyAsChar(char a1, char a2, LCharBinaryOperator func)
static char	tryApplyAsChar(char a1, char a2, LCharBinaryOperator func, ExWF<RuntimeException> exF)
static char	tryApplyAsChar(char a1, char a2, LCharBinaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static char	tryApplyAsCharThen(char a1, char a2, LCharBinaryOperator func, LToCharFunction<Throwable> handler)
default LCharBinaryOperator	trying(ExWF<RuntimeException> exF)
default LCharBinaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LCharBinaryOperator	tryingThen(LToCharFunction<Throwable> handler)
default char	tupleApplyAsChar(LCharPair args)
static LCharBinaryOperator	uncurry(LCharFunction<LCharUnaryOperator> func)

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaOperator

isOperator

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaFunction

isFunction

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface

formatTo, isAction, isConsumer, isPredicate, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

isThrowing

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing

isThrowing

Field Detail

DESCRIPTION

static final String DESCRIPTION

See Also:

Constant Field Values

Method Detail

applyAsChar

default char applyAsChar(char a1,
                         char a2)

applyAsCharX

char applyAsCharX(char a1,
                  char a2)
           throws Throwable

Implement this, but call applyAsChar(char a1,char a2)

Throws:

Throwable

tupleApplyAsChar

default char tupleApplyAsChar(LCharPair args)

handlingApplyAsChar

default char handlingApplyAsChar(char a1,
                                 char a2,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LCharBinaryOperator handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsChar

default char applyAsChar(char a1,
                         char a2,
                         @Nonnull
                         ExWMF<RuntimeException> exF,
                         @Nonnull
                         String newMessage,
                         @Nullable
                         Object... messageParams)

trying

default LCharBinaryOperator trying(@Nonnull
                                   ExWMF<RuntimeException> exF,
                                   @Nonnull
                                   String newMessage,
                                   @Nullable
                                   Object... messageParams)

applyAsChar

default char applyAsChar(char a1,
                         char a2,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

default LCharBinaryOperator trying(@Nonnull
                                   ExWF<RuntimeException> exF)

applyAsCharThen

default char applyAsCharThen(char a1,
                             char a2,
                             @Nonnull
                             LToCharFunction<Throwable> handler)

tryingThen

default LCharBinaryOperator tryingThen(@Nonnull
                                       LToCharFunction<Throwable> handler)

nestingApplyAsChar

default char nestingApplyAsChar(char a1,
                                char a2)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApplyAsChar

default char shovingApplyAsChar(char a1,
                                char a2)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApplyAsChar

static char handlingApplyAsChar(char a1,
                                char a2,
                                LCharBinaryOperator func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsChar

static char tryApplyAsChar(char a1,
                           char a2,
                           LCharBinaryOperator func)

tryApplyAsChar

static char tryApplyAsChar(char a1,
                           char a2,
                           LCharBinaryOperator func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsChar

static char tryApplyAsChar(char a1,
                           char a2,
                           LCharBinaryOperator func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsCharThen

static char tryApplyAsCharThen(char a1,
                               char a2,
                               LCharBinaryOperator func,
                               @Nonnull
                               LToCharFunction<Throwable> handler)

failSafeApplyAsChar

default char failSafeApplyAsChar(char a1,
                                 char a2,
                                 @Nonnull
                                 LCharBinaryOperator failSafe)

failSafeApplyAsChar

static char failSafeApplyAsChar(char a1,
                                char a2,
                                LCharBinaryOperator func,
                                @Nonnull
                                LCharBinaryOperator failSafe)

failSafe

static LCharBinaryOperator failSafe(LCharBinaryOperator func,
                                    @Nonnull
                                    LCharBinaryOperator failSafe)

nonNullApplyAsChar

default char nonNullApplyAsChar(char a1,
                                char a2)

Just to mirror the method: Ensures the result is not null

functionalInterfaceDescription

@Nonnull
default String functionalInterfaceDescription()

Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static void fromTo(int min_i,
                   int max_i,
                   char a1,
                   char a2,
                   LCharBinaryOperator func)

From-To. Intended to be used with non-capturing lambda.

fromTill

static void fromTill(int min_i,
                     int max_i,
                     char a1,
                     char a2,
                     LCharBinaryOperator func)

From-To. Intended to be used with non-capturing lambda.

times

static void times(int max_i,
                  char a1,
                  char a2,
                  LCharBinaryOperator func)

From-To. Intended to be used with non-capturing lambda.

lShrink

default LCharUnaryOperator lShrink(LCharUnaryOperator left)

lShrinkc

default LCharUnaryOperator lShrinkc(char a1)

lShrinked

static LCharUnaryOperator lShrinked(LCharUnaryOperator left,
                                    LCharBinaryOperator func)

lShrinkedc

static LCharUnaryOperator lShrinkedc(char a1,
                                     LCharBinaryOperator func)

rShrink

default LCharUnaryOperator rShrink(LCharUnaryOperator right)

rShrinkc

default LCharUnaryOperator rShrinkc(char a2)

rShrinked

static LCharUnaryOperator rShrinked(LCharUnaryOperator right,
                                    LCharBinaryOperator func)

rShrinkedc

static LCharUnaryOperator rShrinkedc(char a2,
                                     LCharBinaryOperator func)

uncurry

static LCharBinaryOperator uncurry(LCharFunction<LCharUnaryOperator> func)

capture

default LCharSupplier capture(char a1,
                              char a2)

Captures arguments but delays the evaluation.

constant

static LCharBinaryOperator constant(char r)

Creates function that always returns the same value.

apply1stAsChar

@Nonnull
static LCharBinaryOperator apply1stAsChar(@Nonnull
                                                    LCharUnaryOperator func)

Captures single parameter function into this interface where only 1st parameter will be used.

apply2ndAsChar

@Nonnull
static LCharBinaryOperator apply2ndAsChar(@Nonnull
                                                    LCharUnaryOperator func)

Captures single parameter function into this interface where only 2nd parameter will be used.

charBinaryOp

@Nonnull
static LCharBinaryOperator charBinaryOp(@Nonnull
                                                  LCharBinaryOperator lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

@Nonnull
static LCharBinaryOperator recursive(@Nonnull
                                               LFunction<LCharBinaryOperator,LCharBinaryOperator> selfLambda)

charBinaryOpThrowing

@Nonnull
static LCharBinaryOperator charBinaryOpThrowing(@Nonnull
                                                          ExF<Throwable> exF)

charBinaryOpThrowing

@Nonnull
static LCharBinaryOperator charBinaryOpThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static char call(char a1,
                 char a2,
                 @Nonnull
                 LCharBinaryOperator lambda)

safe

@Nonnull
static LCharBinaryOperator safe()

Safe instance. That always returns the same value (as produceChar).

safeSupplier

@Nonnull
static LSupplier<LCharBinaryOperator> safeSupplier()

Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static LCharBinaryOperator safe(@Nullable
                                          LCharBinaryOperator other)

Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.

safeSupplier

@Nonnull
static LSupplier<LCharBinaryOperator> safeSupplier(@Nullable
                                                             LSupplier<LCharBinaryOperator> supplier)

Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.

minBy

@Nonnull
static LCharBinaryOperator minBy(@Nonnull
                                           Comparator<Character> comparator)

Creates function that returns the lesser value according to the comparator.

See Also:

java.util.function.BinaryOperator#minBy}

maxBy

@Nonnull
static LCharBinaryOperator maxBy(@Nonnull
                                           Comparator<Character> comparator)

Creates function that returns the lesser value according to the comparator.

See Also:

java.util.function.BinaryOperator#maxBy}

min

@Nonnull
static LCharBinaryOperator min()

Returns function that returns the lower value.

See Also:

java.util.function.BinaryOperator#minBy}

max

@Nonnull
static LCharBinaryOperator max()

Returns function that returns the higher value.

See Also:

java.util.function.BinaryOperator#maxBy}

compose

@Nonnull
default LCharBinaryOperator compose(@Nonnull
                                              LCharUnaryOperator before1,
                                              @Nonnull
                                              LCharUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LCharBinaryOperator composed(@Nonnull
                                    LCharUnaryOperator before1,
                                    @Nonnull
                                    LCharUnaryOperator before2,
                                    LCharBinaryOperator after)

charBinaryOpCompose

@Nonnull
default <V1,V2> LToCharBiFunction<V1,V2> charBinaryOpCompose(@Nonnull
                                                                       LToCharFunction<? super V1> before1,
                                                                       @Nonnull
                                                                       LToCharFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2> LToCharBiFunction<V1,V2> composed(@Nonnull
                                                 LToCharFunction<? super V1> before1,
                                                 @Nonnull
                                                 LToCharFunction<? super V2> before2,
                                                 LCharBinaryOperator after)

then

@Nonnull
default <V> LBiCharFunction<V> then(@Nonnull
                                              LCharFunction<? extends V> after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LCharBinaryOperator thenToChar(@Nonnull
                                                 LCharUnaryOperator after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBiCharPredicate thenToBool(@Nonnull
                                              LCharPredicate after)

Combines two functions together in a order.

produceChar

static char produceChar(char a1,
                        char a2)

Does nothing (LCharBinaryOperator) Operator

forEach

default <C1,C2> void forEach(IndexedRead<C1,aType.aChar> ia1,
                             C1 source1,
                             IndexedRead<C2,aType.aChar> ia2,
                             C2 source2,
                             LCharConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2> void iterate(SequentialRead<C1,I1,aType.aChar> sa1,
                                C1 source1,
                                IndexedRead<C2,aType.aChar> ia2,
                                C2 source2,
                                LCharConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,C2,I2> void iterate(IndexedRead<C1,aType.aChar> ia1,
                                C1 source1,
                                SequentialRead<C2,I2,aType.aChar> sa2,
                                C2 source2,
                                LCharConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2,I2> void iterate(SequentialRead<C1,I1,aType.aChar> sa1,
                                   C1 source1,
                                   SequentialRead<C2,I2,aType.aChar> sa2,
                                   C2 source2,
                                   LCharConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.