cyclops.collections.mutable

Class ListX.Instances

java.lang.Object

cyclops.collections.mutable.ListX.Instances

Enclosing interface:

ListX<T>

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

Constructor Summary

Constructors

Constructor and Description
Instances()

Method Summary

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

Transform a list, mulitplying every element by 2

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

  //[2,4,6]


 
 

An example fluent api working with Lists

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

 
 

Returns:

A functor for Lists

unit

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

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

        //Arrays.asList("hello"))

 
 

Returns:

A factory for Lists

zippingApplicative

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

 
 import static com.aol.cyclops2.hkt.jdk.ListX.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

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

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

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

 
 

Returns:

A zipper for Lists

monad

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

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

Example fluent API

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

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

 
 

Returns:

Type class with monad functions for Lists

monadZero

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

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

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

 
 

Returns:

A filterable monad (with default value)

monadPlus

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

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

 
 

Returns:

Type class for combining Lists by concatenation

monadPlus

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

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

 
 

Parameters:

m - Monoid toNested use for combining Lists

Returns:

Type class for combining Lists

traverse

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

Returns:

Type class for traversables with traverse / sequence operations

foldable

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

 
 int sum  = Lists.foldable()
        .foldLeft(0, (a,b)->a+b, ListX.widen(Arrays.asList(1,2,3,4)));

        //10

 
 

Returns:

Type class for folding / reduction operations

widen2

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

Widen a ListType nested inside another HKT encoded type

Parameters:

flux - HTK encoded type containing a List toNested widen

Returns:

HKT encoded type with a widened List

narrowK

public static <T> ListX<T> narrowK(Higher<ListX.µ,T> future)

Convert the raw Higher Kinded Type for ListType types into the ListType type definition class

Parameters:

future - HKT encoded list into a ListType

Returns:

ListType

narrow

public static <T> ListX<T> narrow(Higher<ListX.µ,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