FluentFunctions.FluentFunction (cyclops-react 1.0.5 API)

java.lang.Object
- com.aol.cyclops.control.FluentFunctions.FluentFunction<T,R>

All Implemented Interfaces:: Reader<T,R>, Functor<R>, java.util.function.Function<T,R>

Enclosing class:: FluentFunctions

public static class FluentFunctions.FluentFunction<T,R>
extends java.lang.Object
implements java.util.function.Function<T,R>, Reader<T,R>

Constructor Summary

Constructors
Constructor and Description

FluentFunction(java.util.function.Function<T,R> fn)

Constructors
Constructor and Description
`FluentFunction(java.util.function.Function<T,R> fn)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FluentFunctions.FluentFunction<T,R>`	`after(java.util.function.BiConsumer<T,R> action)` Apply After advice to this function capturing both the input and the output with the provided BiConsumer
`<V> java.util.function.Function<T,V>`	`andThen(java.util.function.Function<? super R,? extends V> after)`
`R`	`apply(T t)`
`FluentFunctions.FluentFunction<T,R>`	`around(java.util.function.Function<FluentFunctions.Advice1<T,R>,R> around)` Apply around advice to this function, captures input allows output to be controlled by the advice
`java.util.concurrent.CompletableFuture<FluentFunctions.FluentFunction<T,R>>`	`async(java.util.concurrent.Executor ex)` Move this function into an asynchronous context
`FluentFunctions.FluentFunction<T,R>`	`before(java.util.function.Consumer<T> action)` Apply before advice to this function, capture the input with the provided Consumer
`<V> java.util.function.Function<V,R>`	`compose(java.util.function.Function<? super V,? extends T> before)`
`<R1> FluentFunctions.FluentFunction<T,R1>`	`flatMap(java.util.function.Function<? super R,? extends Reader<T,R1>> f)` FlatMap this Reader by applying the prodived function and unnesting to a single Reader
`ReactiveSeq<R>`	`generate(T input)`
`ReactiveSeq<R>`	`iterate(T seed, java.util.function.Function<R,T> mapToType)` Generate an infinite Stream that iterates from the specified seed using the currently wrapped function e.g.
`FluentFunctions.FluentFunction<java.util.Optional<T>,java.util.Optional<R>>`	`lift()`
`FluentFunctions.FluentFunction<T,java.util.concurrent.CompletableFuture<R>>`	`liftAsync(java.util.concurrent.Executor ex)`
`FluentFunctions.FluentFunction<AnyM<T>,AnyM<R>>`	`liftM()`
`<X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,Try<R,X>>`	`liftTry(java.lang.Class<X>... classes)`
`FluentFunctions.FluentFunction<T,R>`	`log(java.util.function.Consumer<java.lang.String> logger, java.util.function.Consumer<java.lang.Throwable> error)` A Function that logs it's success or error states to the provided Consumers
`<R1> FluentFunctions.FluentFunction<T,R1>`	`map(java.util.function.Function<? super R,? extends R1> f2)` Transform this functor using the supplied transformation function
`<R1> FluentFunctions.FluentFunction<T,R1>`	`matches(java.util.function.Function<Matchable.CheckValue1<R,R1>,Matchable.CheckValue1<R,R1>> case1, java.util.function.Supplier<? extends R1> otherwise)` A Function that triggers an event if the result matches the case provided, or generates a new value from the supplier provided if not
`FluentFunctions.FluentFunction<T,R>`	`memoize()`
`FluentFunctions.FluentFunction<T,R>`	`memoize(Cacheable<R> cache)`
`FluentFunctions.FluentFunction<T,R>`	`name(java.lang.String name)`
`FluentFunctions.FluentSupplier<R>`	`partiallyApply(T param)` Partially apply the provided value to this function, to turn it into a Supplier
`FluentFunctions.FluentFunction<T,R>`	`println()`
`<X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,R>`	`recover(java.lang.Class<X> type, java.util.function.Function<T,R> onError)` A Function that can recover from the specified exception types, using the provided recovery Function
`FluentFunctions.FluentFunction<T,R>`	`retry(int times, int backoffStartTime)` A Function capable of retrying on failure using an exponential backoff strategy
`FluentFunctions.FluentFunction<T,R>`	`visitEvent(java.util.function.Consumer<R> eventConsumer, java.util.function.Consumer<java.lang.Throwable> errorConsumer)` Visit the result of this Function 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

