cyclops.typeclasses

Class Nested<W1,W2,T>

java.lang.Object

cyclops.typeclasses.Nested<W1,W2,T>

Type Parameters:

W1 - First Witness type Witness

W2 - Second Witness type Witness

T - Nested Data Type

All Implemented Interfaces:

Convert<Higher<Higher<Higher<Witness.nested,W1>,W2>,T>>, Higher<Higher<Higher<Witness.nested,W1>,W2>,T>, Higher2<Higher<Witness.nested,W1>,W2,T>, Higher3<Witness.nested,W1,W2,T>, To<Nested<W1,W2,T>>, Transformable<T>

public class Nested<W1,W2,T>
extends java.lang.Object
implements Transformable<T>, Higher3<Witness.nested,W1,W2,T>, To<Nested<W1,W2,T>>

Class for working with Nested Data Structures. E.g. to work with a List of Optionals

     
      import cyclops.monads.Witness.list;
        import cyclops.monads.Witness.optional;

      Nested<list,optional,Integer> listOfOptionalInt = Nested.of(ListX.of(Optionals.OptionalKind.of(2)),ListX.Instances.definitions(),Optionals.Instances.definitions());
      //Nested[List[Optional[2]]]
     

 

Transform nest data

     
     Nested<list,optional,Integer> listOfOptionalInt;  //Nested[List[Optional[2]]]
     Nested<list,optional,Integer> doubled = listOfOptionalInt.map(i->i*2);
      //Nested[List[Optional[4]]]
     


 

Sequencing data

     
     Nested<list,optional,Integer> listOfOptionalInt;  //Nested[List[Optional[2]]]
     Nested<optional,list,Integer> sequenced = listOfOptionalInt.sequence();
     //Nested[Optional[List[2]]]

     


 

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	Nested.Converter<W,S>
static class	Nested.Instances
static class	Nested.NestedComprehensions<W1,W2,T>
class	Nested.Plus
class	Nested.Unfolds

Field Summary

Fields

Modifier and Type	Field and Description
InstanceDefinitions<W1>	def1
InstanceDefinitions<W2>	def2
Higher<W1,Higher<W2,T>>	nested

Constructor Summary

Constructors

Constructor and Description
Nested()

Method Summary

