com.aol.cyclops.reactor.hkt.typeclasses.instances

Class MonoInstances

java.lang.Object

com.aol.cyclops.reactor.hkt.typeclasses.instances.MonoInstances

public class MonoInstances
extends java.lang.Object

Companion class for creating Type Class instances for working with Monos

Constructor Summary

Constructors

Constructor and Description
MonoInstances()

Method Summary

Modifier and Type	Method and Description
static <T,R> com.aol.cyclops.hkt.typeclasses.monad.Applicative<MonoType.µ>	applicative() import static com.aol.cyclops.hkt.jdk.MonoType.widen; import static com.aol.cyclops.util.function.Lambda.l1; import static java.util.Arrays.asMono; Monos.applicative() .ap(widen(asMono(l1(this::multiplyByTwo))),widen(Mono.just(3))); //[6]
static <T> com.aol.cyclops.hkt.typeclasses.comonad.Comonad<MonoType.µ>	comonad()
static <T> com.aol.cyclops.hkt.typeclasses.foldable.Foldable<MonoType.µ>	foldable() int sum = Monos.foldable() .foldLeft(0, (a,b)->a+b, MonoType.widen(Arrays.asMono(1,2,3,4))); //10
static <T,R> com.aol.cyclops.hkt.typeclasses.functor.Functor<MonoType.µ>	functor() Transform a Mono, mulitplying every element by 2
static <T,R> com.aol.cyclops.hkt.typeclasses.monad.Monad<MonoType.µ>	monad() import static com.aol.cyclops.hkt.jdk.MonoType.widen; MonoType<Integer> ft = Monos.monad() .flatMap(i->widen(Mono.just(i)), widen(Mono.just(3))) .convert(MonoType::narrowK);
static <T> com.aol.cyclops.hkt.typeclasses.monad.MonadPlus<MonoType.µ>	monadPlus() Combines Monos by selecting the first result returned
static <T> com.aol.cyclops.hkt.typeclasses.monad.MonadPlus<MonoType.µ>	monadPlus(Monoid<MonoType<T>> m) Monoid<MonoType<Integer>> m = Monoid.of(MonoType.widen(Arrays.asMono()), (a,b)->a.isEmpty() ? b : a); MonoType<Integer> ft = Monos.<Integer>monadPlus(m) .plus(MonoType.widen(Arrays.asMono(5)), MonoType.widen(Arrays.asMono(10))) .convert(MonoType::narrowK); //Arrays.asMono(5))
static <T,R> com.aol.cyclops.hkt.typeclasses.monad.MonadZero<MonoType.µ>	monadZero() MonoType<String> ft = Monos.unit() .unit("hello") .then(h->Monos.monadZero().filter((String t)->t.startsWith("he"), h)) .convert(MonoType::narrowK); //Mono.just("hello"));
static <C2,T> com.aol.cyclops.hkt.typeclasses.monad.Traverse<MonoType.µ>	traverse()
static <T> com.aol.cyclops.hkt.typeclasses.Unit<MonoType.µ>	unit() MonoType<String> ft = Monos.unit() .unit("hello") .convert(MonoType::narrowK); //Mono["hello"]

Methods inherited from class java.lang.Object

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

Constructor Detail

MonoInstances

public MonoInstances()

Method Detail

functor

public static <T,R> com.aol.cyclops.hkt.typeclasses.functor.Functor<MonoType.µ> functor()