Methods inherited from interface com.aol.cyclops.control.Reader
anyM

Methods inherited from interface java.util.function.Function
identity

Methods inherited from interface com.aol.cyclops.types.Functor
cast, patternMatch, peek, trampoline

- Constructor Detail
  - FluentFunction
```
public FluentFunction(java.util.function.Function<T,R> fn)
```
- Method Detail
  - apply
```
public R apply(T t)
```
    Specified by:
    
    apply in interface java.util.function.Function<T,R>
  - map
```
public <R1> FluentFunctions.FluentFunction<T,R1> map(java.util.function.Function<? super R,? extends R1> f2)
```
    Description copied from interface: Functor
    Transform this functor using the supplied transformation function
```
  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 
```
    Specified by:
    
    map in interface Reader<T,R>
    
    Specified by:
    
    map in interface Functor<R>
    
    Parameters:
    
    f2 - Transformation function
    
    Returns:
    
    Transformed Functor
  - flatMap
```
public <R1> FluentFunctions.FluentFunction<T,R1> flatMap(java.util.function.Function<? super R,? extends Reader<T,R1>> f)
```
    Description copied from interface: Reader
    
    FlatMap this Reader by applying the prodived function and unnesting to a single Reader
    
    Specified by:
    
    flatMap in interface Reader<T,R>
    
    Parameters:
    
    f - Transformation function to be flattened
    
    Returns:
    
    Transformed Reader
  - before
```
public FluentFunctions.FluentFunction<T,R> before(java.util.function.Consumer<T> action)
```
    Apply before advice to this function, capture the input with the provided Consumer
    
    Parameters:
    
    action - Before advice
    
    Returns:
    
    Function with Before advice attached
  - after
```
public FluentFunctions.FluentFunction<T,R> after(java.util.function.BiConsumer<T,R> action)
```
    Apply After advice to this function capturing both the input and the output with the provided BiConsumer
    
    Parameters:
    
    action - After advice
    
    Returns:
    
    Function with After advice attached
  - around
```
public FluentFunctions.FluentFunction<T,R> around(java.util.function.Function<FluentFunctions.Advice1<T,R>,R> around)
```
    Apply around advice to this function, captures input allows output to be controlled by the advice
    
    Parameters:
    
    around - Around advice
    
    Returns:
    
    Function with Around advice attached
  - partiallyApply
```
public FluentFunctions.FluentSupplier<R> partiallyApply(T param)
```
    Partially apply the provided value to this function, to turn it into a Supplier
    
    Parameters:
    
    param - Input param to apply to this function
    
    Returns:
    
    Supplier generated by partially applying the input param to this function
  - memoize
```
public FluentFunctions.FluentFunction<T,R> memoize()
```
    Returns:
    
    A caching (memoizing) version of this Function
  - memoize
```
public FluentFunctions.FluentFunction<T,R> memoize(Cacheable<R> cache)
```
    Parameters:
    
    cache - A wrapper around an external cache implementation
    
    Returns:
    
    A caching (memoizing) version of this Function
  - name
```
public FluentFunctions.FluentFunction<T,R> name(java.lang.String name)
```
    Parameters:
    
    name - To give this Function
    
    Returns:
    
    A Function with a name (useful for logging purposes)
  - log
```
public FluentFunctions.FluentFunction<T,R> log(java.util.function.Consumer<java.lang.String> logger,
                                               java.util.function.Consumer<java.lang.Throwable> error)
```
    A Function that logs it's success or error states to the provided Consumers
    
    Parameters:
    
    logger - Success logger
    
    error - Failure logger
    
    Returns:
    
    Function that logs it's state
  - visitEvent
```
public FluentFunctions.FluentFunction<T,R> visitEvent(java.util.function.Consumer<R> eventConsumer,
                                                      java.util.function.Consumer<java.lang.Throwable> errorConsumer)
```
    Visit the result of this Function 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:
    
    Function with event vistor attached.
  - println
