com.aol.cyclops.control

Class FluentFunctions.FluentFunction<T,R>

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)

Method Summary

Modifier and Type	Method and Description
FluentFunctions.FluentFunction<T,R>	after(java.util.function.BiConsumer<T,R> action)
<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)
java.util.concurrent.CompletableFuture<FluentFunctions.FluentFunction<T,R>>	async(java.util.concurrent.Executor ex)
FluentFunctions.FluentFunction<T,R>	before(java.util.function.Consumer<T> action)
<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)
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)
<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)
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)
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)
FluentFunctions.FluentFunction<T,R>	retry(int times, int backoffStartTime)
FluentFunctions.FluentFunction<T,R>	visitEvent(java.util.function.Consumer<R> eventConsumer, java.util.function.Consumer<java.lang.Throwable> 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)

Specified by:

flatMap in interface Reader<T,R>

before

public FluentFunctions.FluentFunction<T,R> before(java.util.function.Consumer<T> action)

after

public FluentFunctions.FluentFunction<T,R> after(java.util.function.BiConsumer<T,R> action)

around

public FluentFunctions.FluentFunction<T,R> around(java.util.function.Function<FluentFunctions.Advice1<T,R>,R> around)

partiallyApply

public FluentFunctions.FluentSupplier<R> partiallyApply(T param)

memoize

public FluentFunctions.FluentFunction<T,R> memoize()

memoize

public FluentFunctions.FluentFunction<T,R> memoize(Cacheable<R> cache)

name

public FluentFunctions.FluentFunction<T,R> name(java.lang.String name)

log

public FluentFunctions.FluentFunction<T,R> log(java.util.function.Consumer<java.lang.String> logger,
                                               java.util.function.Consumer<java.lang.Throwable> error)

visitEvent

public FluentFunctions.FluentFunction<T,R> visitEvent(java.util.function.Consumer<R> eventConsumer,
                                                      java.util.function.Consumer<java.lang.Throwable> errorConsumer)

println

public FluentFunctions.FluentFunction<T,R> println()

recover

public <X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,R> recover(java.lang.Class<X> type,
                                                                                   java.util.function.Function<T,R> onError)

retry

public FluentFunctions.FluentFunction<T,R> retry(int times,
                                                 int backoffStartTime)

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)

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)

lift

public FluentFunctions.FluentFunction<java.util.Optional<T>,java.util.Optional<R>> lift()

liftTry

public <X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,Try<R,X>> liftTry(java.lang.Class<X>... classes)

liftM

public FluentFunctions.FluentFunction<AnyM<T>,AnyM<R>> liftM()

liftAsync

public FluentFunctions.FluentFunction<T,java.util.concurrent.CompletableFuture<R>> liftAsync(java.util.concurrent.Executor ex)

async

public java.util.concurrent.CompletableFuture<FluentFunctions.FluentFunction<T,R>> async(java.util.concurrent.Executor ex)

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>