cyclops.typeclasses

Class Nested.Instances

java.lang.Object

cyclops.typeclasses.Nested.Instances

Enclosing class:

Nested<W1,W2,T>

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

Constructor Summary

Constructors

Constructor and Description
Instances()

Method Summary

Modifier and Type	Method and Description
static <W1,W2> Applicative<Higher<Higher<Witness.nested,W1>,W2>>	applicative(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2, TransformerFactory<W1,W2> factory)
static <W1,W2> Foldable<Higher<Higher<Witness.nested,W1>,W2>>	foldable()
static <W1,W2> Functor<Higher<Higher<Witness.nested,W1>,W2>>	functor()
static <W1,W2> Monad<Higher<Higher<Witness.nested,W1>,W2>>	monad(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2, TransformerFactory<W1,W2> factory)
static <W1,W2> MonadRec<Higher<Higher<Witness.nested,W1>,W2>>	monadRec(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)
static <W1,W2> MonadZero<Higher<Higher<Witness.nested,W1>,W2>>	monadZero(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2, TransformerFactory<W1,W2> factory, Higher<W2,?> zero)
static <W1,W2,T> Traverse<Higher<Higher<Witness.nested,W1>,W2>>	traverse(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2, TransformerFactory<W1,W2> factory)
static <W1,W2,C2,T,R> Higher<C2,Higher<Higher<Higher<Witness.nested,W1>,W2>,R>>	traverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,R>> fn, Higher<Higher<Higher<Witness.nested,W1>,W2>,T> ds)
static <W1,W2> Unfoldable<Higher<Higher<Witness.nested,W1>,W2>>	unfoldable(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)
static <W1,W2> Pure<Higher<Higher<Witness.nested,W1>,W2>>	unit(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)

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 <W1,W2> Functor<Higher<Higher<Witness.nested,W1>,W2>> functor()

unit

public static <W1,W2> Pure<Higher<Higher<Witness.nested,W1>,W2>> unit(InstanceDefinitions<W1> def1,
                                                                      InstanceDefinitions<W2> def2)

applicative

public static <W1,W2> Applicative<Higher<Higher<Witness.nested,W1>,W2>> applicative(InstanceDefinitions<W1> def1,
                                                                                    InstanceDefinitions<W2> def2,
                                                                                    TransformerFactory<W1,W2> factory)

monadRec

public static <W1,W2> MonadRec<Higher<Higher<Witness.nested,W1>,W2>> monadRec(InstanceDefinitions<W1> def1,
                                                                              InstanceDefinitions<W2> def2)

traverseA

public static <W1,W2,C2,T,R> Higher<C2,Higher<Higher<Higher<Witness.nested,W1>,W2>,R>> traverseA(Applicative<C2> applicative,
                                                                                                 java.util.function.Function<? super T,? extends Higher<C2,R>> fn,
                                                                                                 Higher<Higher<Higher<Witness.nested,W1>,W2>,T> ds)

traverse

public static <W1,W2,T> Traverse<Higher<Higher<Witness.nested,W1>,W2>> traverse(InstanceDefinitions<W1> def1,
                                                                                InstanceDefinitions<W2> def2,
                                                                                TransformerFactory<W1,W2> factory)

monad

public static <W1,W2> Monad<Higher<Higher<Witness.nested,W1>,W2>> monad(InstanceDefinitions<W1> def1,
                                                                        InstanceDefinitions<W2> def2,
                                                                        TransformerFactory<W1,W2> factory)

monadZero

public static <W1,W2> MonadZero<Higher<Higher<Witness.nested,W1>,W2>> monadZero(InstanceDefinitions<W1> def1,
                                                                                InstanceDefinitions<W2> def2,
                                                                                TransformerFactory<W1,W2> factory,
                                                                                Higher<W2,?> zero)

foldable

public static <W1,W2> Foldable<Higher<Higher<Witness.nested,W1>,W2>> foldable()

unfoldable

public static <W1,W2> Unfoldable<Higher<Higher<Witness.nested,W1>,W2>> unfoldable(InstanceDefinitions<W1> def1,
                                                                                  InstanceDefinitions<W2> def2)