cyclops.function

Interface Fn1<T,R>

All Superinterfaces:

java.util.function.Function<T,R>

All Known Subinterfaces:

AnyMFn1<W,T1,R>, AnyMFn3<W,T1,T2,T3,R>, AnyMFn4<W,T1,T2,T3,T4,R>, AnyMFn5<W,T1,T2,T3,T4,T5,R>, AnyMFn6<W,T1,T2,T3,T4,T5,T6,R>, AnyMFn7<W,T1,T2,T3,T4,T5,T6,T7,R>, AnyMFn8<W,T1,T2,T3,T4,T5,T6,T7,T8,R>, Fn1.FunctionalOperations<T1,R>, Fn3<S1,S2,S3,R>, Fn4<T1,T2,T3,T4,R>, Fn5<T1,T2,T3,T4,T5,R>, Fn6<T1,T2,T3,T4,T5,T6,R>, Fn7<T1,T2,T3,T4,T5,T6,T7,R>, Fn8<T1,T2,T3,T4,T5,T6,T7,T8,R>, Generator.GeneratorFunction<T>, KleisliM<W,T,R>, Reader<T,R>, UnaryAnyMFn<W,T>, UnaryFn<T>

All Known Implementing Classes:

Cokleisli, CokleisliM, FluentFunctions.FluentFunction, FluentFunctions.FluentTriFunction, FunctionK, Kleisli, ReaderT

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface Fn1<T,R>
extends java.util.function.Function<T,R>

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	Fn1.FunctionalOperations<T1,R>

Method Summary

Modifier and Type	Method and Description
default Fn1<T,R>	after(java.util.function.BiConsumer<? super T,? super R> action) Apply MORE advice to this function capturing both the input and the emitted with the provided BiConsumer
default Eval<R>	always(T t)
default <V> Fn1<java.util.function.Function<? super R,? extends V>,Fn1<T,V>>	andThen()
default <V> Fn1<T,V>	andThen(java.util.function.Function<? super R,? extends V> after)
R	apply(T a)
default Fn0<R>	applyLazy(T t)
default Fn1<T,R>	before(java.util.function.Consumer<? super T> action) Apply before advice to this function, capture the input with the provided Consumer
default Fn0<R>	bind(T s)
default <V> Fn1<V,R>	compose(java.util.function.Function<? super V,? extends T> before)
default <T2> Fn1<Xor<T,T2>,R>	fanIn(java.util.function.Function<? super T2,? extends R> fanIn)
default <__> Fn1<org.jooq.lambda.tuple.Tuple2<T,__>,org.jooq.lambda.tuple.Tuple2<R,__>>	firstFn()
default Fn1.FunctionalOperations<T,R>	functionOps()
default Eval<R>	later(T t)
default <__> Fn1<Xor<T,__>,Xor<R,__>>	leftFn()
default Fn1<T,Maybe<R>>	lift()
default Fn1<T,Future<R>>	lift(java.util.concurrent.Executor ex)
default <W1 extends WitnessType<W1>,W2 extends WitnessType<W2>> Fn1<AnyM<W1,T>,AnyM<W2,R>>	liftAnyM(java.util.function.Function<AnyM<W1,T>,AnyM<W2,T>> hktTransform)
default <W extends WitnessType<W>> AnyMFn1<W,T,R>	liftF()
default <W1,W2> Fn1<Higher<W1,T>,Higher<W2,R>>	liftNT(java.util.function.Function<Higher<W1,T>,Higher<W2,T>> hktTransform, Functor<W2> functor)
default Fn1<T,java.util.Optional<R>>	liftOpt()
default Fn1<T,Try<R,java.lang.Throwable>>	liftTry()
default Fn1<T,R>	memoize()
default Fn1<T,R>	memoize(Cacheable<R> c)
default Fn1<T,R>	memoizeAsync(java.util.concurrent.ScheduledExecutorService ex, long timeToLiveMillis)
default Fn1<T,R>	memoizeAsync(java.util.concurrent.ScheduledExecutorService ex, java.lang.String cron)
default <T2,R2> Fn1<Xor<T,T2>,Xor<R,R2>>	merge(java.util.function.Function<? super T2,? extends R2> fn)
static <T,R> Fn1<T,R>	narrow(java.util.function.Function<? super T,? extends R> fn)
default Eval<R>	now(T t)
default <R1> Fn1<T,org.jooq.lambda.tuple.Tuple2<R,R1>>	product(Fn1<? super T,? extends R1> fn)
default <R2,R3> Fn1<T,org.jooq.lambda.tuple.Tuple3<R,R2,R3>>	product(java.util.function.Function<? super T,? extends R2> fn2, java.util.function.Function<? super T,? extends R3> fn3)
default <R2,R3,R4> Fn1<T,org.jooq.lambda.tuple.Tuple4<R,R2,R3,R4>>	product(java.util.function.Function<? super T,? extends R2> fn2, java.util.function.Function<? super T,? extends R3> fn3, java.util.function.Function<? super T,? extends R4> fn4)
default Reader<T,R>	reader()
default <__> Fn1<Xor<__,T>,Xor<__,R>>	rightFn()
default <__> Fn1<org.jooq.lambda.tuple.Tuple2<__,T>,org.jooq.lambda.tuple.Tuple2<__,R>>	secondFn()
static <T1,T3,R> Fn1<T1,R>	λ(Fn1<T1,R> triFunc)
static <T1,T3,R> Fn1<? super T1,? extends R>	λv(Fn1<? super T1,? extends R> triFunc)