Modifier and Type	Method and Description
Active<Higher<Higher<Witness.nested,W1>,W2>,T>	allTypeclasses(TransformerFactory<W1,W2> factory)
<R> Nested<W1,W2,R>	ap(Higher<W2,? extends java.util.function.Function<T,R>> fn)
<U> Nested<W1,W2,U>	cast(java.lang.Class<? extends U> type) Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException.
static <T> Nested<Witness.completableFuture,Witness.stream,T>	completableFutureStream(java.util.concurrent.CompletableFuture<? extends java.util.stream.Stream<T>> optionalList)
Nested.NestedComprehensions<W1,W2,T>	comprehensions(TransformerFactory<W1,W2> factory)
Maybe<Nested.NestedComprehensions.Guarded<W1,W2,T>>	comprehensionsGuarded(TransformerFactory<W1,W2> factory)
Maybe<Comprehensions.Guarded<Higher<Higher<Witness.nested,W1>,W2>>>	comprehensionsGuardedHk(TransformerFactory<W1,W2> factory)
Comprehensions<Higher<Higher<Witness.nested,W1>,W2>>	comprehensionsHk(TransformerFactory<W1,W2> factory)
<C,R> cyclops.typeclasses.Nested.NarrowedApplicative<C,R>	concreteAp(Kleisli<W2,C,java.util.function.Function<T,R>> widen)
<S,R> Nested.Converter<W1,S>	concreteConversion(java.util.function.Function<? super Higher<W2,T>,? extends S> narrow2)
<C,R> cyclops.typeclasses.Nested.NarrowedFlatMap<C,R>	concreteFlatMap(Kleisli<W2,C,R> widen)
<C> cyclops.typeclasses.Nested.Narrowed<C>	concreteMonoid(Kleisli<W2,C,T> widen, Cokleisli<W2,T,C> narrow)
<C,R> cyclops.typeclasses.Nested.NarrowedTailRec<C,R>	concreteTailRec(Kleisli<W2,C,Xor<T,R>> widen)
InstanceDefinitions<Higher<Higher<Witness.nested,W1>,W2>>	definitions(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2, TransformerFactory<W1,W2> factory)
InstanceDefinitions<Higher<Higher<Witness.nested,W1>,W2>>	definitions(InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2, TransformerFactory<W1,W2> factory, Maybe<Higher<W2,?>> zero)
<R> Nested<W1,W2,R>	flatMap(java.util.function.Function<? super T,? extends Higher<W2,R>> fn)
<R,X> Nested<W1,W2,R>	flatMap(java.util.function.Function<? super X,? extends Higher<W2,R>> widenFn, java.util.function.Function<? super T,? extends X> fn)
<R> Nested<W1,W2,R>	flatMapA(java.util.function.Function<? super T,? extends Active<W2,R>> fn)
<C2,T> Higher<C2,Nested<W1,W2,T>>	flatSequence(Applicative<C2> applicative, Nested<W1,W2,Higher<C2,Nested<W1,W2,T>>> fgfa, TransformerFactory<W1,W2> factory)
static <W,T> Active<W,T>	flatten(Nested<W,W,T> nested)
<C2,R> Higher<C2,Nested<W1,W2,R>>	flatTraverse(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,Nested<W1,W2,R>>> f, TransformerFactory<W1,W2> factory)
<R> R	fold(java.util.function.Function<? super Higher<W1,Higher<W2,T>>,? extends R> fn)
T	foldBothl(T identity, java.util.function.BinaryOperator<T> semigroup)
T	foldBothLeft(Monoid<T> monoid)
T	foldBothr(T identity, java.util.function.BinaryOperator<T> semigroup)
T	foldBothRight(Monoid<T> monoid)
Active<W1,T>	foldl(Monoid<T> monoid)
Active<W1,T>	foldl(T identity, java.util.function.BinaryOperator<T> semigroup)
Higher<W1,T>	foldLeft(Monoid<T> monoid)
<R> R	foldLeft(Monoid<T> monoid, java.util.function.Function<? super Higher<W1,T>,? extends R> narrowK)
Higher<W1,T>	foldLeft(T identity, java.util.function.BinaryOperator<T> semigroup)
<R> Higher<W1,R>	foldMap(Monoid<R> mb, java.util.function.Function<? super T,? extends R> fn)
<R> Active<W1,R>	foldMapA(Monoid<R> mb, java.util.function.Function<? super T,? extends R> fn)
<R> R	foldMapBoth(Monoid<R> mb, java.util.function.Function<? super T,? extends R> fn)
Active<W1,T>	foldr(Monoid<T> monoid)
Active<W1,T>	foldr(T identity, java.util.function.BinaryOperator<T> semigroup)
Higher<W1,T>	foldRight(Monoid<T> monoid)
<R> R	foldRight(Monoid<T> monoid, java.util.function.Function<? super Higher<W1,T>,? extends R> narrowK)
Higher<W1,T>	foldRight(T identity, java.util.function.BinaryOperator<T> semigroup)
static <T> Nested<Witness.future,Witness.list,T>	futureList(Future<? extends java.util.List<T>> futureList)
static <T,X extends java.lang.Throwable> Nested<Witness.future,Higher<Witness.tryType,X>,T>	futureTry(Future<? extends Try<T,X>> futureTry)
static <T> Nested<Witness.future,Witness.vectorX,T>	futureVector(Future<VectorX<T>> futureList)
static <L,R> Nested<Witness.future,Higher<Witness.xor,L>,R>	futureXor(Future<? extends Xor<L,R>> futureXor)
Higher<W1,Higher<W2,T>>	getNested()
<R> java.util.function.Function<Nested<W1,W2,T>,Nested<W1,W2,R>>	lift(java.util.function.Function<? super T,? extends R> fn)
static <T,X extends java.lang.Throwable> Nested<Witness.list,Higher<Witness.tryType,X>,T>	listTry(java.util.List<? extends Try<T,X>> futureTry)
static <L,R> Nested<Witness.list,Higher<Witness.xor,L>,R>	listXor(java.util.List<? extends Xor<L,R>> listXor)
<R> Nested<W1,W2,R>	map(java.util.function.Function<? super T,? extends R> fn) Transform this functor using the supplied transformation function
<R> Nested<W1,W2,R>	mapWithIndex(java.util.function.BiFunction<? super T,java.lang.Long,? extends R> f)
static <W1,W2,T> Higher<W1,Higher<W2,T>>	narrow(Higher<W1,? extends Higher<W2,? extends T>> nested)
static <W1,W2,T> Nested<W1,W2,T>	narrowK(Higher<Higher<Higher<Witness.nested,W1>,W2>,T> ds)
static <W1,W2,T> Nested<W1,W2,T>	of(Active<W1,? extends Higher<W2,? extends T>> nested, InstanceDefinitions<W2> def2)
static <W1,W2,T> Nested<W1,W2,T>	of(Higher<W1,? extends Higher<W2,? extends T>> nested, InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)
static <T> Nested<Witness.optional,Witness.list,T>	optionalList(java.util.Optional<? extends java.util.List<T>> optionalList)
static <T> Nested<Witness.optional,Witness.stream,T>	optionalStream(java.util.Optional<? extends java.util.stream.Stream<T>> optionalList)
Nested<W1,W2,T>	peek(java.util.function.Consumer<? super T> fn) Peek at the current value of this Transformable, without transforming it
Maybe<Nested.Plus>	plus()
Nested.Plus	plus(MonadPlus<W1> plus1, MonadPlus<W2> plus2)
Nested<W1,W2,T>	plusNested(SemigroupK<W2,T> semigroupK, Higher<W2,T> add)
Nested.Plus	plusUnsafe()
<R> Active<W1,R>	pure1(R value)
<R> Nested<W1,W2,R>	pure2(R value)
<R> Nested<W1,W2,R>	retry(java.util.function.Function<? super T,? extends R> fn) Retry a transformation if it fails.
<R> Nested<W1,W2,R>	retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit) Retry a transformation if it fails.
Nested<W1,W2,T>	reverse()
Nested<W2,W1,T>	sequence()
<C2,T> Higher<C2,Nested<W1,W2,T>>	sequenceA(Applicative<C2> applicative, Nested<W1,W2,Higher<C2,T>> ds)
Active<W1,java.lang.Long>	size()
Active<W1,ReactiveSeq<T>>	stream()
ReactiveSeq<T>	streamBoth()
<R> Nested<W1,W2,R>	tailRec(T initial, java.util.function.Function<? super T,? extends Nested<W1,W2,? extends Xor<T,R>>> fn)
<R> Nested<W1,W2,R>	tailRecN(T initial, java.util.function.Function<? super T,? extends Higher<W2,? extends Xor<T,R>>> fn)
Active<W1,ListX<T>>	toListX()
ListX<T>	toListXBoth()
java.lang.String	toString()
long	totalSize()
<R> Nested<W1,W2,R>	trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper) Performs a map operation that can call a recursive method without running out of stack space
Transformer<W1,W2,T>	transformer(TransformerFactory<W1,W2> factory)
<R> Nested<W2,W1,R>	traverse(java.util.function.Function<? super T,? extends R> fn)
<C2,R> Higher<C2,Nested<W1,W2,R>>	traverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,R>> fn)
Maybe<Nested.Unfolds>	unfolds()
Nested.Unfolds	unfolds(Unfoldable<W2> unf)
Nested.Unfolds	unfoldsUnsafe()
<T2,R> Nested<W1,W2,org.jooq.lambda.tuple.Tuple2<T,T2>>	zip(Higher<W2,T2> fb)
<T2,R> Nested<W1,W2,R>	zip(Higher<W2,T2> fb, java.util.function.BiFunction<? super T,? super T2,? extends R> f)
<R> Nested<W1,W2,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>	zipWithIndex()

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.aol.cyclops2.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert

convert

Methods inherited from interface com.aol.cyclops2.types.foldable.To

to

Field Detail

nested

public final Higher<W1,Higher<W2,T>> nested

def1

public final InstanceDefinitions<W1> def1

def2

public final InstanceDefinitions<W2> def2

Constructor Detail

Nested

public Nested()

Method Detail

transformer

public Transformer<W1,W2,T> transformer(TransformerFactory<W1,W2> factory)

of

public static <W1,W2,T> Nested<W1,W2,T> of(Higher<W1,? extends Higher<W2,? extends T>> nested,
                                           InstanceDefinitions<W1> def1,
                                           InstanceDefinitions<W2> def2)

of

public static <W1,W2,T> Nested<W1,W2,T> of(Active<W1,? extends Higher<W2,? extends T>> nested,
                                           InstanceDefinitions<W2> def2)

narrow

public static <W1,W2,T> Higher<W1,Higher<W2,T>> narrow(Higher<W1,? extends Higher<W2,? extends T>> nested)

flatten

public static <W,T> Active<W,T> flatten(Nested<W,W,T> nested)

getNested

public Higher<W1,Higher<W2,T>> getNested()

fold

public <R> R fold(java.util.function.Function<? super Higher<W1,Higher<W2,T>>,? extends R> fn)

