cyclops.typeclasses

Class Kleisli<W,T,R>

java.lang.Object

cyclops.typeclasses.Kleisli<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 Implemented Interfaces:

Convert<Higher<Higher<Higher<Witness.kleisli,W>,T>,R>>, Higher<Higher<Higher<Witness.kleisli,W>,T>,R>, Higher2<Higher<Witness.kleisli,W>,T,R>, Higher3<Witness.kleisli,W,T,R>, Transformable<R>, Fn1<T,Higher<W,R>>, java.util.function.Function<T,Higher<W,R>>

public class Kleisli<W,T,R>
extends java.lang.Object
implements Fn1<T,Higher<W,R>>, Transformable<R>, Higher3<Witness.kleisli,W,T,R>

Compose functions that return monads

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Kleisli.Instances

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

Fn1.FunctionalOperations<T1,R>

Constructor Summary

Constructors

Constructor and Description
Kleisli()

Method Summary

Modifier and Type	Method and Description
Higher<W,R>	apply(T a)
<A> Kleisli<W,A,R>	compose(Kleisli<W,A,T> kleisli)
<T2> Kleisli<W,Xor<T,T2>,R>	fanIn(Kleisli<W,T2,R> fanIn)
<__> Kleisli<W,org.jooq.lambda.tuple.Tuple2<T,__>,org.jooq.lambda.tuple.Tuple2<R,__>>	firstK()
<R1> Kleisli<W,T,R1>	flatMap(java.util.function.Function<? super R,? extends Higher<W,? extends R1>> mapper)
<R1> Kleisli<W,T,R1>	flatMapK(java.util.function.Function<? super R,? extends Kleisli<W,T,R1>> mapper)
<R1,R4> Kleisli<W,T,R4>	forEach2(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends Higher<W,? extends R1>>> value2, java.util.function.BiFunction<? super R,? super R1,? extends R4> yieldingFunction)
<R1,R2,R4> Kleisli<W,T,R4>	forEach3(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends Higher<W,? extends R1>>> value2, java.util.function.BiFunction<? super R,? super R1,java.util.function.Function<? super T,? extends Higher<W,? extends R2>>> value3, Fn3<? super R,? super R1,? super R2,? extends R4> yieldingFunction)
<R1,R2,R3,R4> Kleisli<W,T,R4>	forEach4(java.util.function.Function<? super R,java.util.function.Function<? super T,? extends Higher<W,? extends R1>>> value2, java.util.function.BiFunction<? super R,? super R1,java.util.function.Function<? super T,? extends Higher<W,? extends R2>>> value3, Fn3<? super R,? super R1,? super R2,java.util.function.Function<? super T,? extends Higher<W,? extends R3>>> value4, Fn4<? super R,? super R1,? super R2,? super R3,? extends R4> yieldingFunction)
static <T,R,W> Kleisli<W,T,R>	kleisliK(Monad<W> monad, java.util.function.Function<? super T,? extends Higher<W,? extends R>> fn)
<__> Kleisli<W,Xor<T,__>,Xor<R,__>>	leftK(W type)
static <T,R,W> Kleisli<W,T,R>	lift(Monad<W> monad, java.util.function.Function<? super T,? extends R> fn, W type)
Kleisli<W,T,R>	local(java.util.function.Function<? super R,? extends R> local)
<R1> Kleisli<W,T,R1>	map(java.util.function.Function<? super R,? extends R1> mapper) Transform this functor using the supplied transformation function
<T2,R2> Kleisli<W,Xor<T,T2>,Xor<R,R2>>	merge(Kleisli<W,T2,R2> merge, W type)
static <W,T,R> Kleisli<W,T,R>	of(Monad<W> monad, java.util.function.Function<? super T,? extends Higher<W,? extends R>> fn)
<__> Kleisli<W,Xor<__,T>,Xor<__,R>>	rightK(W type)
<__> Kleisli<W,org.jooq.lambda.tuple.Tuple2<__,T>,org.jooq.lambda.tuple.Tuple2<__,R>>	secondK()
<R2> Kleisli<W,T,R2>	then(Kleisli<W,R,R2> kleisli)
<R2> Kleisli<W,T,org.jooq.lambda.tuple.Tuple2<R,R2>>	zip(Kleisli<W,T,R2> o)
<R2,B> Kleisli<W,T,B>	zip(Kleisli<W,T,R2> o, java.util.function.BiFunction<? super R,? super R2,? extends B> fn)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface cyclops.function.Fn1

after, always, andThen, andThen, applyLazy, before, bind, compose, fanIn, firstFn, functionOps, later, leftFn, lift, lift, liftAnyM, liftF, liftNT, liftOpt, liftTry, memoize, memoize, memoizeAsync, memoizeAsync, merge, narrow, now, product, product, product, reader, rightFn, secondFn, λ, λv

Methods inherited from interface java.util.function.Function

identity

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

cast, peek, retry, retry, trampoline

Methods inherited from interface com.aol.cyclops2.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert

convert

Constructor Detail

Kleisli

public Kleisli()

Method Detail

of

public static <W,T,R> Kleisli<W,T,R> of(Monad<W> monad,
                                        java.util.function.Function<? super T,? extends Higher<W,? extends R>> fn)

local

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

map

public <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

flatMap

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

zip

public <R2> Kleisli<W,T,org.jooq.lambda.tuple.Tuple2<R,R2>> zip(Kleisli<W,T,R2> o)

zip

public <R2,B> Kleisli<W,T,B> zip(Kleisli<W,T,R2> o,
                                 java.util.function.BiFunction<? super R,? super R2,? extends B> fn)

flatMapK

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

compose

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

then

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

leftK

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

rightK

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

firstK

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

secondK

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

merge

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

fanIn

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

forEach4

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

forEach3

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

forEach2

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

kleisliK

public static <T,R,W> Kleisli<W,T,R> kleisliK(Monad<W> monad,
                                              java.util.function.Function<? super T,? extends Higher<W,? extends R>> fn)

lift

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

apply

public Higher<W,R> apply(T a)

Specified by:

apply in interface Fn1<T,Higher<W,R>>

Specified by:

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