LToLongFunction (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aLong>, Domain, Domain1<aType.a<T>>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, OFunction<T,aType.aLong>, java.util.function.ToLongFunction<T>

All Known Implementing Classes:

LToLongFunction.LToLongFunctionSingle
```
@FunctionalInterface
public interface LToLongFunction<T>
extends java.util.function.ToLongFunction<T>, MetaFunction, MetaInterface.NonThrowing, OFunction<T,aType.aLong>, Codomain<aType.aLong>, Domain1<aType.a<T>>
```
Non-throwing functional interface (lambda) LToLongFunction for Java 8.
Type: function
Domain (lvl: 1): T a
Co-domain: long
Special case of function that corresponds to expressions like (iterator) -> Iterator::next

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LToLongFunction.LToLongFunctionSingle<T>
- Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface
  MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LToLongFunction.LToLongFunctionSingle<T>`

Field Summary

Fields
Modifier and Type Field and Description

static String DESCRIPTION

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default long`	`applyAsLong(T a)`
`default long`	`applyAsLong(T a, ExWF<RuntimeException> exF)`
`default long`	`applyAsLong(T a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default long`	`applyAsLongThen(T a, LToLongFunction<Throwable> handler)`
`long`	`applyAsLongX(T a)` Implement this, but call applyAsLong(T a)
`static <T> long`	`call(T a, LToLongFunction<T> lambda)`
`default LLongSupplier`	`capture(T a)` Captures arguments but delays the evaluation.
`default <V2> LToLongFunction<V2>`	`cast()` Cast that replace generics.
`static <V2,T> LToLongFunction<V2>`	`cast(LToLongFunction<T> function)` Cast that replace generics.
`default <V> LToLongFunction<V>`	`compose(LFunction<? super V,? extends T> before)` Allows to manipulate the domain of the function.
`static <V,T> LToLongFunction<V>`	`composed(LFunction<? super V,? extends T> before, LToLongFunction<T> after)`
`static <T> LToLongFunction<T>`	`constant(long r)` Creates function that always returns the same value.
`static <T> LToLongFunction<T>`	`failSafe(LToLongFunction<T> func, LToLongFunction<T> failSafe)`
`default long`	`failSafeApplyAsLong(T a, LToLongFunction<T> failSafe)`
`static <T> long`	`failSafeApplyAsLong(T a, LToLongFunction<T> func, LToLongFunction<T> failSafe)`
`default <C0> void`	`forEach(IndexedRead<C0,aType.a<T>> ia, C0 source, LLongConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static <T> void`	`fromTill(int min_i, int max_i, T a, LToLongFunction<T> func)` From-To.
`static <T> void`	`fromTo(int min_i, int max_i, T a, LToLongFunction<T> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LToLongFunction<T>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default long`	`handlingApplyAsLong(T a, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T> long`	`handlingApplyAsLong(T a, LToLongFunction<T> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`default <C0,I0> void`	`iterate(SequentialRead<C0,I0,aType.a<T>> sa, C0 source, LLongConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default long`	`nestingApplyAsLong(T a)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default long`	`nonNullApplyAsLong(T a)` Just to mirror the method: Ensures the result is not null
`static <T> long`	`produceLong(T a)` Does nothing (LToLongFunction) Function
`static <T> LToLongFunction<T>`	`recursive(LFunction<LToLongFunction<T>,LToLongFunction<T>> selfLambda)`
`static <T> LToLongFunction<T>`	`safe()` Safe instance.
`static <T> LToLongFunction<T>`	`safe(LToLongFunction<T> other)` Safe wrapping.
`static <T> LSupplier<LToLongFunction<T>>`	`safeSupplier()` Safe instance supplier.
`static <T> LSupplier<LToLongFunction<T>>`	`safeSupplier(LSupplier<LToLongFunction<T>> supplier)` Safe supplier.
`default long`	`shovingApplyAsLong(T a)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default <V> LFunction<T,V>`	`then(LLongFunction<? extends V> after)` Combines two functions together in a order.
`default LPredicate<T>`	`thenToBool(LLongPredicate after)` Combines two functions together in a order.
`default LToByteFunction<T>`	`thenToByte(LLongToByteFunction after)` Combines two functions together in a order.
`default LToCharFunction<T>`	`thenToChar(LLongToCharFunction after)` Combines two functions together in a order.
`default LToDblFunction<T>`	`thenToDbl(LLongToDblFunction after)` Combines two functions together in a order.
`default LToFltFunction<T>`	`thenToFlt(LLongToFltFunction after)` Combines two functions together in a order.
`default LToIntFunction<T>`	`thenToInt(LLongToIntFunction after)` Combines two functions together in a order.
`default LToLongFunction<T>`	`thenToLong(LLongUnaryOperator after)` Combines two functions together in a order.
`default LToSrtFunction<T>`	`thenToSrt(LLongToSrtFunction after)` Combines two functions together in a order.
`static <T> void`	`times(int max_i, T a, LToLongFunction<T> func)` From-To.
`static <T> LToLongFunction<T>`	`toLongFunc(LToLongFunction<T> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T> LToLongFunction<T>`	`toLongFuncThrowing(ExF<Throwable> exF)`
`static <T> LToLongFunction<T>`	`toLongFuncThrowing(String message, ExMF<Throwable> exF)`
`static <T> long`	`tryApplyAsLong(T a, LToLongFunction<T> func)`
`static <T> long`	`tryApplyAsLong(T a, LToLongFunction<T> func, ExWF<RuntimeException> exF)`
`static <T> long`	`tryApplyAsLong(T a, LToLongFunction<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T> long`	`tryApplyAsLongThen(T a, LToLongFunction<T> func, LToLongFunction<Throwable> handler)`
`default LToLongFunction<T>`	`trying(ExWF<RuntimeException> exF)`
`default LToLongFunction<T>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LToLongFunction<T>`	`tryingThen(LToLongFunction<Throwable> handler)`
`default long`	`tupleApplyAsLong(LSingle<T> args)`
`default LToLongFunction`	`untyped()` Cast that removes generics.
`static <T> LToLongFunction<T>`	`wrap(java.util.function.ToLongFunction<T> other)` Wraps JRE instance.

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

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, isOperator, isPredicate, isSupplier

Field Detail
- DESCRIPTION
```
static final String DESCRIPTION
```
  See Also:
  
  Constant Field Values

Method Detail

applyAsLong
```
default long applyAsLong(T a)
```
Specified by:

applyAsLong in interface java.util.function.ToLongFunction<T>

applyAsLongX
```
long applyAsLongX(T a)
           throws Throwable
```
Implement this, but call applyAsLong(T a)

Throws:

Throwable

tupleApplyAsLong

default long tupleApplyAsLong(LSingle<T> args)

handlingApplyAsLong

default long handlingApplyAsLong(T a,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LToLongFunction<T> handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsLong

default long applyAsLong(T a,
                         @Nonnull
                         ExWMF<RuntimeException> exF,
                         @Nonnull
                         String newMessage,
                         @Nullable
                         Object... messageParams)

trying

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

applyAsLong

default long applyAsLong(T a,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

default LToLongFunction<T> trying(@Nonnull
                                  ExWF<RuntimeException> exF)

applyAsLongThen

default long applyAsLongThen(T a,
                             @Nonnull
                             LToLongFunction<Throwable> handler)

tryingThen

default LToLongFunction<T> tryingThen(@Nonnull
                                      LToLongFunction<Throwable> handler)

nestingApplyAsLong
```
default long nestingApplyAsLong(T a)
```
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApplyAsLong
```
default long shovingApplyAsLong(T a)
```
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApplyAsLong

static <T> long handlingApplyAsLong(T a,
                                    LToLongFunction<T> func,
                                    HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsLong

static <T> long tryApplyAsLong(T a,
                               LToLongFunction<T> func)

tryApplyAsLong

static <T> long tryApplyAsLong(T a,
                               LToLongFunction<T> func,
                               @Nonnull
                               ExWMF<RuntimeException> exF,
                               @Nonnull
                               String newMessage,
                               @Nullable
                               Object... messageParams)

tryApplyAsLong

static <T> long tryApplyAsLong(T a,
                               LToLongFunction<T> func,
                               @Nonnull
                               ExWF<RuntimeException> exF)

tryApplyAsLongThen

static <T> long tryApplyAsLongThen(T a,
                                   LToLongFunction<T> func,
                                   @Nonnull
                                   LToLongFunction<Throwable> handler)

failSafeApplyAsLong

default long failSafeApplyAsLong(T a,
                                 @Nonnull
                                 LToLongFunction<T> failSafe)

failSafeApplyAsLong

static <T> long failSafeApplyAsLong(T a,
                                    LToLongFunction<T> func,
                                    @Nonnull
                                    LToLongFunction<T> failSafe)

failSafe

static <T> LToLongFunction<T> failSafe(LToLongFunction<T> func,
                                       @Nonnull
                                       LToLongFunction<T> failSafe)

nonNullApplyAsLong
```
default long nonNullApplyAsLong(T a)
```
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 <T> void fromTo(int min_i,
                       int max_i,
                       T a,
                       LToLongFunction<T> func)

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

fromTill

static <T> void fromTill(int min_i,
                         int max_i,
                         T a,
                         LToLongFunction<T> func)

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

times

static <T> void times(int max_i,
                      T a,
                      LToLongFunction<T> func)

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

untyped
```
default LToLongFunction untyped()
```
Cast that removes generics.

cast

default <V2> LToLongFunction<V2> cast()

Cast that replace generics.

cast

static <V2,T> LToLongFunction<V2> cast(LToLongFunction<T> function)

Cast that replace generics.

capture
```
default LLongSupplier capture(T a)
```
Captures arguments but delays the evaluation.

constant
```
static <T> LToLongFunction<T> constant(long r)
```
Creates function that always returns the same value.

toLongFunc

@Nonnull
static <T> LToLongFunction<T> toLongFunc(@Nonnull
                                                   LToLongFunction<T> lambda)

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

recursive

@Nonnull
static <T> LToLongFunction<T> recursive(@Nonnull
                                                  LFunction<LToLongFunction<T>,LToLongFunction<T>> selfLambda)

toLongFuncThrowing

@Nonnull
static <T> LToLongFunction<T> toLongFuncThrowing(@Nonnull
                                                           ExF<Throwable> exF)

toLongFuncThrowing

@Nonnull
static <T> LToLongFunction<T> toLongFuncThrowing(String message,
                                                           @Nonnull
                                                           ExMF<Throwable> exF)

call

static <T> long call(T a,
                     @Nonnull
                     LToLongFunction<T> lambda)

wrap

@Nonnull
static <T> LToLongFunction<T> wrap(java.util.function.ToLongFunction<T> other)

Wraps JRE instance.

safe
```
@Nonnull
static <T> LToLongFunction<T> safe()
```
Safe instance. That always returns the same value (as produceLong).

safeSupplier
```
@Nonnull
static <T> LSupplier<LToLongFunction<T>> safeSupplier()
```
Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static <T> LToLongFunction<T> safe(@Nullable
                                             LToLongFunction<T> other)

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

safeSupplier

@Nonnull
static <T> LSupplier<LToLongFunction<T>> safeSupplier(@Nullable
                                                                LSupplier<LToLongFunction<T>> supplier)

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

compose

@Nonnull
default <V> LToLongFunction<V> compose(@Nonnull
                                                 LFunction<? super V,? extends T> before)

Allows to manipulate the domain of the function.