com.aol.cyclops2.hkt

Interface Higher<T1,T2>

Type Parameters:

T1 - Core type

T2 - Data type of elements in Core Type

All Superinterfaces:

Convert<Higher<T1,T2>>

All Known Subinterfaces:

CompletableFutureKind<T>, DequeX<T>, Eval<T>, Fn0.SupplierKind<R>, FutureStream<U>, ListX<T>, Maybe<T>, PQueueX<T>, PStackX<T>, PVectorX<T>, QueueX<T>, ReactiveSeq<T>, StreamKind<T>

All Known Implementing Classes:

CompletableFutureKind.Box, Eval.Module.Always, Eval.Module.Later, Future, LazyDequeX, LazyListX, LazyPQueueX, LazyPStackX, LazyPVectorX, LazyQueueX, Maybe.Just, Maybe.Lazy, Maybe.Nothing, OptionalKind, StreamKind.Box

public interface Higher<T1,T2>
extends Convert<Higher<T1,T2>>

Higher Kinded Type - a core type (e.g. a List) and a data type of the elements within the List (e.g. Integers). A fluent semantic alias for org.derive4j.hkt.__ (awaiting https://github.com/derive4j/hkt/issues/13).

Method Summary

Modifier and Type	Method and Description
default <T3,R> Higher<T1,R>	apply_(java.util.function.BiFunction<? super T3,? super Higher<T1,T2>,? extends Higher<T1,R>> biFn, T3 param) Apply the provided BiFunction passing this as the second parameter This allows a fluent api without narrowing or unwrapping simulated Higher Kinded Types
default <T3,R> Higher<T1,R>	apply(T3 param, java.util.function.BiFunction<? super Higher<T1,T2>,? super T3,? extends Higher<T1,R>> biFn) Apply the provided BiFunction passing this as the first parameter This allows a fluent api without narrowing or unwrapping simulated Higher Kinded Types
default <R> Higher<T1,R>	transform(java.util.function.Function<? super Higher<T1,T2>,? extends Higher<T1,R>> fn)

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

convert

Method Detail

apply_

default <T3,R> Higher<T1,R> apply_(java.util.function.BiFunction<? super T3,? super Higher<T1,T2>,? extends Higher<T1,R>> biFn,
                                   T3 param)

Apply the provided BiFunction passing this as the second parameter This allows a fluent api without narrowing or unwrapping simulated Higher Kinded Types

 
  Functor<ListType.µ> f = TypeClasses.General
    .<ListType.µ,List<?>>functor(ListType::narrow,(list,fn)->ListX.fromIterable(list).map(fn));

    List<Integer> mapped2 = f.map(a->a+1, ListType.widen(Arrays.asList(1,2,3)))
    .then_(f::map,λ(this::mult3))
    .then_(f::map,λ(this::add2))
    .convert(ListType::narrow);

 
 

Parameters:

biFn - BiFunction to execute

param - 1st parameter to pass to BiFunction

Returns:

Result of executing the provided BiFunction

transform

default <R> Higher<T1,R> transform(java.util.function.Function<? super Higher<T1,T2>,? extends Higher<T1,R>> fn)

apply

default <T3,R> Higher<T1,R> apply(T3 param,
                                  java.util.function.BiFunction<? super Higher<T1,T2>,? super T3,? extends Higher<T1,R>> biFn)

Apply the provided BiFunction passing this as the first parameter This allows a fluent api without narrowing or unwrapping simulated Higher Kinded Types

Parameters:

biFn - BiFunction to execute

param - 2nd parameter to pass to BiFunction

Returns:

Result of executing the provided BiFunction