FluentFunctions (cyclops-react 1.0.1 API)

java.lang.Object
- com.aol.cyclops.control.FluentFunctions

```
public class FluentFunctions
extends java.lang.Object
```
Fluent API for working with java.util.Function types Supports caching (memoization) aspects (before, after, around) logging retry recovery Async execution Reader monad Partial application Currying Pattern Matching

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`FluentFunctions.Advice0<R>`
`static class`	`FluentFunctions.Advice1<T,R>`
`static class`	`FluentFunctions.Advice2<T1,T2,R>`
`static class`	`FluentFunctions.Advice3<T1,T2,T3,R>`
`static class`	`FluentFunctions.FluentBiFunction<T1,T2,R>`
`static class`	`FluentFunctions.FluentFunction<T,R>`
`static class`	`FluentFunctions.FluentSupplier<R>`
`static class`	`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`

Constructor Summary

Constructors
Constructor and Description

FluentFunctions()

Constructors
Constructor and Description
`FluentFunctions()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T1,T2> FluentFunctions.FluentBiFunction<T1,T2,org.jooq.lambda.tuple.Tuple2<T1,T2>>`	`checkedExpression(org.jooq.lambda.fi.util.function.CheckedBiConsumer<T1,T2> action)` Convert a CheckedBiConsumer into a FluentBiConsumer that returns it's input in a tuple
`static <T> FluentFunctions.FluentFunction<T,T>`	`checkedExpression(org.jooq.lambda.fi.util.function.CheckedConsumer<T> action)` Convert a checked statement (e.g.
`static <T1,T2> FluentFunctions.FluentBiFunction<T1,T2,org.jooq.lambda.tuple.Tuple2<T1,T2>>`	`expression(java.util.function.BiConsumer<? super T1,? super T2> action)` Convert a BiConsumer into a FluentBiFunction that returns it's input in a Tuple
`static <T> FluentFunctions.FluentFunction<T,T>`	`expression(java.util.function.Consumer<? super T> action)` Convert a statement (e.g.
`static <T1,T2,R> FluentFunctions.FluentBiFunction<T1,T2,R>`	`of(java.util.function.BiFunction<T1,T2,R> fn)` Convert a BiFunction to a FluentBiFunction
`static <T,R> FluentFunctions.FluentFunction<T,R>`	`of(java.util.function.Function<T,R> fn)` Construct a FluentFunction from a Function
`static <R> FluentFunctions.FluentSupplier<R>`	`of(java.util.function.Supplier<R> supplier)` Construct a FluentSupplier from a Supplier
`static <T1,T2,T3,R> FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`of(TriFunction<T1,T2,T3,R> fn)` Convert a CheckedTriFunction to a FluentTriFunction
`static <T1,T2,R> FluentFunctions.FluentBiFunction<T1,T2,R>`	`ofChecked(org.jooq.lambda.fi.util.function.CheckedBiFunction<T1,T2,R> fn)` Construct a FluentBiFunction from a CheckedBiFunction
`static <T,R> FluentFunctions.FluentFunction<T,R>`	`ofChecked(org.jooq.lambda.fi.util.function.CheckedFunction<T,R> fn)` Construct a FluentFunction from a CheckedFunction
`static <R> FluentFunctions.FluentSupplier<R>`	`ofChecked(org.jooq.lambda.fi.util.function.CheckedSupplier<R> supplier)` Construct a FluentSupplier from a checked Supplier
`static <T1,T2,T3,R> FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`ofChecked(CheckedTriFunction<T1,T2,T3,R> fn)` Convert a CheckedTriFunction to a FluentTriFunction

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

Constructor Detail
- FluentFunctions
```
public FluentFunctions()
```

Method Detail

ofChecked

public static <R> FluentFunctions.FluentSupplier<R> ofChecked(org.jooq.lambda.fi.util.function.CheckedSupplier<R> supplier)

Construct a FluentSupplier from a checked Supplier

 
 FluentFunctions.ofChecked(this::exceptionalFirstTime)
    					.recover(IOException.class, ()->"hello boo!")
    					.println()
    					.get()

Parameters:: supplier - that throws CheckedExcpetion
Returns:: FluentSupplier

of

public static <R> FluentFunctions.FluentSupplier<R> of(java.util.function.Supplier<R> supplier)

Construct a FluentSupplier from a Supplier

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

Parameters:: supplier - to make Fluent
Returns:: FluentSupplier

ofChecked

public static <T,R> FluentFunctions.FluentFunction<T,R> ofChecked(org.jooq.lambda.fi.util.function.CheckedFunction<T,R> fn)

Construct a FluentFunction from a CheckedFunction

  
 FluentFunctions.ofChecked(this::exceptionalFirstTime)
    					.recover(IOException.class, in->in+"boo!")
    					.println()
    					.apply("hello ")

Parameters:: fn - CheckedFunction
Returns:: FluentFunction

of

public static <T,R> FluentFunctions.FluentFunction<T,R> of(java.util.function.Function<T,R> fn)

Construct a FluentFunction from a Function

  
 FluentFunctions.of(this::addOne)
    				   .around(advice->advice.proceed(advice.param+1))
    				   .println()
    				   .apply(10)

Parameters:: fn - Function
Returns:: FluentFunction

ofChecked

public static <T1,T2,R> FluentFunctions.FluentBiFunction<T1,T2,R> ofChecked(org.jooq.lambda.fi.util.function.CheckedBiFunction<T1,T2,R> fn)

Construct a FluentBiFunction from a CheckedBiFunction

  
 FluentFunctions.ofChecked(this::exceptionalFirstTime)
    				   .println()
    				   .retry(2,500)
    				   .apply("hello","woo!")

Parameters:: fn - CheckedBiFunction
Returns:: FluentBiFunction

of

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

Convert a BiFunction to a FluentBiFunction

  
 CompletableFuture<Integer> cf = FluentFunctions.of(this::add)
    												  .liftAsync(ex)
    												  .apply(1,1)

Parameters:: fn - BiFunction to convert
Returns:: FluentBiFuntion

ofChecked

public static <T1,T2,T3,R> FluentFunctions.FluentTriFunction<T1,T2,T3,R> ofChecked(CheckedTriFunction<T1,T2,T3,R> fn)

Convert a CheckedTriFunction to a FluentTriFunction

 
       FluentFunctions.ofChecked(this::exceptionalFirstTime)
    				   .println()
    				   .retry(2,500)
    				   .apply("hello","woo!","h")

Parameters:: fn - CheckedTriFunction to convert
Returns:: FluentTriFunction

of

public static <T1,T2,T3,R> FluentFunctions.FluentTriFunction<T1,T2,T3,R> of(TriFunction<T1,T2,T3,R> fn)

Convert a CheckedTriFunction to a FluentTriFunction

 
       FluentFunctions.of(this::add)	
    				  .matches(-1,c->c.hasValues(3).then(i->3))
    				  .apply(1,1,1)

Parameters:: fn - TriFunction to convert
Returns:: FluentTriFunction

expression

public static <T> FluentFunctions.FluentFunction<T,T> expression(java.util.function.Consumer<? super T> action)

Convert a statement (e.g. a method or Consumer with no return value) to an Expression. The input is returned as output

  
 FluentFunctions.expression(System.out::println)
    				   .apply("hello");
    	
    	//hello

Parameters:: action - Consumer
Returns:: FluentFunction

checkedExpression

public static <T> FluentFunctions.FluentFunction<T,T> checkedExpression(org.jooq.lambda.fi.util.function.CheckedConsumer<T> action)

Convert a checked statement (e.g. a method or Consumer with no return value that throws a Checked Exception) to a fluent expression (FluentFunction). The input is returned as output

  
 public void print(String input) throws IOException{
    	  System.out.println(input);
        }
        FluentFunctions.checkedExpression(this::print)
    			   .apply("hello")

Parameters:: action -
Returns:: FluentFunction

expression

public static <T1,T2> FluentFunctions.FluentBiFunction<T1,T2,org.jooq.lambda.tuple.Tuple2<T1,T2>> expression(java.util.function.BiConsumer<? super T1,? super T2> action)

Convert a BiConsumer into a FluentBiFunction that returns it's input in a Tuple

  
 public void withTwo(Integer a,Integer b){
    	 System.out.println(a+b);
    	}
    	FluentFunctions.expression(this::withTwo)
    				   .apply(1,2)
    				   
    	//returns Tuple2[1,2]

Parameters:: action - BiConsumer
Returns:: FluentBiFunction

checkedExpression

public static <T1,T2> FluentFunctions.FluentBiFunction<T1,T2,org.jooq.lambda.tuple.Tuple2<T1,T2>> checkedExpression(org.jooq.lambda.fi.util.function.CheckedBiConsumer<T1,T2> action)

Convert a CheckedBiConsumer into a FluentBiConsumer that returns it's input in a tuple

  
 public void printTwo(String input1,String input2) throws IOException{
    	System.out.println(input1);
    	System.out.println(input2);
       }
 
 FluentFunctions.checkedExpression(this::printTwo)
    				   .apply("hello","world");
    				   
    	//returns Tuple2["hello","world"]

Parameters:: action -
Returns:

Class FluentFunctions

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FluentFunctions

Method Detail

ofChecked

of

ofChecked

of

ofChecked

of

ofChecked

of

expression

checkedExpression

expression

checkedExpression