cyclops.stream

Class ReactiveSeq.Instances

java.lang.Object

cyclops.stream.ReactiveSeq.Instances

Enclosing interface:

ReactiveSeq<T>

public static class ReactiveSeq.Instances
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
Instances()

Method Summary

Modifier and Type	Method and Description
static <T> Foldable<ReactiveSeq.µ>	foldable() int sum = Lists.foldable() .foldLeft(0, (a,b)->a+b, ReactiveSeq.of(1,2,3,4)); //10
static <T,R> Functor<ReactiveSeq.µ>	functor() Transform a list, mulitplying every element by 2
static <T,R> Monad<ReactiveSeq.µ>	monad() import static com.aol.cyclops2.hkt.jdk.ReactiveSeq.widen; ReactiveSeq<Integer> list = Lists.monad() .flatMap(i->widen(ReactiveSeq.range(0,i)), widen(Arrays.asList(1,2,3))) .convert(ReactiveSeq::narrowK);
static <T> MonadPlus<ReactiveSeq.µ>	monadPlus() ReactiveSeq<Integer> list = Lists.<Integer>monadPlus() .plus(ReactiveSeq.widen(Arrays.asList()), ReactiveSeq.widen(Arrays.asList(10))) .convert(ReactiveSeq::narrowK); //Arrays.asList(10))
static <T> MonadPlus<ReactiveSeq.µ>	monadPlus(Monoid<ReactiveSeq<T>> m) Monoid<ReactiveSeq<Integer>> m = Monoid.of(ReactiveSeq.widen(Arrays.asList()), (a,b)->a.isEmpty() ? b : a); ReactiveSeq<Integer> list = Lists.<Integer>monadPlus(m) .plus(ReactiveSeq.widen(Arrays.asList(5)), ReactiveSeq.widen(Arrays.asList(10))) .convert(ReactiveSeq::narrowK); //Arrays.asList(5))
static <T,R> MonadZero<ReactiveSeq.µ>	monadZero() ReactiveSeq<String> list = Lists.unit() .unit("hello") .apply(h->Lists.monadZero().filter((String t)->t.startsWith("he"), h)) .convert(ReactiveSeq::narrowK); //Arrays.asList("hello"));
static <T> ReactiveSeq<T>	narrow(Higher<ReactiveSeq.µ,T> completableList) Convert the HigherKindedType definition for a List into
static <C2,T> Traverse<ReactiveSeq.µ>	traverse()
static <T> Pure<ReactiveSeq.µ>	unit() ReactiveSeq<String> list = Lists.unit() .unit("hello") .convert(ReactiveSeq::narrowK); //Arrays.asList("hello"))
static <C2,T> Higher<C2,Higher<ReactiveSeq.µ,T>>	widen2(Higher<C2,ReactiveSeq<T>> flux) Widen a ReactiveSeq nested inside another HKT encoded type
static <T,R> Applicative<ReactiveSeq.µ>	zippingApplicative() import static com.aol.cyclops2.hkt.jdk.ReactiveSeq.widen; import static com.aol.cyclops2.util.function.Lambda.l1; import static java.util.Arrays.asList; Lists.zippingApplicative() .ap(widen(asList(l1(this::multiplyByTwo))),widen(asList(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

Instances

public Instances()

Method Detail

functor

public static <T,R> Functor<ReactiveSeq.µ> functor()

Transform a list, mulitplying every element by 2

 
  ReactiveSeq<Integer> list = Lists.functor().map(i->i*2, ReactiveSeq.widen(Arrays.asList(1,2,3));

  //[2,4,6]


 
 

An example fluent api working with Lists

 
   ReactiveSeq<Integer> list = ReactiveSeq.Instances.unit()
        .unit("hello")
        .apply(h->Lists.functor().map((String v) ->v.length(), h))
        .convert(ReactiveSeq::narrowK);

 
 

Returns:

A functor for Lists

unit

public static <T> Pure<ReactiveSeq.µ> unit()

 
 ReactiveSeq<String> list = Lists.unit()
        .unit("hello")
        .convert(ReactiveSeq::narrowK);

        //Arrays.asList("hello"))

 
 

Returns:

A factory for Lists

zippingApplicative

public static <T,R> Applicative<ReactiveSeq.µ> zippingApplicative()

 
 import static com.aol.cyclops2.hkt.jdk.ReactiveSeq.widen;
 import static com.aol.cyclops2.util.function.Lambda.l1;
 import static java.util.Arrays.asList;

        Lists.zippingApplicative()
        .ap(widen(asList(l1(this::multiplyByTwo))),widen(asList(1,2,3)));

 //[2,4,6]
 
 

Example fluent API

 
 ReactiveSeq<Function<Integer,Integer>> listFn =Lists.unit()
                                                  .unit(Lambda.l1((Integer i) ->i*2))
                                                  .convert(ReactiveSeq::narrowK);

        ReactiveSeq<Integer> list = Lists.unit()
        .unit("hello")
        .apply(h->Lists.functor().map((String v) ->v.length(), h))
        .apply(h->Lists.zippingApplicative().ap(listFn, h))
        .convert(ReactiveSeq::narrowK);

        //Arrays.asList("hello".length()*2))

 
 

Returns:

A zipper for Lists

monad

public static <T,R> Monad<ReactiveSeq.µ> monad()

 
 import static com.aol.cyclops2.hkt.jdk.ReactiveSeq.widen;
 ReactiveSeq<Integer> list  = Lists.monad()
        .flatMap(i->widen(ReactiveSeq.range(0,i)), widen(Arrays.asList(1,2,3)))
        .convert(ReactiveSeq::narrowK);
 
 

Example fluent API

 
    ReactiveSeq<Integer> list = Lists.unit()
        .unit("hello")
        .apply(h->Lists.monad().flatMap((String v) ->Lists.unit().unit(v.length()), h))
        .convert(ReactiveSeq::narrowK);

        //Arrays.asList("hello".length())

 
 

Returns:

Type class with monad functions for Lists

monadZero

public static <T,R> MonadZero<ReactiveSeq.µ> monadZero()

 
  ReactiveSeq<String> list = Lists.unit()
        .unit("hello")
        .apply(h->Lists.monadZero().filter((String t)->t.startsWith("he"), h))
        .convert(ReactiveSeq::narrowK);

        //Arrays.asList("hello"));

 
 

Returns:

A filterable monad (with default value)

monadPlus

public static <T> MonadPlus<ReactiveSeq.µ> monadPlus()

 
  ReactiveSeq<Integer> list = Lists.<Integer>monadPlus()
        .plus(ReactiveSeq.widen(Arrays.asList()), ReactiveSeq.widen(Arrays.asList(10)))
        .convert(ReactiveSeq::narrowK);
        //Arrays.asList(10))

 
 

Returns:

Type class for combining Lists by concatenation

monadPlus

public static <T> MonadPlus<ReactiveSeq.µ> monadPlus(Monoid<ReactiveSeq<T>> m)

 
  Monoid<ReactiveSeq<Integer>> m = Monoid.of(ReactiveSeq.widen(Arrays.asList()), (a,b)->a.isEmpty() ? b : a);
        ReactiveSeq<Integer> list = Lists.<Integer>monadPlus(m)
        .plus(ReactiveSeq.widen(Arrays.asList(5)), ReactiveSeq.widen(Arrays.asList(10)))
        .convert(ReactiveSeq::narrowK);
        //Arrays.asList(5))

 
 

Parameters:

m - Monoid toNested use for combining Lists

Returns:

Type class for combining Lists

traverse

public static <C2,T> Traverse<ReactiveSeq.µ> traverse()

Returns:

Type class for traversables with traverse / sequence operations

foldable

public static <T> Foldable<ReactiveSeq.µ> foldable()

 
 int sum  = Lists.foldable()
        .foldLeft(0, (a,b)->a+b, ReactiveSeq.of(1,2,3,4));

        //10

 
 

Returns:

Type class for folding / reduction operations

widen2

public static <C2,T> Higher<C2,Higher<ReactiveSeq.µ,T>> widen2(Higher<C2,ReactiveSeq<T>> flux)

Widen a ReactiveSeq nested inside another HKT encoded type

Parameters:

flux - HTK encoded type containing a List toNested widen

Returns:

HKT encoded type with a widened List

narrow

public static <T> ReactiveSeq<T> narrow(Higher<ReactiveSeq.µ,T> completableList)

Convert the HigherKindedType definition for a List into

Parameters:

List - Type Constructor toNested convert back into narrowed type

Returns:

List from Higher Kinded Type