cyclops.typeclasses

Class Product.Instances<W1,W2>

java.lang.Object

cyclops.typeclasses.Product.Instances<W1,W2>

All Implemented Interfaces:

InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

Enclosing class:

Product<W1,W2,T>

public static class Product.Instances<W1,W2>
extends java.lang.Object
implements InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

Constructor Summary

Constructors

Constructor and Description
Instances()

Method Summary

Modifier and Type	Method and Description
Applicative<Higher<Higher<Witness.product,W1>,W2>>	applicative()
<T> Maybe<Comonad<Higher<Higher<Witness.product,W1>,W2>>>	comonad()
static <W1,W2> InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>	definitions(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)
<T> Foldable<Higher<Higher<Witness.product,W1>,W2>>	foldable()
Functor<Higher<Higher<Witness.product,W1>,W2>>	functor()
Monad<Higher<Higher<Witness.product,W1>,W2>>	monad()
<T> Maybe<MonadPlus<Higher<Higher<Witness.product,W1>,W2>>>	monadPlus()
<T> Maybe<MonadPlus<Higher<Higher<Witness.product,W1>,W2>>>	monadPlus(Monoid<Higher<Higher<Higher<Witness.product,W1>,W2>,T>> m)
MonadRec<Higher<Higher<Witness.product,W1>,W2>>	monadRec()
<T,R> Maybe<MonadZero<Higher<Higher<Witness.product,W1>,W2>>>	monadZero()
<C2,T> Traverse<Higher<Higher<Witness.product,W1>,W2>>	traverse()
<T> Maybe<Unfoldable<Higher<Higher<Witness.product,W1>,W2>>>	unfoldable()
Pure<Higher<Higher<Witness.product,W1>,W2>>	unit()

Methods inherited from class java.lang.Object

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

Methods inherited from interface cyclops.typeclasses.InstanceDefinitions

applicativeError, contravariantFunctor, eq, profunctor, show

Constructor Detail

Instances

public Instances()

Method Detail

definitions

public static <W1,W2> InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>> definitions(InstanceDefinitions<W1> def1,
                                                                                             InstanceDefinitions<W2> def2)

functor

public Functor<Higher<Higher<Witness.product,W1>,W2>> functor()

Specified by:

functor in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

unit

public Pure<Higher<Higher<Witness.product,W1>,W2>> unit()

Specified by:

unit in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

applicative

public Applicative<Higher<Higher<Witness.product,W1>,W2>> applicative()

Specified by:

applicative in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

monad

public Monad<Higher<Higher<Witness.product,W1>,W2>> monad()

Specified by:

monad in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

monadZero

public <T,R> Maybe<MonadZero<Higher<Higher<Witness.product,W1>,W2>>> monadZero()

Specified by:

monadZero in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

monadRec

public MonadRec<Higher<Higher<Witness.product,W1>,W2>> monadRec()

Specified by:

monadRec in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

monadPlus

public <T> Maybe<MonadPlus<Higher<Higher<Witness.product,W1>,W2>>> monadPlus()

Specified by:

monadPlus in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

monadPlus

public <T> Maybe<MonadPlus<Higher<Higher<Witness.product,W1>,W2>>> monadPlus(Monoid<Higher<Higher<Higher<Witness.product,W1>,W2>,T>> m)

Specified by:

monadPlus in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

traverse

public <C2,T> Traverse<Higher<Higher<Witness.product,W1>,W2>> traverse()

Specified by:

traverse in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

foldable

public <T> Foldable<Higher<Higher<Witness.product,W1>,W2>> foldable()

Specified by:

foldable in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

comonad

public <T> Maybe<Comonad<Higher<Higher<Witness.product,W1>,W2>>> comonad()

Specified by:

comonad in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>

unfoldable

public <T> Maybe<Unfoldable<Higher<Higher<Witness.product,W1>,W2>>> unfoldable()

Specified by:

unfoldable in interface InstanceDefinitions<Higher<Higher<Witness.product,W1>,W2>>