Methods inherited from interface java.util.function.Function

identity

Method Detail

λ

static <T1,T3,R> Fn1<T1,R> λ(Fn1<T1,R> triFunc)

λv

static <T1,T3,R> Fn1<? super T1,? extends R> λv(Fn1<? super T1,? extends R> triFunc)

applyLazy

default Fn0<R> applyLazy(T t)

later

default Eval<R> later(T t)

always

default Eval<R> always(T t)

now

default Eval<R> now(T t)

reader

default Reader<T,R> reader()

apply

R apply(T a)

Specified by:

apply in interface java.util.function.Function<T,R>

before

default Fn1<T,R> before(java.util.function.Consumer<? super T> action)

Apply before advice to this function, capture the input with the provided Consumer

Parameters:

action - LESS advice

Returns:

Function with LESS advice attached

after

default Fn1<T,R> after(java.util.function.BiConsumer<? super T,? super R> action)

Apply MORE advice to this function capturing both the input and the emitted with the provided BiConsumer

Parameters:

action - MORE advice

Returns:

Function with MORE advice attached

liftNT

default <W1,W2> Fn1<Higher<W1,T>,Higher<W2,R>> liftNT(java.util.function.Function<Higher<W1,T>,Higher<W2,T>> hktTransform,
                                                      Functor<W2> functor)

liftAnyM

default <W1 extends WitnessType<W1>,W2 extends WitnessType<W2>> Fn1<AnyM<W1,T>,AnyM<W2,R>> liftAnyM(java.util.function.Function<AnyM<W1,T>,AnyM<W2,T>> hktTransform)

lift

default Fn1<T,Maybe<R>> lift()

lift

default Fn1<T,Future<R>> lift(java.util.concurrent.Executor ex)

liftTry

default Fn1<T,Try<R,java.lang.Throwable>> liftTry()

liftOpt

default Fn1<T,java.util.Optional<R>> liftOpt()

liftF

default <W extends WitnessType<W>> AnyMFn1<W,T,R> liftF()

memoize

default Fn1<T,R> memoize()

memoize

default Fn1<T,R> memoize(Cacheable<R> c)

memoizeAsync

default Fn1<T,R> memoizeAsync(java.util.concurrent.ScheduledExecutorService ex,
                              java.lang.String cron)

memoizeAsync

default Fn1<T,R> memoizeAsync(java.util.concurrent.ScheduledExecutorService ex,
                              long timeToLiveMillis)

merge

default <T2,R2> Fn1<Xor<T,T2>,Xor<R,R2>> merge(java.util.function.Function<? super T2,? extends R2> fn)

fanIn

default <T2> Fn1<Xor<T,T2>,R> fanIn(java.util.function.Function<? super T2,? extends R> fanIn)

leftFn

default <__> Fn1<Xor<T,__>,Xor<R,__>> leftFn()

rightFn

default <__> Fn1<Xor<__,T>,Xor<__,R>> rightFn()

product

default <R1> Fn1<T,org.jooq.lambda.tuple.Tuple2<R,R1>> product(Fn1<? super T,? extends R1> fn)

firstFn

default <__> Fn1<org.jooq.lambda.tuple.Tuple2<T,__>,org.jooq.lambda.tuple.Tuple2<R,__>> firstFn()

secondFn

default <__> Fn1<org.jooq.lambda.tuple.Tuple2<__,T>,org.jooq.lambda.tuple.Tuple2<__,R>> secondFn()

product

default <R2,R3> Fn1<T,org.jooq.lambda.tuple.Tuple3<R,R2,R3>> product(java.util.function.Function<? super T,? extends R2> fn2,
                                                                     java.util.function.Function<? super T,? extends R3> fn3)

product

default <R2,R3,R4> Fn1<T,org.jooq.lambda.tuple.Tuple4<R,R2,R3,R4>> product(java.util.function.Function<? super T,? extends R2> fn2,
                                                                           java.util.function.Function<? super T,? extends R3> fn3,
                                                                           java.util.function.Function<? super T,? extends R4> fn4)

bind

default Fn0<R> bind(T s)

compose

default <V> Fn1<V,R> compose(java.util.function.Function<? super V,? extends T> before)

Specified by:

compose in interface java.util.function.Function<T,R>

andThen

default <V> Fn1<T,V> andThen(java.util.function.Function<? super R,? extends V> after)

Specified by:

andThen in interface java.util.function.Function<T,R>

andThen

default <V> Fn1<java.util.function.Function<? super R,? extends V>,Fn1<T,V>> andThen()

narrow

static <T,R> Fn1<T,R> narrow(java.util.function.Function<? super T,? extends R> fn)

functionOps

default Fn1.FunctionalOperations<T,R> functionOps()