pure1

public <R> Active<W1,R> pure1(R value)

pure2

public <R> Nested<W1,W2,R> pure2(R value)

map

public <R> Nested<W1,W2,R> map(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Transformable

Transform this functor using the supplied transformation function

 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 

Specified by:

map in interface Transformable<T>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

toListX

public Active<W1,ListX<T>> toListX()

toListXBoth

public ListX<T> toListXBoth()

stream

public Active<W1,ReactiveSeq<T>> stream()

streamBoth

public ReactiveSeq<T> streamBoth()

size

public Active<W1,java.lang.Long> size()

reverse

public Nested<W1,W2,T> reverse()

totalSize

public long totalSize()

mapWithIndex

public <R> Nested<W1,W2,R> mapWithIndex(java.util.function.BiFunction<? super T,java.lang.Long,? extends R> f)

zipWithIndex

public <R> Nested<W1,W2,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

peek

public Nested<W1,W2,T> peek(java.util.function.Consumer<? super T> fn)

Description copied from interface: Transformable

Peek at the current value of this Transformable, without transforming it

 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 

Specified by:

peek in interface Transformable<T>

Parameters:

fn - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

lift

public <R> java.util.function.Function<Nested<W1,W2,T>,Nested<W1,W2,R>> lift(java.util.function.Function<? super T,? extends R> fn)

ap

public <R> Nested<W1,W2,R> ap(Higher<W2,? extends java.util.function.Function<T,R>> fn)

flatMap

public <R> Nested<W1,W2,R> flatMap(java.util.function.Function<? super T,? extends Higher<W2,R>> fn)

flatMap

public <R,X> Nested<W1,W2,R> flatMap(java.util.function.Function<? super X,? extends Higher<W2,R>> widenFn,
                                     java.util.function.Function<? super T,? extends X> fn)

zip

public <T2,R> Nested<W1,W2,R> zip(Higher<W2,T2> fb,
                                  java.util.function.BiFunction<? super T,? super T2,? extends R> f)

zip

public <T2,R> Nested<W1,W2,org.jooq.lambda.tuple.Tuple2<T,T2>> zip(Higher<W2,T2> fb)

concreteMonoid

public <C> cyclops.typeclasses.Nested.Narrowed<C> concreteMonoid(Kleisli<W2,C,T> widen,
                                                                 Cokleisli<W2,T,C> narrow)

concreteFlatMap

public <C,R> cyclops.typeclasses.Nested.NarrowedFlatMap<C,R> concreteFlatMap(Kleisli<W2,C,R> widen)

concreteAp

public <C,R> cyclops.typeclasses.Nested.NarrowedApplicative<C,R> concreteAp(Kleisli<W2,C,java.util.function.Function<T,R>> widen)

concreteTailRec

public <C,R> cyclops.typeclasses.Nested.NarrowedTailRec<C,R> concreteTailRec(Kleisli<W2,C,Xor<T,R>> widen)

concreteConversion

public <S,R> Nested.Converter<W1,S> concreteConversion(java.util.function.Function<? super Higher<W2,T>,? extends S> narrow2)

flatMapA

public <R> Nested<W1,W2,R> flatMapA(java.util.function.Function<? super T,? extends Active<W2,R>> fn)

tailRecN

public <R> Nested<W1,W2,R> tailRecN(T initial,
                                    java.util.function.Function<? super T,? extends Higher<W2,? extends Xor<T,R>>> fn)

tailRec

public <R> Nested<W1,W2,R> tailRec(T initial,
                                   java.util.function.Function<? super T,? extends Nested<W1,W2,? extends Xor<T,R>>> fn)

unfolds

public Nested.Unfolds unfolds(Unfoldable<W2> unf)

plus

public Nested.Plus plus(MonadPlus<W1> plus1,
                        MonadPlus<W2> plus2)

unfoldsUnsafe

public Nested.Unfolds unfoldsUnsafe()

plusUnsafe

public Nested.Plus plusUnsafe()

unfolds

public Maybe<Nested.Unfolds> unfolds()

plusNested

public Nested<W1,W2,T> plusNested(SemigroupK<W2,T> semigroupK,
                                  Higher<W2,T> add)

plus

public Maybe<Nested.Plus> plus()

foldMapBoth

public <R> R foldMapBoth(Monoid<R> mb,
                         java.util.function.Function<? super T,? extends R> fn)

foldBothl

public T foldBothl(T identity,
                   java.util.function.BinaryOperator<T> semigroup)

foldBothr

public T foldBothr(T identity,
                   java.util.function.BinaryOperator<T> semigroup)

foldBothRight

public T foldBothRight(Monoid<T> monoid)

foldBothLeft

public T foldBothLeft(Monoid<T> monoid)

foldRight

public <R> R foldRight(Monoid<T> monoid,
                       java.util.function.Function<? super Higher<W1,T>,? extends R> narrowK)

foldLeft

public <R> R foldLeft(Monoid<T> monoid,
                      java.util.function.Function<? super Higher<W1,T>,? extends R> narrowK)

foldl

public Active<W1,T> foldl(T identity,
                          java.util.function.BinaryOperator<T> semigroup)

foldr

public Active<W1,T> foldr(T identity,
                          java.util.function.BinaryOperator<T> semigroup)

foldl

public Active<W1,T> foldl(Monoid<T> monoid)

foldr

public Active<W1,T> foldr(Monoid<T> monoid)

foldMapA

public <R> Active<W1,R> foldMapA(Monoid<R> mb,
                                 java.util.function.Function<? super T,? extends R> fn)

foldMap

public <R> Higher<W1,R> foldMap(Monoid<R> mb,
                                java.util.function.Function<? super T,? extends R> fn)

foldRight

public Higher<W1,T> foldRight(Monoid<T> monoid)

foldLeft

public Higher<W1,T> foldLeft(Monoid<T> monoid)

foldLeft

public Higher<W1,T> foldLeft(T identity,
                             java.util.function.BinaryOperator<T> semigroup)

foldRight

public Higher<W1,T> foldRight(T identity,
                              java.util.function.BinaryOperator<T> semigroup)

traverseA

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

sequenceA

public <C2,T> Higher<C2,Nested<W1,W2,T>> sequenceA(Applicative<C2> applicative,
                                                   Nested<W1,W2,Higher<C2,T>> ds)

flatTraverse

public <C2,R> Higher<C2,Nested<W1,W2,R>> flatTraverse(Applicative<C2> applicative,
                                                      java.util.function.Function<? super T,? extends Higher<C2,Nested<W1,W2,R>>> f,
                                                      TransformerFactory<W1,W2> factory)

flatSequence

public <C2,T> Higher<C2,Nested<W1,W2,T>> flatSequence(Applicative<C2> applicative,
                                                      Nested<W1,W2,Higher<C2,Nested<W1,W2,T>>> fgfa,
                                                      TransformerFactory<W1,W2> factory)

sequence

public Nested<W2,W1,T> sequence()

traverse

public <R> Nested<W2,W1,R> traverse(java.util.function.Function<? super T,? extends R> fn)

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

cast

public <U> Nested<W1,W2,U> cast(java.lang.Class<? extends U> type)

Description copied from interface: Transformable

Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Transformable<T>

trampoline

public <R> Nested<W1,W2,R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Transformable

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);

    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}

 55
    	6765
    	832040
    	102334155


 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);


 completes successfully
 
 

