FluentFunctions.FluentBiFunction (cyclops-react 1.0.3 API)

java.lang.Object
- com.aol.cyclops.control.FluentFunctions.FluentBiFunction<T1,T2,R>

All Implemented Interfaces:: java.util.function.BiFunction<T1,T2,R>

Enclosing class:: FluentFunctions

public static class FluentFunctions.FluentBiFunction<T1,T2,R>
extends java.lang.Object
implements java.util.function.BiFunction<T1,T2,R>

Constructor Summary

Constructors
Constructor and Description

FluentBiFunction(java.util.function.BiFunction<T1,T2,R> fn)

Constructors
Constructor and Description
`FluentBiFunction(java.util.function.BiFunction<T1,T2,R> fn)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`after(TriConsumer<T1,T2,R> action)` Apply after advice to this BiFunction
`<V> FluentFunctions.FluentBiFunction<T1,T2,V>`	`andThen(java.util.function.Function<? super R,? extends V> after)`
`R`	`apply(T1 t1, T2 t2)`
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`around(java.util.function.Function<FluentFunctions.Advice2<T1,T2,R>,R> around)` Apply around advice to this BiFunction
`java.util.concurrent.CompletableFuture<FluentFunctions.FluentBiFunction<T1,T2,R>>`	`async(java.util.concurrent.Executor ex)` Wrap this BiFunction in a CompletableFuture for asyncrhonous execution
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`before(java.util.function.BiConsumer<T1,T2> action)` Apply before advice to this BiFunction
`FluentFunctions.FluentFunction<T1,java.util.function.Function<T2,R>>`	`curry()` Curry this BiFunction, that is convert it from a BiFunction that accepts two input parameters to a 'chain' of two Functions that accept a single parameter
`ReactiveSeq<R>`	`generate(T1 input1, T2 input2)` Generate an infinite Stream by applying the input parameters to this function repeatedly
`ReactiveSeq<R>`	`iterate(T1 seed1, T2 seed2, java.util.function.Function<R,org.jooq.lambda.tuple.Tuple2<T1,T2>> mapToTypeAndSplit)` Generate an infinite Stream from the provided seed values and mapping function.
`FluentFunctions.FluentBiFunction<java.util.Optional<T1>,java.util.Optional<T2>,java.util.Optional<R>>`	`lift()`
`FluentFunctions.FluentBiFunction<T1,T2,java.util.concurrent.CompletableFuture<R>>`	`liftAsync(java.util.concurrent.Executor ex)`
`FluentFunctions.FluentBiFunction<AnyM<T1>,AnyM<T2>,AnyM<R>>`	`liftM()`
`<X extends java.lang.Throwable> FluentFunctions.FluentBiFunction<T1,T2,Try<R,X>>`	`liftTry(java.lang.Class<X>... classes)`
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`log(java.util.function.Consumer<java.lang.String> logger, java.util.function.Consumer<java.lang.Throwable> error)` A BiFunction that logs it's success or error states to the provided Consumers
`<R1> FluentFunctions.FluentBiFunction<T1,T2,R1>`	`matches(java.util.function.Function<Matchable.CheckValue1<R,R1>,Matchable.CheckValue1<R,R1>> case1, java.util.function.Supplier<? extends R1> otherwise)` A BiFunction that triggers an event if the result matches the case provided, or generates a new value from the supplier provided if not
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`memoize()`
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`memoize(Cacheable<R> cache)` This methods creates a caching version of this BiFunction, caching is implemented via the Cacheable wrapper, that can be used to wrap any concrete cache implementation E.g.
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`name(java.lang.String name)`
`FluentFunctions.FluentFunction<T2,R>`	`partiallyApply(T1 param)` Partially apply the provided parameter as the first parameter to this BiFunction to generate a Function (single input value)
`FluentFunctions.FluentSupplier<R>`	`partiallyApply(T1 param1, T2 param2)` Partially apply the provided parameters to this BiFunction to generate a Supplier (that takes no inputs)
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`println()`
`<X extends java.lang.Throwable> FluentFunctions.FluentBiFunction<T1,T2,R>`	`recover(java.lang.Class<X> type, java.util.function.BiFunction<T1,T2,R> onError)` A BiFunction that can recover from the specified exception types, using the provided recovery Function
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`retry(int times, int backoffStartTime)` A BiFunction capable of retrying on failure using an exponential backoff strategy
`FluentFunctions.FluentBiFunction<T1,T2,R>`	`visitEvent(java.util.function.Consumer<R> eventConsumer, java.util.function.Consumer<java.lang.Throwable> errorConsumer)` Visit the result of this BiFunction once it has been executed, if the Function executes successfully the result will be passes to the eventConsumer, if there is an error it will be passed to the errorConsumer

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FluentBiFunction

public FluentBiFunction(java.util.function.BiFunction<T1,T2,R> fn)

Method Detail

apply
```
public R apply(T1 t1,
               T2 t2)
