cyclops.monads

Interface Kleisli<W extends WitnessType<W>,T,R>

Type Parameters:

W - Monad kind

T - Function input type

R - Function return type (inside monad e.g. Kleisli[stream,String,Integer] represents a function that takes a String and returns a Stream of Integers)

All Superinterfaces:

Fn1<T,AnyM<W,R>>, java.util.function.Function<T,AnyM<W,R>>, org.jooq.lambda.function.Function1<T,AnyM<W,R>>, Transformable<R>

All Known Subinterfaces:

AnyMFn1<W,T1,R>, UnaryAnyMFn<W,T>

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 Kleisli<W extends WitnessType<W>,T,R>
extends Fn1<T,AnyM<W,R>>, Transformable<R>

Compose functions that return monads

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Kleisli.µ

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

Fn1.FunctionalOperations<T1,R>

Method Summary

Modifier and Type	Method and Description
default <A> Kleisli<W,A,R>	compose(Kleisli<W,A,T> kleisli)
default <T2> Kleisli<W,Xor<T,T2>,R>	fanIn(Kleisli<W,T2,R> fanIn)
default <__> Kleisli<W,org.jooq.lambda.tuple.Tuple2<T,__>,org.jooq.lambda.tuple.Tuple2<R,__>>	firstK()
default <R1> Kleisli<W,T,R1>	flatMap(java.util.function.Function<? super R,? extends Kleisli<W,T,R1>> mapper) Compose functions that return monads.
default <R1> Kleisli<W,T,R1>	flatMapA(java.util.function.Function<? super R,? extends AnyM<W,? extends R1>> mapper)
default <R1,R4> Kleisli<W,T,R4>	forEach2(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends AnyM<W,? extends R1>>> value2, java.util.function.BiFunction<? super R,? super R1,? extends R4> yieldingFunction)
default <R1,R2,R4> Kleisli<W,T,R4>	forEach3(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends AnyM<W,? extends R1>>> value2, java.util.function.BiFunction<? super R,? super R1,java.util.function.Function<? super T,? extends AnyM<W,? extends R2>>> value3, Fn3<? super R,? super R1,? super R2,? extends R4> yieldingFunction)
default <R1,R2,R3,R4> Kleisli<W,T,R4>	forEach4(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends AnyM<W,? extends R1>>> value2, java.util.function.BiFunction<? super R,? super R1,java.util.function.Function<? super T,? extends AnyM<W,? extends R2>>> value3, Fn3<? super R,? super R1,? super R2,java.util.function.Function<? super T,? extends AnyM<W,? extends R3>>> value4, Fn4<? super R,? super R1,? super R2,? super R3,? extends R4> yieldingFunction)
static <T,R,W extends WitnessType<W>> Kleisli<W,T,R>	kleisli(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)
default <__> Kleisli<W,Xor<T,__>,Xor<R,__>>	leftK(W type)
static <T,R,W extends WitnessType<W>> Kleisli<W,T,R>	lift(java.util.function.Function<? super T,? extends R> fn, W type)
default Kleisli<W,T,R>	local(java.util.function.Function<? super R,? extends R> local)
default <R1> Kleisli<W,T,R1>	map(java.util.function.Function<? super R,? extends R1> mapper) Transform this functor using the supplied transformation function
default <T2,R2> Kleisli<W,Xor<T,T2>,Xor<R,R2>>	merge(Kleisli<W,T2,R2> merge, W type)
static <T,W extends WitnessType<W>,R> Fn1<T,AnyM<W,R>>	narrow(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)
default <__> Kleisli<W,Xor<__,T>,Xor<__,R>>	rightK(W type)
default <__> Kleisli<W,org.jooq.lambda.tuple.Tuple2<__,T>,org.jooq.lambda.tuple.Tuple2<__,R>>	secondK()
default <R2> Kleisli<W,T,R2>	then(Kleisli<W,R,R2> kleisli)

Methods inherited from interface cyclops.function.Fn1

andThen, andThen, apply, bind, compose, fanIn, firstFn, functionOps, leftFn, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, memoizeAsync, memoizeAsync, merge, narrow, product, product, product, reader, rightFn, secondFn, λ, λ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.functor.Transformable