Specified by:

trampoline in interface Transformable<T>

Parameters:

mapper - TCO Transformation function

Returns:

Transformable transformed by the supplied transformation function

retry

public <R> Nested<W1,W2,R> retry(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Transformable

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock)
 				.firstValue();

 		//result = 42
 
 

Specified by:

retry in interface Transformable<T>

Parameters:

fn - Function to retry if fails

retry

public <R> Nested<W1,W2,R> retry(java.util.function.Function<? super T,? extends R> fn,
                                 int retries,
                                 long delay,
                                 java.util.concurrent.TimeUnit timeUnit)

Description copied from interface: Transformable

Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = 42
 
 

Specified by:

retry in interface Transformable<T>

Parameters:

fn - Function to retry if fails

retries - Number of retries

delay - Delay in TimeUnits

timeUnit - TimeUnit to use for delay

completableFutureStream

public static <T> Nested<Witness.completableFuture,Witness.stream,T> completableFutureStream(java.util.concurrent.CompletableFuture<? extends java.util.stream.Stream<T>> optionalList)

optionalStream

public static <T> Nested<Witness.optional,Witness.stream,T> optionalStream(java.util.Optional<? extends java.util.stream.Stream<T>> optionalList)

optionalList

public static <T> Nested<Witness.optional,Witness.list,T> optionalList(java.util.Optional<? extends java.util.List<T>> optionalList)