```
Specified by:

apply in interface java.util.function.BiFunction<T1,T2,R>

before
```
public FluentFunctions.FluentBiFunction<T1,T2,R> before(java.util.function.BiConsumer<T1,T2> action)
```
Apply before advice to this BiFunction

Parameters:

action - BiConsumer to recieve input parameters to BiFunction

Returns:

BiFunction with before advice attached

after
```
public FluentFunctions.FluentBiFunction<T1,T2,R> after(TriConsumer<T1,T2,R> action)
```
Apply after advice to this BiFunction

Parameters:

action - TriConsumer to recieve input parameters and return value from BiFunction after it has executed

Returns:

BiFunction with after advice attached

around

public FluentFunctions.FluentBiFunction<T1,T2,R> around(java.util.function.Function<FluentFunctions.Advice2<T1,T2,R>,R> around)

Apply around advice to this BiFunction

  
 public int add(Integer a,Integer b ){
               return a+b;
           }
    FluentFunctions.of(this::add)
                       .around(advice->advice.proceed1(advice.param1+1))
                       .println()
                       .apply(10,1)
    
   //12   (input = 10+1 with advice + 1 = 12)

Parameters:: around - Function that allows the execution of this BiFunction to be contolled via it's input parameter
Returns:: BiFunction with around advice attached

partiallyApply
```
public FluentFunctions.FluentFunction<T2,R> partiallyApply(T1 param)
```
Partially apply the provided parameter as the first parameter to this BiFunction to generate a Function (single input value)

Parameters:

param - Input parameter to Partially Applied

Returns:

A Function generated from the BiFunction with the first parameter already applied

partiallyApply
```
public FluentFunctions.FluentSupplier<R> partiallyApply(T1 param1,
                                                        T2 param2)
```
Partially apply the provided parameters to this BiFunction to generate a Supplier (that takes no inputs)

Parameters:

param1 - First Input parameter

param2 - Second Input parameter

Returns:

Supplier generated from the partial application of the provided input parameters to this BiFunction

curry

public FluentFunctions.FluentFunction<T1,java.util.function.Function<T2,R>> curry()

Curry this BiFunction, that is convert it from a BiFunction that accepts two input parameters to a 'chain' of two Functions that accept a single parameter

  
 public int add(Integer a,Integer b ){
               return a+b;
           }
 
      FluentFunctions.of(this::add)
                               .curry()
                               .apply(1)
                               .apply(2);
                               
                //3

Returns:: Curried function

memoize
```
public FluentFunctions.FluentBiFunction<T1,T2,R> memoize()
```
Returns:

A caching (memoizing) version of this BiFunction, outputs for all inputs will be cached

memoize

public FluentFunctions.FluentBiFunction<T1,T2,R> memoize(Cacheable<R> cache)

This methods creates a caching version of this BiFunction, caching is implemented via the Cacheable wrapper, that can be used to wrap any concrete cache implementation E.g. to use a Guava cache for memoization

  
 
 Cache<Object, Integer> cache = CacheBuilder.newBuilder()
                   .maximumSize(1000)
                   .expireAfterWrite(10, TimeUnit.MINUTES)
                   .build();
        
                   called=0;
            BiFunction<Integer,Integer,Integer> fn = FluentFunctions.of(this::add)
                                                                    .name("myFunction")
                                                                     .memoize((key,f)->cache.get(key,()->f.apply(key)));
        
            fn.apply(10,1);
            fn.apply(10,1);
            fn.apply(10,1);
        
            assertThat(called,equalTo(1));

Parameters:: cache - Cache implementation wrapper
Returns:: A caching (memoizing) version of this BiFunction, outputs for all inputs will be cached (unless ejected from the cache)

name
```
public FluentFunctions.FluentBiFunction<T1,T2,R> name(java.lang.String name)
```
Parameters:

name - To give this BiFunction

Returns:

A BiFunction with a name (useful for logging purposes)

log

public FluentFunctions.FluentBiFunction<T1,T2,R> log(java.util.function.Consumer<java.lang.String> logger,
                                                     java.util.function.Consumer<java.lang.Throwable> error)

A BiFunction that logs it's success or error states to the provided Consumers

Parameters:: logger - Success logger; error - Failure logger
Returns:: BiFunction that logs it's state

visitEvent
```
public FluentFunctions.FluentBiFunction<T1,T2,R> visitEvent(java.util.function.Consumer<R> eventConsumer,
                                                            java.util.function.Consumer<java.lang.Throwable> errorConsumer)
