eu.lunisolar.magma.func.operator.binary

Interface LByteBinaryOperator

All Superinterfaces:

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

All Known Implementing Classes:

LByteBinaryOperator.LByteBinaryOperatorSingle

@FunctionalInterface
public interface LByteBinaryOperator
extends MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aByte>, Domain2<aType.aByte,aType.aByte>

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

Type: operator

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

Co-domain: byte

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LByteBinaryOperator.LByteBinaryOperatorSingle

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 LByteBinaryOperator	apply1stAsByte(LByteUnaryOperator func) Captures single parameter function into this interface where only 1st parameter will be used.
static LByteBinaryOperator	apply2ndAsByte(LByteUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
default byte	applyAsByte(byte a1, byte a2)
default byte	applyAsByte(byte a1, byte a2, ExWF<RuntimeException> exF)
default byte	applyAsByte(byte a1, byte a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default byte	applyAsByteThen(byte a1, byte a2, LToByteFunction<Throwable> handler)
byte	applyAsByteX(byte a1, byte a2) Implement this, but call applyAsByte(byte a1,byte a2)
static LByteBinaryOperator	byteBinaryOp(LByteBinaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V1,V2> LToByteBiFunction<V1,V2>	byteBinaryOpCompose(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
static LByteBinaryOperator	byteBinaryOpThrowing(ExF<Throwable> exF)
static LByteBinaryOperator	byteBinaryOpThrowing(String message, ExMF<Throwable> exF)
static byte	call(byte a1, byte a2, LByteBinaryOperator lambda)
default LByteSupplier	capture(byte a1, byte a2) Captures arguments but delays the evaluation.
default LByteBinaryOperator	compose(LByteUnaryOperator before1, LByteUnaryOperator before2) Allows to manipulate the domain of the function.
static LByteBinaryOperator	composed(LByteUnaryOperator before1, LByteUnaryOperator before2, LByteBinaryOperator after)
static <V1,V2> LToByteBiFunction<V1,V2>	composed(LToByteFunction<? super V1> before1, LToByteFunction<? super V2> before2, LByteBinaryOperator after)
static LByteBinaryOperator	constant(byte r) Creates function that always returns the same value.
static LByteBinaryOperator	failSafe(LByteBinaryOperator func, LByteBinaryOperator failSafe)
default byte	failSafeApplyAsByte(byte a1, byte a2, LByteBinaryOperator failSafe)
static byte	failSafeApplyAsByte(byte a1, byte a2, LByteBinaryOperator func, LByteBinaryOperator failSafe)
default <C1,C2> void	forEach(IndexedRead<C1,aType.aByte> ia1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LByteConsumer 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, byte a1, byte a2, LByteBinaryOperator func) From-To.
static void	fromTo(int min_i, int max_i, byte a1, byte a2, LByteBinaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LByteBinaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default byte	handlingApplyAsByte(byte a1, byte a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static byte	handlingApplyAsByte(byte a1, byte a2, LByteBinaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C1,C2,I2> void	iterate(IndexedRead<C1,aType.aByte> ia1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LByteConsumer 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.aByte> sa1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LByteConsumer 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.aByte> sa1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LByteConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LByteUnaryOperator	lShrink(LByteUnaryOperator left)
default LByteUnaryOperator	lShrinkc(byte a1)
static LByteUnaryOperator	lShrinked(LByteUnaryOperator left, LByteBinaryOperator func)
static LByteUnaryOperator	lShrinkedc(byte a1, LByteBinaryOperator func)
static LByteBinaryOperator	max() Returns function that returns the higher value.
static LByteBinaryOperator	maxBy(Comparator<Byte> comparator) Creates function that returns the lesser value according to the comparator.
static LByteBinaryOperator	min() Returns function that returns the lower value.
static LByteBinaryOperator	minBy(Comparator<Byte> comparator) Creates function that returns the lesser value according to the comparator.
default byte	nestingApplyAsByte(byte a1, byte a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default byte	nonNullApplyAsByte(byte a1, byte a2) Just to mirror the method: Ensures the result is not null
static byte	produceByte(byte a1, byte a2) Does nothing (LByteBinaryOperator) Operator
static LByteBinaryOperator	recursive(LFunction<LByteBinaryOperator,LByteBinaryOperator> selfLambda)
default LByteUnaryOperator	rShrink(LByteUnaryOperator right)
default LByteUnaryOperator	rShrinkc(byte a2)
static LByteUnaryOperator	rShrinked(LByteUnaryOperator right, LByteBinaryOperator func)
static LByteUnaryOperator	rShrinkedc(byte a2, LByteBinaryOperator func)
static LByteBinaryOperator	safe() Safe instance.
static LByteBinaryOperator	safe(LByteBinaryOperator other) Safe wrapping.
static LSupplier<LByteBinaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LByteBinaryOperator>	safeSupplier(LSupplier<LByteBinaryOperator> supplier) Safe supplier.
default byte	shovingApplyAsByte(byte a1, byte a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LBiByteFunction<V>	then(LByteFunction<? extends V> after) Combines two functions together in a order.
default LBiBytePredicate	thenToBool(LBytePredicate after) Combines two functions together in a order.
default LByteBinaryOperator	thenToByte(LByteUnaryOperator after) Combines two functions together in a order.
static void	times(int max_i, byte a1, byte a2, LByteBinaryOperator func) From-To.
static byte	tryApplyAsByte(byte a1, byte a2, LByteBinaryOperator func)
static byte	tryApplyAsByte(byte a1, byte a2, LByteBinaryOperator func, ExWF<RuntimeException> exF)
static byte	tryApplyAsByte(byte a1, byte a2, LByteBinaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static byte	tryApplyAsByteThen(byte a1, byte a2, LByteBinaryOperator func, LToByteFunction<Throwable> handler)
default LByteBinaryOperator	trying(ExWF<RuntimeException> exF)
default LByteBinaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LByteBinaryOperator	tryingThen(LToByteFunction<Throwable> handler)
default byte	tupleApplyAsByte(LBytePair args)
static LByteBinaryOperator	uncurry(LByteFunction<LByteUnaryOperator> 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

applyAsByte

default byte applyAsByte(byte a1,
                         byte a2)

applyAsByteX

byte applyAsByteX(byte a1,
                  byte a2)
           throws Throwable

Implement this, but call applyAsByte(byte a1,byte a2)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LBytePair args)

handlingApplyAsByte

default byte handlingApplyAsByte(byte a1,
                                 byte a2,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsByte

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

trying

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

applyAsByte

default byte applyAsByte(byte a1,
                         byte a2,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsByteThen

default byte applyAsByteThen(byte a1,
                             byte a2,
                             @Nonnull
                             LToByteFunction<Throwable> handler)

tryingThen

default LByteBinaryOperator tryingThen(@Nonnull
                                       LToByteFunction<Throwable> handler)

nestingApplyAsByte

default byte nestingApplyAsByte(byte a1,
                                byte a2)

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

shovingApplyAsByte

default byte shovingApplyAsByte(byte a1,
                                byte a2)

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

handlingApplyAsByte

static byte handlingApplyAsByte(byte a1,
                                byte a2,
                                LByteBinaryOperator func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsByte

static byte tryApplyAsByte(byte a1,
                           byte a2,
                           LByteBinaryOperator func)

tryApplyAsByte

static byte tryApplyAsByte(byte a1,
                           byte a2,
                           LByteBinaryOperator func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsByte

static byte tryApplyAsByte(byte a1,
                           byte a2,
                           LByteBinaryOperator func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsByteThen

static byte tryApplyAsByteThen(byte a1,
                               byte a2,
                               LByteBinaryOperator func,
                               @Nonnull
                               LToByteFunction<Throwable> handler)

failSafeApplyAsByte

default byte failSafeApplyAsByte(byte a1,
                                 byte a2,
                                 @Nonnull
                                 LByteBinaryOperator failSafe)

failSafeApplyAsByte

static byte failSafeApplyAsByte(byte a1,
                                byte a2,
                                LByteBinaryOperator func,
                                @Nonnull
                                LByteBinaryOperator failSafe)

failSafe

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

nonNullApplyAsByte

default byte nonNullApplyAsByte(byte a1,
                                byte 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,
                   byte a1,
                   byte a2,
                   LByteBinaryOperator func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     byte a1,
                     byte a2,
                     LByteBinaryOperator func)

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

times

static void times(int max_i,
                  byte a1,
                  byte a2,
                  LByteBinaryOperator func)

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

lShrink

default LByteUnaryOperator lShrink(LByteUnaryOperator left)

lShrinkc

default LByteUnaryOperator lShrinkc(byte a1)

lShrinked

static LByteUnaryOperator lShrinked(LByteUnaryOperator left,
                                    LByteBinaryOperator func)

lShrinkedc

static LByteUnaryOperator lShrinkedc(byte a1,
                                     LByteBinaryOperator func)

rShrink

default LByteUnaryOperator rShrink(LByteUnaryOperator right)

rShrinkc

default LByteUnaryOperator rShrinkc(byte a2)

rShrinked

static LByteUnaryOperator rShrinked(LByteUnaryOperator right,
                                    LByteBinaryOperator func)

rShrinkedc

static LByteUnaryOperator rShrinkedc(byte a2,
                                     LByteBinaryOperator func)

uncurry

static LByteBinaryOperator uncurry(LByteFunction<LByteUnaryOperator> func)

capture

default LByteSupplier capture(byte a1,
                              byte a2)

Captures arguments but delays the evaluation.

constant

static LByteBinaryOperator constant(byte r)

Creates function that always returns the same value.

apply1stAsByte

@Nonnull
static LByteBinaryOperator apply1stAsByte(@Nonnull
                                                    LByteUnaryOperator func)

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

apply2ndAsByte

@Nonnull
static LByteBinaryOperator apply2ndAsByte(@Nonnull
                                                    LByteUnaryOperator func)

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

byteBinaryOp

@Nonnull
static LByteBinaryOperator byteBinaryOp(@Nonnull
                                                  LByteBinaryOperator lambda)

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

recursive

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

byteBinaryOpThrowing

@Nonnull
static LByteBinaryOperator byteBinaryOpThrowing(@Nonnull
                                                          ExF<Throwable> exF)

byteBinaryOpThrowing

@Nonnull
static LByteBinaryOperator byteBinaryOpThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static byte call(byte a1,
                 byte a2,
                 @Nonnull
                 LByteBinaryOperator lambda)

safe

@Nonnull
static LByteBinaryOperator safe()

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

safeSupplier

@Nonnull
static LSupplier<LByteBinaryOperator> safeSupplier()

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

safe

@Nonnull
static LByteBinaryOperator safe(@Nullable
                                          LByteBinaryOperator other)

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

safeSupplier

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

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

minBy

@Nonnull
static LByteBinaryOperator minBy(@Nonnull
                                           Comparator<Byte> comparator)

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

See Also:

java.util.function.BinaryOperator#minBy}

maxBy

@Nonnull
static LByteBinaryOperator maxBy(@Nonnull
                                           Comparator<Byte> comparator)

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

See Also:

java.util.function.BinaryOperator#maxBy}

min

@Nonnull
static LByteBinaryOperator min()

Returns function that returns the lower value.

See Also:

java.util.function.BinaryOperator#minBy}

max

@Nonnull
static LByteBinaryOperator max()

Returns function that returns the higher value.

See Also:

java.util.function.BinaryOperator#maxBy}

compose

@Nonnull
default LByteBinaryOperator compose(@Nonnull
                                              LByteUnaryOperator before1,
                                              @Nonnull
                                              LByteUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LByteBinaryOperator composed(@Nonnull
                                    LByteUnaryOperator before1,
                                    @Nonnull
                                    LByteUnaryOperator before2,
                                    LByteBinaryOperator after)

byteBinaryOpCompose

@Nonnull
default <V1,V2> LToByteBiFunction<V1,V2> byteBinaryOpCompose(@Nonnull
                                                                       LToByteFunction<? super V1> before1,
                                                                       @Nonnull
                                                                       LToByteFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2> LToByteBiFunction<V1,V2> composed(@Nonnull
                                                 LToByteFunction<? super V1> before1,
                                                 @Nonnull
                                                 LToByteFunction<? super V2> before2,
                                                 LByteBinaryOperator after)

then

@Nonnull
default <V> LBiByteFunction<V> then(@Nonnull
                                              LByteFunction<? extends V> after)

Combines two functions together in a order.

thenToByte

@Nonnull
default LByteBinaryOperator thenToByte(@Nonnull
                                                 LByteUnaryOperator after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBiBytePredicate thenToBool(@Nonnull
                                              LBytePredicate after)

Combines two functions together in a order.

produceByte

static byte produceByte(byte a1,
                        byte a2)

Does nothing (LByteBinaryOperator) Operator

forEach

default <C1,C2> void forEach(IndexedRead<C1,aType.aByte> ia1,
                             C1 source1,
                             IndexedRead<C2,aType.aByte> ia2,
                             C2 source2,
                             LByteConsumer 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.aByte> sa1,
                                C1 source1,
                                IndexedRead<C2,aType.aByte> ia2,
                                C2 source2,
                                LByteConsumer 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.aByte> ia1,
                                C1 source1,
                                SequentialRead<C2,I2,aType.aByte> sa2,
                                C2 source2,
                                LByteConsumer 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.aByte> sa1,
                                   C1 source1,
                                   SequentialRead<C2,I2,aType.aByte> sa2,
                                   C2 source2,
                                   LByteConsumer 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.