Transform a Mono, mulitplying every element by 2

  
  MonoType<Integer> future = Monos.functor().map(i->i*2, MonoType.widen(Mono.just(3));
  
  //[6]
  
 
 
 

An example fluent api working with Monos

  
   MonoType<Integer> ft = Monos.unit()
                                       .unit("hello")
                                       .then(h->Monos.functor().map((String v) ->v.length(), h))
                                       .convert(MonoType::narrowK);
 
 
 

Returns:

A functor for Monos

unit

public static <T> com.aol.cyclops.hkt.typeclasses.Unit<MonoType.µ> unit()

  
 MonoType<String> ft = Monos.unit()
                                     .unit("hello")
                                     .convert(MonoType::narrowK);
        
        //Mono["hello"]
 
 
 

Returns:

A factory for Monos

applicative

public static <T,R> com.aol.cyclops.hkt.typeclasses.monad.Applicative<MonoType.µ> applicative()

  
 import static com.aol.cyclops.hkt.jdk.MonoType.widen;
 import static com.aol.cyclops.util.function.Lambda.l1;
 import static java.util.Arrays.asMono;
 
       Monos.applicative()
            .ap(widen(asMono(l1(this::multiplyByTwo))),widen(Mono.just(3)));
 
 //[6]
 
 

Example fluent API

  
 MonoType<Function<Integer,Integer>> ftFn =Monos.unit()
                                                  .unit(Lambda.l1((Integer i) ->i*2))
                                                  .convert(MonoType::narrowK);
        
        MonoType<Integer> ft = Monos.unit()
                                      .unit("hello")
                                      .then(h->Monos.functor().map((String v) ->v.length(), h))
                                      .then(h->Monos.applicative().ap(ftFn, h))
                                      .convert(MonoType::narrowK);
        
        //Mono.just("hello".length()*2))
 
 
 

Returns:

A zipper for Monos

monad

public static <T,R> com.aol.cyclops.hkt.typeclasses.monad.Monad<MonoType.µ> monad()

  
 import static com.aol.cyclops.hkt.jdk.MonoType.widen;
 MonoType<Integer> ft  = Monos.monad()
                                      .flatMap(i->widen(Mono.just(i)), widen(Mono.just(3)))
                                      .convert(MonoType::narrowK);
 
 

Example fluent API

  
    MonoType<Integer> ft = Monos.unit()
                                        .unit("hello")
                                        .then(h->Monos.monad().flatMap((String v) ->Monos.unit().unit(v.length()), h))
                                        .convert(MonoType::narrowK);
        
        //Mono.just("hello".length())
 
 
 

Returns:

Type class with monad functions for Monos

monadZero

public static <T,R> com.aol.cyclops.hkt.typeclasses.monad.MonadZero<MonoType.µ> monadZero()

  
  MonoType<String> ft = Monos.unit()
                                     .unit("hello")
                                     .then(h->Monos.monadZero().filter((String t)->t.startsWith("he"), h))
                                     .convert(MonoType::narrowK);
        
       //Mono.just("hello"));
 
 
 

Returns:

A filterable monad (with default value)

monadPlus

public static <T> com.aol.cyclops.hkt.typeclasses.monad.MonadPlus<MonoType.µ> monadPlus()

Combines Monos by selecting the first result returned

  
  MonoType<Integer> ft = Monos.<Integer>monadPlus()
                                      .plus(MonoType.widen(Mono.empty()), MonoType.widen(Mono.just(10)))
                                      .convert(MonoType::narrowK);
        //Mono.empty()
 
 
 

Returns:

Type class for combining Monos by concatenation

monadPlus

public static <T> com.aol.cyclops.hkt.typeclasses.monad.MonadPlus<MonoType.µ> monadPlus(Monoid<MonoType<T>> m)

  
  Monoid<MonoType<Integer>> m = Monoid.of(MonoType.widen(Arrays.asMono()), (a,b)->a.isEmpty() ? b : a);
        MonoType<Integer> ft = Monos.<Integer>monadPlus(m)
                                      .plus(MonoType.widen(Arrays.asMono(5)), MonoType.widen(Arrays.asMono(10)))
                                      .convert(MonoType::narrowK);
        //Arrays.asMono(5))
 
 
 

Parameters:

m - Monoid to use for combining Monos

Returns:

Type class for combining Monos

traverse

public static <C2,T> com.aol.cyclops.hkt.typeclasses.monad.Traverse<MonoType.µ> traverse()

Returns:

Type class for traversables with traverse / sequence operations

foldable

public static <T> com.aol.cyclops.hkt.typeclasses.foldable.Foldable<MonoType.µ> foldable()

  
 int sum  = Monos.foldable()
                        .foldLeft(0, (a,b)->a+b, MonoType.widen(Arrays.asMono(1,2,3,4)));
        
        //10
 
 
 

Returns:

Type class for folding / reduction operations

comonad

public static <T> com.aol.cyclops.hkt.typeclasses.comonad.Comonad<MonoType.µ> comonad()