```
Visit the result of this BiFunction once it has been executed, if the Function executes successfully the result will be passes to the eventConsumer, if there is an error it will be passed to the errorConsumer

Parameters:

eventConsumer - Consumer to recieve result on successful execution

errorConsumer - Consumer to recieve error on failure

Returns:

BiFunction with event vistor attached.

println
```
public FluentFunctions.FluentBiFunction<T1,T2,R> println()
```
Returns:

Function that logs it's result or error to the console

recover

public <X extends java.lang.Throwable> FluentFunctions.FluentBiFunction<T1,T2,R> recover(java.lang.Class<X> type,
                                                                                         java.util.function.BiFunction<T1,T2,R> onError)

A BiFunction that can recover from the specified exception types, using the provided recovery Function

Parameters:: type - Recoverable exception types; onError - Recovery BiFunction
Returns:: BiFunction capable of error recovery

retry
```
public FluentFunctions.FluentBiFunction<T1,T2,R> retry(int times,
                                                       int backoffStartTime)
```
A BiFunction capable of retrying on failure using an exponential backoff strategy

Parameters:

times - Number of times to retry

backoffStartTime - Wait time before first retry

Returns:

BiFunction with a retry strategy

matches
```
public <R1> FluentFunctions.FluentBiFunction<T1,T2,R1> matches(java.util.function.Function<Matchable.CheckValue1<R,R1>,Matchable.CheckValue1<R,R1>> case1,
                                                               java.util.function.Supplier<? extends R1> otherwise)
```
A BiFunction that triggers an event if the result matches the case provided, or generates a new value from the supplier provided if not

Parameters:

case1 - Case against which the value returned by this Function will be compared

otherwise - Supplier to generate an alterantive value if this value does not match the provided case

Returns:

BiFunction that matches it's value against the supplied case

iterate

public ReactiveSeq<R> iterate(T1 seed1,
                              T2 seed2,
                              java.util.function.Function<R,org.jooq.lambda.tuple.Tuple2<T1,T2>> mapToTypeAndSplit)

Generate an infinite Stream from the provided seed values and mapping function. The supplied mapping function is inverted taking an input of type R and returning two outputs T1, T2 (in a Tuple)

  
   FluentFunctions.of(this::add) 
                            .iterate(1,2,(i)->Tuple.tuple(i,i))
                            .limit(10)
                            .printOut();
 
   //3
               6
               12
               24
               48
               96
               192
               384
               768
               1536

Parameters:: seed1 - Initial input parameter 1; seed2 - Initial input parameter 2; mapToTypeAndSplit - Reversed mapping function
Returns:: Infinite Stream

generate
```
public ReactiveSeq<R> generate(T1 input1,
                               T2 input2)
```
Generate an infinite Stream by applying the input parameters to this function repeatedly

Parameters:

input1 - First input parameter

input2 - Second input parameter

Returns:

Infinite Stream

lift

public FluentFunctions.FluentBiFunction<java.util.Optional<T1>,java.util.Optional<T2>,java.util.Optional<R>> lift()

Returns:: A BiFunction that accepts and returns Optionals

liftTry

public <X extends java.lang.Throwable> FluentFunctions.FluentBiFunction<T1,T2,Try<R,X>> liftTry(java.lang.Class<X>... classes)

Parameters:: classes - Classes to catch exceptions for
Returns:: BiFunction that returns it's result in a Try

liftM

public FluentFunctions.FluentBiFunction<AnyM<T1>,AnyM<T2>,AnyM<R>> liftM()

Returns:: A BiFunction that accepts and returns a generic Monad instance

liftAsync
```
public FluentFunctions.FluentBiFunction<T1,T2,java.util.concurrent.CompletableFuture<R>> liftAsync(java.util.concurrent.Executor ex)
```
Parameters:

ex - Executor to execute this function on

Returns:

A BiFunction that executes asynchronously on the provided Executor returning a CompletableFuture as it's result

async

public java.util.concurrent.CompletableFuture<FluentFunctions.FluentBiFunction<T1,T2,R>> async(java.util.concurrent.Executor ex)

Wrap this BiFunction in a CompletableFuture for asyncrhonous execution

  
   FluentFunctions.of(this::add)
                            .async(ex)
                            .thenApplyAsync(f->f.apply(4,1))
                            .join()

Parameters:: ex - Executor to execute this BiFunction on
Returns:: CompletableFuture containing BiFunction for asyncrhonous execution

andThen

public <V> FluentFunctions.FluentBiFunction<T1,T2,V> andThen(java.util.function.Function<? super R,? extends V> after)

Specified by:: andThen in interface java.util.function.BiFunction<T1,T2,R>

Class FluentFunctions.FluentBiFunction<T1,T2,R>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FluentBiFunction

Method Detail

apply

before

after

around

partiallyApply

partiallyApply

curry

memoize

memoize

name

log

visitEvent

println

recover

retry

matches

iterate

generate

lift

liftTry

liftM

liftAsync

async

andThen