futureTry

public static <T,X extends java.lang.Throwable> Nested<Witness.future,Higher<Witness.tryType,X>,T> futureTry(Future<? extends Try<T,X>> futureTry)

listTry

public static <T,X extends java.lang.Throwable> Nested<Witness.list,Higher<Witness.tryType,X>,T> listTry(java.util.List<? extends Try<T,X>> futureTry)

listXor

public static <L,R> Nested<Witness.list,Higher<Witness.xor,L>,R> listXor(java.util.List<? extends Xor<L,R>> listXor)

futureXor

public static <L,R> Nested<Witness.future,Higher<Witness.xor,L>,R> futureXor(Future<? extends Xor<L,R>> futureXor)

futureList

public static <T> Nested<Witness.future,Witness.list,T> futureList(Future<? extends java.util.List<T>> futureList)

futureVector

public static <T> Nested<Witness.future,Witness.vectorX,T> futureVector(Future<VectorX<T>> futureList)

narrowK

public static <W1,W2,T> Nested<W1,W2,T> narrowK(Higher<Higher<Higher<Witness.nested,W1>,W2>,T> ds)

comprehensionsGuarded

public Maybe<Nested.NestedComprehensions.Guarded<W1,W2,T>> comprehensionsGuarded(TransformerFactory<W1,W2> factory)

comprehensions

public Nested.NestedComprehensions<W1,W2,T> comprehensions(TransformerFactory<W1,W2> factory)

comprehensionsGuardedHk

public Maybe<Comprehensions.Guarded<Higher<Higher<Witness.nested,W1>,W2>>> comprehensionsGuardedHk(TransformerFactory<W1,W2> factory)

comprehensionsHk

public Comprehensions<Higher<Higher<Witness.nested,W1>,W2>> comprehensionsHk(TransformerFactory<W1,W2> factory)

allTypeclasses

public Active<Higher<Higher<Witness.nested,W1>,W2>,T> allTypeclasses(TransformerFactory<W1,W2> factory)

definitions

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

definitions

public InstanceDefinitions<Higher<Higher<Witness.nested,W1>,W2>> definitions(InstanceDefinitions<W1> def1,
                                                                             InstanceDefinitions<W2> def2,
                                                                             TransformerFactory<W1,W2> factory,
                                                                             Maybe<Higher<W2,?>> zero)