cyclops.companion

Class Streams.Instances

java.lang.Object

cyclops.companion.Streams.Instances

Enclosing class:

Streams

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

Companion class for creating Type Class instances for working with Streams

Constructor Summary

Constructors

Constructor and Description
Instances()

Method Summary

Modifier and Type	Method and Description
static InstanceDefinitions<Witness.stream>	definitions()
static <T,R> Foldable<Witness.stream>	foldable() int sum = Streams.foldable() .foldLeft(0, (a,b)->a+b, StreamKind.widen(Stream.of(1,2,3,4))); //10
static <T,R> Functor<Witness.stream>	functor()
static <T,R> Monad<Witness.stream>	monad() import static com.aol.cyclops.hkt.jdk.StreamKind.widen; StreamKind<Integer> list = Streams.monad() .flatMap(i->widen(StreamX.range(0,i)), widen(Stream.of(1,2,3))) .convert(StreamKind::narrow);
static <T> MonadPlus<Witness.stream>	monadPlus() StreamKind<Integer> list = Streams.<Integer>monadPlus() .plus(StreamKind.widen(Stream.of()), StreamKind.widen(Stream.of(10))) .convert(StreamKind::narrow); //Stream.of(10))
static <T> MonadPlus<Witness.stream>	monadPlus(Monoid<Streams.StreamKind<T>> m) Monoid<StreamKind<Integer>> m = Monoid.of(StreamKind.widen(Stream.of()), (a,b)->a.isEmpty() ? b : a); StreamKind<Integer> list = Streams.<Integer>monadPlus(m) .plus(StreamKind.widen(Stream.of(5)), StreamKind.widen(Stream.of(10))) .convert(StreamKind::narrow); //Stream.of(5))
static <T,R> MonadRec<Witness.stream>	monadRec()
static <T,R> MonadZero<Witness.stream>	monadZero() StreamKind<String> list = Streams.unit() .unit("hello") .applyHKT(h->Streams.monadZero().filter((String t)->t.startsWith("he"), h)) .convert(StreamKind::narrow); //Stream.of("hello"));
static <C2,T> Traverse<Witness.stream>	traverse()
static Unfoldable<Witness.stream>	unfoldable()
static <T> Pure<Witness.stream>	unit() StreamKind<String> list = Streams.unit() .unit("hello") .convert(StreamKind::narrow); //Stream.of("hello"))
static <T,R> Applicative<Witness.stream>	zippingApplicative() import static com.aol.cyclops.hkt.jdk.StreamKind.widen; import static com.aol.cyclops.util.function.Lambda.l1; Streams.zippingApplicative() .ap(widen(Stream.of(l1(this::multiplyByTwo))),widen(Stream.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

Instances

public Instances()

Method Detail

definitions

public static InstanceDefinitions<Witness.stream> definitions()

unfoldable

public static Unfoldable<Witness.stream> unfoldable()

functor

public static <T,R> Functor<Witness.stream> functor()

unit

public static <T> Pure<Witness.stream> unit()

 
 StreamKind<String> list = Streams.unit()
        .unit("hello")
        .convert(StreamKind::narrow);

        //Stream.of("hello"))

 
 

Returns:

A factory for Streams

zippingApplicative

public static <T,R> Applicative<Witness.stream> zippingApplicative()

 
 import static com.aol.cyclops.hkt.jdk.StreamKind.widen;
 import static com.aol.cyclops.util.function.Lambda.l1;

        Streams.zippingApplicative()
        .ap(widen(Stream.of(l1(this::multiplyByTwo))),widen(Stream.of(1,2,3)));

 //[2,4,6]
 
 

Example fluent API

 
 StreamKind<Function<Integer,Integer>> listFn =Streams.unit()
                                                  .unit(Lambda.l1((Integer i) ->i*2))
                                                  .convert(StreamKind::narrow);

        StreamKind<Integer> list = Streams.unit()
        .unit("hello")
        .applyHKT(h->Streams.functor().map((String v) ->v.length(), h))
        .applyHKT(h->Streams.zippingApplicative().ap(listFn, h))
        .convert(StreamKind::narrow);

        //Stream.of("hello".length()*2))

 
 

Returns:

A zipper for Streams

monad

public static <T,R> Monad<Witness.stream> monad()

 
 import static com.aol.cyclops.hkt.jdk.StreamKind.widen;
 StreamKind<Integer> list  = Streams.monad()
        .flatMap(i->widen(StreamX.range(0,i)), widen(Stream.of(1,2,3)))
        .convert(StreamKind::narrow);
 
 

Example fluent API

 
    StreamKind<Integer> list = Streams.unit()
        .unit("hello")
        .applyHKT(h->Streams.monad().flatMap((String v) ->Streams.unit().unit(v.length()), h))
        .convert(StreamKind::narrow);

        //Stream.of("hello".length())

 
 

Returns:

Type class with monad functions for Streams

monadZero

public static <T,R> MonadZero<Witness.stream> monadZero()

 
  StreamKind<String> list = Streams.unit()
        .unit("hello")
        .applyHKT(h->Streams.monadZero().filter((String t)->t.startsWith("he"), h))
        .convert(StreamKind::narrow);

        //Stream.of("hello"));

 
 

Returns:

A filterable monad (with default value)

monadRec

public static <T,R> MonadRec<Witness.stream> monadRec()

monadPlus

public static <T> MonadPlus<Witness.stream> monadPlus()

 
  StreamKind<Integer> list = Streams.<Integer>monadPlus()
        .plus(StreamKind.widen(Stream.of()), StreamKind.widen(Stream.of(10)))
        .convert(StreamKind::narrow);
        //Stream.of(10))

 
 

Returns:

Type class for combining Streams by concatenation

monadPlus

public static <T> MonadPlus<Witness.stream> monadPlus(Monoid<Streams.StreamKind<T>> m)

 
  Monoid<StreamKind<Integer>> m = Monoid.of(StreamKind.widen(Stream.of()), (a,b)->a.isEmpty() ? b : a);
        StreamKind<Integer> list = Streams.<Integer>monadPlus(m)
        .plus(StreamKind.widen(Stream.of(5)), StreamKind.widen(Stream.of(10)))
        .convert(StreamKind::narrow);
        //Stream.of(5))

 
 

Parameters:

m - Monoid to use for combining Streams

Returns:

Type class for combining Streams

traverse

public static <C2,T> Traverse<Witness.stream> traverse()

Returns:

Type class for traversables with traverse / sequence operations

foldable

public static <T,R> Foldable<Witness.stream> foldable()

 
 int sum  = Streams.foldable()
        .foldLeft(0, (a,b)->a+b, StreamKind.widen(Stream.of(1,2,3,4)));

        //10

 
 

Returns:

Type class for folding / reduction operations