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

Class FluxInstances

java.lang.Object

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

public class FluxInstances
extends java.lang.Object

Companion class for creating Type Class instances for working with Fluxs

Constructor Summary

Constructors

Constructor and Description
FluxInstances()

Method Summary

Modifier and Type	Method and Description
static <T> com.aol.cyclops.hkt.typeclasses.foldable.Foldable<FluxType.µ>	foldable() int sum = Fluxs.foldable() .foldLeft(0, (a,b)->a+b, FluxType.widen(Flux.of(1,2,3,4))); //10
static <T,R> com.aol.cyclops.hkt.typeclasses.functor.Functor<FluxType.µ>	functor() Transform a flux, mulitplying every element by 2
static <T,R> com.aol.cyclops.hkt.typeclasses.monad.Monad<FluxType.µ>	monad() import static com.aol.cyclops.hkt.jdk.FluxType.widen; FluxType<Integer> flux = Fluxs.monad() .flatMap(i->widen(FluxX.range(0,i)), widen(Flux.of(1,2,3))) .convert(FluxType::narrowK);
static <T> com.aol.cyclops.hkt.typeclasses.monad.MonadPlus<FluxType.µ>	monadPlus() FluxType<Integer> flux = Fluxs.<Integer>monadPlus() .plus(FluxType.widen(Flux.of()), FluxType.widen(Flux.of(10))) .convert(FluxType::narrowK); //Flux.of(10))
static <T> com.aol.cyclops.hkt.typeclasses.monad.MonadPlus<FluxType.µ>	monadPlus(Monoid<FluxType<T>> m) Monoid<FluxType<Integer>> m = Monoid.of(FluxType.widen(Flux.of()), (a,b)->a.isEmpty() ? b : a); FluxType<Integer> flux = Fluxs.<Integer>monadPlus(m) .plus(FluxType.widen(Flux.of(5)), FluxType.widen(Flux.of(10))) .convert(FluxType::narrowK); //Flux.of(5))
static <T,R> com.aol.cyclops.hkt.typeclasses.monad.MonadZero<FluxType.µ>	monadZero() FluxType<String> flux = Fluxs.unit() .unit("hello") .then(h->Fluxs.monadZero().filter((String t)->t.startsWith("he"), h)) .convert(FluxType::narrowK); //Flux.of("hello"));
static <C2,T> com.aol.cyclops.hkt.typeclasses.monad.Traverse<FluxType.µ>	traverse()
static <T> com.aol.cyclops.hkt.typeclasses.Unit<FluxType.µ>	unit() FluxType<String> flux = Fluxs.unit() .unit("hello") .convert(FluxType::narrowK); //Flux.of("hello"))
static <T,R> com.aol.cyclops.hkt.typeclasses.monad.Applicative<FluxType.µ>	zippingApplicative() import static com.aol.cyclops.hkt.jdk.FluxType.widen; import static com.aol.cyclops.util.function.Lambda.l1; Fluxs.zippingApplicative() .ap(widen(Flux.of(l1(this::multiplyByTwo))),widen(Flux.of(1,2,3))); //[2,4,6]

Methods inherited from class java.lang.Object

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

Constructor Detail

FluxInstances

public FluxInstances()

Method Detail

functor

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

Transform a flux, mulitplying every element by 2

  
  FluxType<Integer> flux = Fluxs.functor().map(i->i*2, FluxType.widen(Flux.of(1,2,3));
  
  //[2,4,6]
  
 
 
 

An example fluent api working with Fluxs

  
   FluxType<Integer> flux = Fluxs.unit()
                                       .unit("hello")
                                       .then(h->Fluxs.functor().map((String v) ->v.length(), h))
                                       .convert(FluxType::narrowK);
 
 
 

Returns:

A functor for Fluxs

unit

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

  
 FluxType<String> flux = Fluxs.unit()
                                     .unit("hello")
                                     .convert(FluxType::narrowK);
        
        //Flux.of("hello"))
 
 
 

Returns:

A factory for Fluxs

zippingApplicative

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

  
 import static com.aol.cyclops.hkt.jdk.FluxType.widen;
 import static com.aol.cyclops.util.function.Lambda.l1;
 
       Fluxs.zippingApplicative()
            .ap(widen(Flux.of(l1(this::multiplyByTwo))),widen(Flux.of(1,2,3)));
 
 //[2,4,6]
 
 

Example fluent API

  
 FluxType<Function<Integer,Integer>> fluxFn =Fluxs.unit()
                                                  .unit(Lambda.l1((Integer i) ->i*2))
                                                  .convert(FluxType::narrowK);
        
        FluxType<Integer> flux = Fluxs.unit()
                                      .unit("hello")
                                      .then(h->Fluxs.functor().map((String v) ->v.length(), h))
                                      .then(h->Fluxs.zippingApplicative().ap(fluxFn, h))
                                      .convert(FluxType::narrowK);
        
        //Flux.of("hello".length()*2))
 
 
 

Returns:

A zipper for Fluxs

monad

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

  
 import static com.aol.cyclops.hkt.jdk.FluxType.widen;
 FluxType<Integer> flux  = Fluxs.monad()
                                      .flatMap(i->widen(FluxX.range(0,i)), widen(Flux.of(1,2,3)))
                                      .convert(FluxType::narrowK);
 
 

Example fluent API

  
    FluxType<Integer> flux = Fluxs.unit()
                                        .unit("hello")
                                        .then(h->Fluxs.monad().flatMap((String v) ->Fluxs.unit().unit(v.length()), h))
                                        .convert(FluxType::narrowK);
        
        //Flux.of("hello".length())
 
 
 

Returns:

Type class with monad functions for Fluxs

monadZero

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

  
  FluxType<String> flux = Fluxs.unit()
                                         .unit("hello")
                                         .then(h->Fluxs.monadZero().filter((String t)->t.startsWith("he"), h))
                                         .convert(FluxType::narrowK);
        
       //Flux.of("hello"));
 
 
 

Returns:

A filterable monad (with default value)

monadPlus

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

  
  FluxType<Integer> flux = Fluxs.<Integer>monadPlus()
                                      .plus(FluxType.widen(Flux.of()), FluxType.widen(Flux.of(10)))
                                      .convert(FluxType::narrowK);
        //Flux.of(10))
 
 
 

Returns:

Type class for combining Fluxs by concatenation

monadPlus

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

  
  Monoid<FluxType<Integer>> m = Monoid.of(FluxType.widen(Flux.of()), (a,b)->a.isEmpty() ? b : a);
        FluxType<Integer> flux = Fluxs.<Integer>monadPlus(m)
                                      .plus(FluxType.widen(Flux.of(5)), FluxType.widen(Flux.of(10)))
                                      .convert(FluxType::narrowK);
        //Flux.of(5))
 
 
 

Parameters:

m - Monoid to use for combining Fluxs

Returns:

Type class for combining Fluxs

traverse

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

Returns:

Type class for traversables with traverse / sequence operations

foldable

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

  
 int sum  = Fluxs.foldable()
                        .foldLeft(0, (a,b)->a+b, FluxType.widen(Flux.of(1,2,3,4)));
        
        //10
 
 
 

Returns:

Type class for folding / reduction operations