cast, peek, retry, retry, trampoline

Method Detail

local

default Kleisli<W,T,R> local(java.util.function.Function<? super R,? extends R> local)

map

default <R1> Kleisli<W,T,R1> map(java.util.function.Function<? super R,? extends R1> mapper)

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>

Parameters:

mapper - Transformation function

Returns:

Transformed Transformable

flatMapA

default <R1> Kleisli<W,T,R1> flatMapA(java.util.function.Function<? super R,? extends AnyM<W,? extends R1>> mapper)

flatMap

default <R1> Kleisli<W,T,R1> flatMap(java.util.function.Function<? super R,? extends Kleisli<W,T,R1>> mapper)

Compose functions that return monads. Example :-

  
  import cyclops.monads.Witness.reactiveSeq;
        import static cyclops.monads.Kleisli.kleisli;


        Kleisli<reactiveSeq, Integer, Integer> k1 = kleisli(t -> ReactiveSeq.iterate(0,i->i<t, i->i+1)
                                                                            .anyM(), reactiveSeq.INSTANCE);

        k1.flatMap(i-> kleisli(t-> ReactiveSeq.of(t+i)
                                              .anyM(), reactiveSeq.INSTANCE))
          .apply(10)
          .forEach(System.out::println);

        10
        11
        12
        13
        14
        15
        16
        17
        18
        19

 

Type Parameters:

R1 -

Parameters:

mapper -

Returns:

compose

default <A> Kleisli<W,A,R> compose(Kleisli<W,A,T> kleisli)

then

default <R2> Kleisli<W,T,R2> then(Kleisli<W,R,R2> kleisli)

leftK

default <__> Kleisli<W,Xor<T,__>,Xor<R,__>> leftK(W type)

rightK

default <__> Kleisli<W,Xor<__,T>,Xor<__,R>> rightK(W type)

firstK

default <__> Kleisli<W,org.jooq.lambda.tuple.Tuple2<T,__>,org.jooq.lambda.tuple.Tuple2<R,__>> firstK()

secondK

default <__> Kleisli<W,org.jooq.lambda.tuple.Tuple2<__,T>,org.jooq.lambda.tuple.Tuple2<__,R>> secondK()

merge

default <T2,R2> Kleisli<W,Xor<T,T2>,Xor<R,R2>> merge(Kleisli<W,T2,R2> merge,
                                                     W type)

fanIn

default <T2> Kleisli<W,Xor<T,T2>,R> fanIn(Kleisli<W,T2,R> fanIn)

forEach4

default <R1,R2,R3,R4> Kleisli<W,T,R4> forEach4(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends AnyM<W,? extends R1>>> value2,
                                               java.util.function.BiFunction<? super R,? super R1,java.util.function.Function<? super T,? extends AnyM<W,? extends R2>>> value3,
                                               Fn3<? super R,? super R1,? super R2,java.util.function.Function<? super T,? extends AnyM<W,? extends R3>>> value4,
                                               Fn4<? super R,? super R1,? super R2,? super R3,? extends R4> yieldingFunction)

forEach3

default <R1,R2,R4> Kleisli<W,T,R4> forEach3(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends AnyM<W,? extends R1>>> value2,
                                            java.util.function.BiFunction<? super R,? super R1,java.util.function.Function<? super T,? extends AnyM<W,? extends R2>>> value3,
                                            Fn3<? super R,? super R1,? super R2,? extends R4> yieldingFunction)

forEach2

default <R1,R4> Kleisli<W,T,R4> forEach2(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends AnyM<W,? extends R1>>> value2,
                                         java.util.function.BiFunction<? super R,? super R1,? extends R4> yieldingFunction)

kleisli

static <T,R,W extends WitnessType<W>> Kleisli<W,T,R> kleisli(java.util.function.Function<? super T,? extends AnyM<W,? extends R>> fn)

lift

static <T,R,W extends WitnessType<W>> Kleisli<W,T,R> lift(java.util.function.Function<? super T,? extends R> fn,
                                                          W type)

narrow

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