FluentFunctions.FluentFunction (cyclops-react 2.0.0-MI3 API)

java.lang.Object
- cyclops.function.FluentFunctions.FluentFunction<T,R>

All Implemented Interfaces:

Transformable<R>, Fn1<T,R>, Reader<T,R>, java.util.function.Function<T,R>, org.jooq.lambda.function.Function1<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>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.function.Fn1
  Fn1.µ, Fn1.FunctionalOperations<T1,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 emitted with the provided BiConsumer
`<V> FluentFunctions.FluentFunction<T,V>`	`andThen(java.util.function.Function<? super R,? extends V> after)`
`R`	`apply(T t)` Apply this function to the arguments.
`FluentFunctions.FluentFunction<T,R>`	`around(java.util.function.Function<FluentFunctions.Advice1<T,R>,R> around)` Apply around advice to this function, captures input allows emitted 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> FluentFunctions.FluentFunction<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<T,java.util.concurrent.CompletableFuture<R>>`	`liftAsync(java.util.concurrent.Executor ex)`
`<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
`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 cyclops.function.Reader
forEach2, forEach3, forEach4

Methods inherited from interface cyclops.function.Fn1
andThen, bind, functionOps, lift, lift, liftF, liftOpt, liftTry, product, reader, λ, λv

Methods inherited from interface org.jooq.lambda.function.Function1
apply, applyPartially, applyPartially, curry, curry, from, toFunction

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

Methods inherited from interface com.aol.cyclops2.types.Transformable
cast, peek, retry, retry, trampoline

- Constructor Detail
  - FluentFunction
```
public FluentFunction(java.util.function.Function<T,R> fn)
```
- Method Detail
  - apply
```
public R apply(T t)
```
    Description copied from interface: org.jooq.lambda.function.Function1
    
    Apply this function to the arguments.
    
    Specified by:
    
    apply in interface Fn1<T,R>
    
    Specified by:
    
    apply in interface java.util.function.Function<T,R>
    
    Specified by:
    
    apply in interface org.jooq.lambda.function.Function1<T,R>
  - map
```
public <R1> FluentFunctions.FluentFunction<T,R1> map(java.util.function.Function<? super R,? extends R1> f2)
```
    Description copied from interface: Transformable
    Transform this functor using the supplied transformation function
```
  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 
```
    Specified by:
    
    map in interface Transformable<R>
    
    Specified by:
    
    map in interface Reader<T,R>
    
    Parameters:
    
    f2 - Transformation function
    
    Returns:
    
    Transformed Transformable
  - 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 emitted 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 emitted 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()
```
    Specified by:
    
    memoize in interface Fn1<T,R>
    
    Returns:
    
    A caching (memoizing) version of this Function
  - memoize
```
public FluentFunctions.FluentFunction<T,R> memoize(Cacheable<R> cache)
```
    Specified by:
    
    memoize in interface Fn1<T,R>
    
    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
  - 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 function 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
  - 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
  - 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> FluentFunctions.FluentFunction<V,R> compose(java.util.function.Function<? super V,? extends T> before)
```
    Specified by:
    
    compose in interface Fn1<T,R>
    
    Specified by:
    
    compose in interface java.util.function.Function<T,R>
  - andThen
```
public <V> FluentFunctions.FluentFunction<T,V> andThen(java.util.function.Function<? super R,? extends V> after)
```
    Specified by:
    
    andThen in interface Fn1<T,R>
    
    Specified by:
    
    andThen in interface java.util.function.Function<T,R>

Class FluentFunctions.FluentFunction<T,R>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.function.Fn1

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.function.Reader

Methods inherited from interface cyclops.function.Fn1

Methods inherited from interface org.jooq.lambda.function.Function1

Methods inherited from interface java.util.function.Function

Methods inherited from interface com.aol.cyclops2.types.Transformable

Constructor Detail

FluentFunction

Method Detail

apply

map

flatMap

before

after

around

partiallyApply

memoize

memoize

name

log

visitEvent

println

recover

retry

iterate

generate

liftTry

liftAsync

async

compose

andThen