```
public FluentFunctions.FluentFunction<T,R> println()
```
    Returns:
    
    Function that logs it's result or error to the console
  - recover
```
public <X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,R> recover(java.lang.Class<X> type,
                                                                                   java.util.function.Function<T,R> onError)
```
    A Function that can recover from the specified exception types, using the provided recovery Function
    
    Parameters:
    
    type - Recoverable exception types
    
    onError - Recovery function
    
    Returns:
    
    Function capable of error recovery
  - retry
```
public FluentFunctions.FluentFunction<T,R> retry(int times,
                                                 int backoffStartTime)
```
    A Function capable of retrying on failure using an exponential backoff strategy
    
    Parameters:
    
    times - Number of times to retry
    
    backoffStartTime - Wait time before first retry
    
    Returns:
    
    Function with a retry strategy
  - matches
```
public <R1> FluentFunctions.FluentFunction<T,R1> matches(java.util.function.Function<Matchable.CheckValue1<R,R1>,Matchable.CheckValue1<R,R1>> case1,
                                                         java.util.function.Supplier<? extends R1> otherwise)
```
    A Function 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:
    
    Function that matches it's value against the supplied case
  - iterate
```
public ReactiveSeq<R> iterate(T seed,
                              java.util.function.Function<R,T> mapToType)
```
    Generate an infinite Stream that iterates from the specified seed using the currently wrapped function e.g.
```
  
 FluentFunctions.of(this::addOne)	
        				.iterate(95281,i->i)
        				.forEach(System.out::println);
 
 
 //95282
           //95283
           //95284
           //95285
           //95286
 //etc
 
 
```
    Parameters:
    
    seed - initial value
    
    mapToType - Convert from supplied functions return type to Stream input type
    
    Returns:
    
    Infinite Stream
  - generate
```
public ReactiveSeq<R> generate(T input)
```
    Parameters:
    
    input - Input value, this function will applied to this value to generate the value that will be infinitely repeated in this Stream
    
    Returns:
    
    An infinitely generating Stream ReactiveSeq of values determined by the application of this function to the input value
  - lift
```
public FluentFunctions.FluentFunction<java.util.Optional<T>,java.util.Optional<R>> lift()
```
    Returns:
    
    A Function that accepts and returns an Optional
  - liftTry
```
public <X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,Try<R,X>> liftTry(java.lang.Class<X>... classes)
```
    Parameters:
    
    classes - To catch exceptions for
    
    Returns:
    
    A function that executes and returns a Try as the result typ
  - liftM
```
public FluentFunctions.FluentFunction<AnyM<T>,AnyM<R>> liftM()
```
    Returns:
    
    A function that accepts and reurns an AnyM type
  - liftAsync
```
public FluentFunctions.FluentFunction<T,java.util.concurrent.CompletableFuture<R>> liftAsync(java.util.concurrent.Executor ex)
```
    Parameters:
    
    ex - Executor to execute this function on
    
    Returns:
    
    A Function that returns an asynchonously executing CompletableFuture
  - async
```
public java.util.concurrent.CompletableFuture<FluentFunctions.FluentFunction<T,R>> async(java.util.concurrent.Executor ex)
```
    Move this function into an asynchronous context
    
    Parameters:
    
    ex - Executor to manage operations on this function on
    
    Returns:
    
    A CompletableFuture that contains this function
  - compose
```
public <V> java.util.function.Function<V,R> compose(java.util.function.Function<? super V,? extends T> before)
```
    Specified by:
    
    compose in interface java.util.function.Function<T,R>
  - andThen
```
public <V> java.util.function.Function<T,V> andThen(java.util.function.Function<? super R,? extends V> after)
```
    Specified by:
    
    andThen in interface java.util.function.Function<T,R>

Class FluentFunctions.FluentFunction<T,R>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.control.Reader

Methods inherited from interface java.util.function.Function

Methods inherited from interface com.aol.cyclops.types.Functor

Constructor Detail

FluentFunction

Method Detail

apply

map

flatMap

before

after

around

partiallyApply

memoize

memoize

name

log

visitEvent

println

recover

retry

matches

iterate

generate

lift

liftTry

liftM

liftAsync

async

compose

andThen