Xor (simple-react 1.0.0-RC4 API)

Type Parameters:: ST - Secondary type; PT - Primary type

All Superinterfaces:: ApplicativeFunctor<PT>, Convertable<PT>, ConvertableFunctor<PT>, Filterable<PT>, Foldable<PT>, Functor<PT>, java.lang.Iterable<PT>, MonadicValue<PT>, MonadicValue2<ST,PT>, java.util.function.Predicate<PT>, org.reactivestreams.Publisher<PT>, java.util.function.Supplier<PT>, Unit<PT>, Value<PT>, Visitable<PT>

All Known Implementing Classes:: Xor.Primary, Xor.Secondary

public interface Xor<ST,PT>
extends java.util.function.Supplier<PT>, MonadicValue2<ST,PT>, Functor<PT>, Filterable<PT>, ApplicativeFunctor<PT>

eXclusive Or (Xor) 'Right' (or primary type) biased disjunct union. No 'projections' are provided, swap() and secondaryXXXX alternative methods can be used instead.

   
      Xor.primary("hello").map(v->v+" world") 
      //Xor.primary["hello world"]

Values can be accumulated via

   
  Xor.accumulateSecondary(ListX.of(Xor.secondary("failed1"),
                                                    Xor.secondary("failed2"),
                                                    Xor.primary("success")),
                                                    Semigroups.stringConcat)
  
  //failed1failed2
  
   Xor<String,String> fail1 = Xor.secondary("failed1");
     fail1.swap().ap((a,b)->a+b)
                 .ap(Xor.secondary("failed2").swap())
                 .ap(Xor.<String,String>primary("success").swap())
  
  //failed1failed2

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Xor.Primary<ST,PT>

static class Xor.Secondary<ST,PT>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
  ApplicativeFunctor.Applicatives, ApplicativeFunctor.ApplyFunctions<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value
  Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable
  Convertable.SupplierToConvertable<T>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Xor.Primary<ST,PT>`
`static class`	`Xor.Secondary<ST,PT>`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static <ST,PT,R> Xor<?,R>`	`accumulatePrimary(CollectionX<Xor<ST,PT>> xors, java.util.function.Function<? super PT,R> mapper, Semigroup<R> reducer)`
`static <ST,PT,R> Xor<?,R>`	`accumulatePrimary(CollectionX<Xor<ST,PT>> xors, Reducer<R> reducer)`
`static <ST,PT> Xor<?,PT>`	`accumulatePrimary(CollectionX<Xor<ST,PT>> xors, Semigroup<PT> reducer)`
`static <ST,PT,R> Xor<?,R>`	`accumulateSecondary(CollectionX<Xor<ST,PT>> xors, java.util.function.Function<? super ST,R> mapper, Semigroup<R> reducer)`
`static <ST,PT,R> Xor<?,R>`	`accumulateSecondary(CollectionX<Xor<ST,PT>> xors, Reducer<R> reducer)`
`static <ST,PT> Xor<?,ST>`	`accumulateSecondary(CollectionX<Xor<ST,PT>> xors, Semigroup<ST> reducer)` `Xor.accumulateSecondary(ListX.of(Xor.secondary("failed1"), Xor.secondary("failed2"), Xor.primary("success")), Semigroups.stringConcat) //Xors.Primary[failed1failed2]`
`default AnyMValue<PT>`	`anyM()`
`<T2,R> Xor<ST,R>`	`ap(Value<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)`
`default <T2,R> Xor<ST,R>`	`ap(Xor<? extends ST,? extends T2> app, java.util.function.BinaryOperator<ST> semigroup, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Accumulate secondary values with the provided BinaryOperator / Semigroup `Semigroups` Primary accumulation only occurs if all phases are primary
`default <T2,R> Xor<PStackX<ST>,R>`	`apToList(Xor<ST,? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Accumulate secondarys into a PStackX (extended Persistent List) and Primary with the supplied combiner function Primary accumulation only occurs if all phases are primary
`default <U> Xor<ST,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default <R> Xor<ST,R>`	`coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)`
`default Xor<ST,PT>`	`combine(Monoid<PT> monoid, MonadicValue2<? extends ST,? extends PT> v2)` Eagerly combine two MonadicValues using the supplied monoid
`Xor<ST,PT>`	`filter(java.util.function.Predicate<? super PT> test)` Keep only elements for which the supplied predicates hold e.g.
`default Xor<ST,PT>`	`filterNot(java.util.function.Predicate<? super PT> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<LT1,RT1> Xor<LT1,RT1>`	`flatMap(java.util.function.Function<? super PT,? extends MonadicValue2<? extends LT1,? extends RT1>> mapper)`
`static <ST,T> Xor<ST,T>`	`fromIterable(java.lang.Iterable<T> iterable)`
`static <T> Xor<java.lang.Throwable,T>`	`fromPublisher(org.reactivestreams.Publisher<T> pub)`
`PT`	`get()`
`default boolean`	`isPresent()`
`boolean`	`isPrimary()`
`boolean`	`isSecondary()`
`default Xor<PStackX<ST>,PT>`	`list()`
`<R> Xor<ST,R>`	`map(java.util.function.Function<? super PT,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> Eval<R>`	`matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> fn1, java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> fn2, java.util.function.Supplier<? extends R> otherwise)`
`default Xor<ST,MonadicValue<PT>>`	`nest()`
`default Xor<ST,PT>`	`notNull()` Filter elements retaining only values which are not null
`default <U> Xor<ST,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default <R> Xor<ST,R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`Xor<ST,PT>`	`peek(java.util.function.Consumer<? super PT> action)` Peek at the current value of this Functor, without transforming it
`void`	`peek(java.util.function.Consumer<? super ST> stAction, java.util.function.Consumer<? super PT> ptAction)`
`static <ST,PT> Xor<ST,PT>`	`primary(PT value)`
`static <ST,PT> Xor<ST,PT>`	`secondary(ST value)` Create an instance of the secondary type.
`<LT1,RT1> Xor<LT1,RT1>`	`secondaryFlatMap(java.util.function.Function<? super ST,? extends Xor<LT1,RT1>> mapper)`
`ST`	`secondaryGet()`
`<R> Xor<R,PT>`	`secondaryMap(java.util.function.Function<? super ST,? extends R> fn)`
`Xor<ST,PT>`	`secondaryPeek(java.util.function.Consumer<? super ST> action)`
`java.util.Optional<ST>`	`secondaryToOptional()`
`Xor<ST,PT>`	`secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Xor<ST,PT>> fn)`
`Xor<ST,PT>`	`secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)`
`ReactiveSeq<ST>`	`secondaryToStream()`
`Value<ST>`	`secondaryValue()`
`static <ST,PT> Xor<ListX<ST>,ListX<PT>>`	`sequencePrimary(CollectionX<Xor<ST,PT>> xors)`
`static <ST,PT> Xor<ListX<PT>,ListX<ST>>`	`sequenceSecondary(CollectionX<Xor<ST,PT>> xors)`
`Xor<PT,ST>`	`swap()`
`Ior<ST,PT>`	`toIor()`
`default java.util.Optional<PT>`	`toOptional()`
`default Xor<ST,PT>`	`toXor()`
`default <ST2> Xor<ST2,PT>`	`toXor(ST2 secondary)` Convert to an Xor where the secondary value will be used if no primary value is present
`default <R> Xor<ST,R>`	`trampoline(java.util.function.Function<? super PT,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`default <T> Xor<ST,T>`	`unit(T unit)`
`<R> R`	`visit(java.util.function.Function<? super ST,? extends R> secondary, java.util.function.Function<? super PT,? extends R> primary)`
`default <R1,R2> Xor<R1,R2>`	`visitXor(java.util.function.Function<? super ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary)`
`default <T2,R> Xor<ST,R>`	`zip(java.util.function.BiFunction<? super PT,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app)`
`default <T2,R> Xor<ST,R>`	`zip(java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)`

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor
applyFunctions

Methods inherited from interface com.aol.cyclops.types.Value
collect, fold, fold, generate, iterate, mapReduce, mkString, newSubscriber, of, stream, subscribe, test, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFeatureToggle, toFutureStream, toFutureStream, toLazyImmutable, toList, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, toTry, unapply

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch

Methods inherited from interface com.aol.cyclops.types.Convertable
collect, fromSupplier, iterator, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, toOptionalAtomicReference, toStream, visit

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface java.util.function.Predicate
and, isEqual, negate, or

Method Detail

fromPublisher

static <T> Xor<java.lang.Throwable,T> fromPublisher(org.reactivestreams.Publisher<T> pub)

fromIterable

static <ST,T> Xor<ST,T> fromIterable(java.lang.Iterable<T> iterable)

secondary
```
static <ST,PT> Xor<ST,PT> secondary(ST value)
```
Create an instance of the secondary type. Most methods are biased to the primary type, so you will need to use swap() or secondaryXXXX to manipulate the wrapped value
```
  
   Xor.<Integer,Integer>secondary(10).map(i->i+1);
   //Xor.secondary[10]
    
    Xor.<Integer,Integer>secondary(10).swap().map(i->i+1);
    //Xor.primary[11]
 
 
```
Parameters:

value - to wrap

Returns:

Secondary instance of Xor

primary

static <ST,PT> Xor<ST,PT> primary(PT value)

anyM
```
default AnyMValue<PT> anyM()
```
Specified by:

anyM in interface MonadicValue<PT>

coflatMap

default <R> Xor<ST,R> coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)

Specified by:: coflatMap in interface MonadicValue<PT>

nest
```
default Xor<ST,MonadicValue<PT>> nest()
```
Specified by:

nest in interface MonadicValue<PT>

combine

default Xor<ST,PT> combine(Monoid<PT> monoid,
                           MonadicValue2<? extends ST,? extends PT> v2)

Description copied from interface: MonadicValue2

Eagerly combine two MonadicValues using the supplied monoid

  
 
  Monoid<Integer> add = Mondoid.of(1,Semigroups.intSum);
  Maybe.of(10).plus(add,Maybe.none());
  //Maybe[10]
  
  Maybe.none().plus(add,Maybe.of(10));
  //Maybe[10]
  
  Maybe.none().plus(add,Maybe.none());
  //Maybe.none()
  
  Maybe.of(10).plus(add,Maybe.of(10));
  //Maybe[20]
  
  Monoid<Integer> firstNonNull = Monoid.of(null , Semigroups.firstNonNull());
  Maybe.of(10).plus(firstNonNull,Maybe.of(10));
  //Maybe[10]

Specified by:: combine in interface MonadicValue2<ST,PT>
Returns:

unit
```
default <T> Xor<ST,T> unit(T unit)
```
Specified by:

unit in interface MonadicValue<PT>

Specified by:

unit in interface MonadicValue2<ST,PT>

Specified by:

unit in interface Unit<PT>

toOptional
```
default java.util.Optional<PT> toOptional()
```
Specified by:

toOptional in interface Convertable<PT>

Returns:

Optional that wraps contained value, Optional.empty if value is null

filter
```
Xor<ST,PT> filter(java.util.function.Predicate<? super PT> test)
```
Description copied from interface: Filterable
Keep only elements for which the supplied predicates hold e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 
```
Specified by:

filter in interface Filterable<PT>

Parameters:

test - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

secondaryToPrimayMap

Xor<ST,PT> secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)

secondaryMap

<R> Xor<R,PT> secondaryMap(java.util.function.Function<? super ST,? extends R> fn)

map
```
<R> Xor<ST,R> map(java.util.function.Function<? super PT,? extends R> fn)
```
Description copied from interface: Functor
Transform this functor using the supplied transformation function
```
  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 
```
Specified by:

map in interface ConvertableFunctor<PT>

Specified by:

map in interface Functor<PT>

Specified by:

map in interface MonadicValue<PT>

Specified by:

map in interface MonadicValue2<ST,PT>

Parameters:

fn - Transformation function

Returns:

Transformed Functor

secondaryPeek

Xor<ST,PT> secondaryPeek(java.util.function.Consumer<? super ST> action)

peek
```
Xor<ST,PT> peek(java.util.function.Consumer<? super PT> action)
```
Description copied from interface: Functor
Peek at the current value of this Functor, without transforming it
```
  
  
  
    of(1,2,3).map(System.out::println)
    
    1
    2
    3
  
 
 
```
Specified by:

peek in interface Functor<PT>

Parameters:

action - Consumer that recieves each element from this Functor

Returns:

Functor that will peek at each value

swap
```
Xor<PT,ST> swap()
```

toIor
```
Ior<ST,PT> toIor()
```
Specified by:

toIor in interface Value<PT>

isPresent
```
default boolean isPresent()
```
Specified by:

isPresent in interface Convertable<PT>

toXor
```
default Xor<ST,PT> toXor()
```
Specified by:

toXor in interface Value<PT>

toXor
```
default <ST2> Xor<ST2,PT> toXor(ST2 secondary)
```
Description copied from interface: Value

Convert to an Xor where the secondary value will be used if no primary value is present

Specified by:

toXor in interface Value<PT>

Parameters:

secondary - Value to use in case no primary value is present

Returns:

sequenceSecondary

static <ST,PT> Xor<ListX<PT>,ListX<ST>> sequenceSecondary(CollectionX<Xor<ST,PT>> xors)

accumulateSecondary

static <ST,PT,R> Xor<?,R> accumulateSecondary(CollectionX<Xor<ST,PT>> xors,
                                              Reducer<R> reducer)

accumulateSecondary

static <ST,PT,R> Xor<?,R> accumulateSecondary(CollectionX<Xor<ST,PT>> xors,
                                              java.util.function.Function<? super ST,R> mapper,
                                              Semigroup<R> reducer)

sequencePrimary

static <ST,PT> Xor<ListX<ST>,ListX<PT>> sequencePrimary(CollectionX<Xor<ST,PT>> xors)

accumulatePrimary

static <ST,PT,R> Xor<?,R> accumulatePrimary(CollectionX<Xor<ST,PT>> xors,
                                            Reducer<R> reducer)

accumulatePrimary

static <ST,PT,R> Xor<?,R> accumulatePrimary(CollectionX<Xor<ST,PT>> xors,
                                            java.util.function.Function<? super PT,R> mapper,
                                            Semigroup<R> reducer)

accumulatePrimary

static <ST,PT> Xor<?,PT> accumulatePrimary(CollectionX<Xor<ST,PT>> xors,
                                           Semigroup<PT> reducer)

accumulateSecondary

static <ST,PT> Xor<?,ST> accumulateSecondary(CollectionX<Xor<ST,PT>> xors,
                                             Semigroup<ST> reducer)

  
 Xor.accumulateSecondary(ListX.of(Xor.secondary("failed1"),
													Xor.secondary("failed2"),
													Xor.primary("success")),
													Semigroups.stringConcat)
													
													
 //Xors.Primary[failed1failed2]

Parameters:: xors -; reducer -
Returns:

visit

<R> R visit(java.util.function.Function<? super ST,? extends R> secondary,
            java.util.function.Function<? super PT,? extends R> primary)

visitXor

default <R1,R2> Xor<R1,R2> visitXor(java.util.function.Function<? super ST,? extends R1> secondary,
                                    java.util.function.Function<? super PT,? extends R2> primary)

patternMatch

default <R> Xor<ST,R> patternMatch(java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> case1,
                                   java.util.function.Supplier<? extends R> otherwise)

Description copied from interface: Functor

Transform the elements of this Stream with a Pattern Matching case and default value

 
 List<String> result = CollectionX.of(1,2,3,4)
                                              .patternMatch(
                                                        c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
                                                      )
 
 // CollectionX["odd","even","odd","even"]

Specified by:: patternMatch in interface Functor<PT>
Parameters:: case1 - Function to generate a case (or chain of cases as a single case); otherwise - Value if supplied case doesn't match
Returns:: CollectionX where elements are transformed by pattern matching

matches

<R> Eval<R> matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> fn1,
                    java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> fn2,
                    java.util.function.Supplier<? extends R> otherwise)

get
```
PT get()
```
Specified by:

get in interface Convertable<PT>

Specified by:

get in interface java.util.function.Supplier<PT>

Returns:

Contained value, maybe null

secondaryValue
```
Value<ST> secondaryValue()
```

secondaryGet
```
ST secondaryGet()
```

secondaryToOptional

java.util.Optional<ST> secondaryToOptional()

secondaryToStream
```
ReactiveSeq<ST> secondaryToStream()
```

flatMap

<LT1,RT1> Xor<LT1,RT1> flatMap(java.util.function.Function<? super PT,? extends MonadicValue2<? extends LT1,? extends RT1>> mapper)

Specified by:: flatMap in interface MonadicValue2<ST,PT>

secondaryFlatMap

<LT1,RT1> Xor<LT1,RT1> secondaryFlatMap(java.util.function.Function<? super ST,? extends Xor<LT1,RT1>> mapper)

secondaryToPrimayFlatMap

Xor<ST,PT> secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Xor<ST,PT>> fn)

peek

void peek(java.util.function.Consumer<? super ST> stAction,
          java.util.function.Consumer<? super PT> ptAction)

isPrimary
```
boolean isPrimary()
```

isSecondary
```
boolean isSecondary()
```

ap

<T2,R> Xor<ST,R> ap(Value<? extends T2> app,
                    java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)

Specified by:: ap in interface ApplicativeFunctor<PT>

list
```
default Xor<PStackX<ST>,PT> list()
```
Returns:

An Xor with the secondary type converted to a persistent list, for use with accumulating app function Xor#ap(Xor,BiFunction)

apToList
```
default <T2,R> Xor<PStackX<ST>,R> apToList(Xor<ST,? extends T2> app,
                                           java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
```
Accumulate secondarys into a PStackX (extended Persistent List) and Primary with the supplied combiner function Primary accumulation only occurs if all phases are primary

Parameters:

app - Value to combine with

fn - Combiner function for primary values

Returns:

Combined Xor

ap

default <T2,R> Xor<ST,R> ap(Xor<? extends ST,? extends T2> app,
                            java.util.function.BinaryOperator<ST> semigroup,
                            java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)

Accumulate secondary values with the provided BinaryOperator / Semigroup Semigroups Primary accumulation only occurs if all phases are primary

  
  Xor<String,String> fail1 =  Xor.secondary("failed1");
        Xor<PStackX<String>,String> result = fail1.list().ap(Xor.secondary("failed2").list(), Semigroups.collectionConcat(),(a,b)->a+b);
        
        //Secondary of [PStackX.of("failed1","failed2")))]

Parameters:: app - Value to combine with; semigroup - to combine secondary types; fn - To combine primary types
Returns:: Combined Xor

zip

default <T2,R> Xor<ST,R> zip(java.lang.Iterable<? extends T2> app,
                             java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)

Specified by:: zip in interface ApplicativeFunctor<PT>

zip

default <T2,R> Xor<ST,R> zip(java.util.function.BiFunction<? super PT,? super T2,? extends R> fn,
                             org.reactivestreams.Publisher<? extends T2> app)

Specified by:: zip in interface ApplicativeFunctor<PT>

ofType
```
default <U> Xor<ST,U> ofType(java.lang.Class<? extends U> type)
```
Description copied from interface: Filterable
Keep only those elements in a stream that are of a given type.
```
  
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 
```
Specified by:

ofType in interface Filterable<PT>

filterNot
```
default Xor<ST,PT> filterNot(java.util.function.Predicate<? super PT> fn)
```
Description copied from interface: Filterable
Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
Specified by:

filterNot in interface Filterable<PT>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

notNull
```
default Xor<ST,PT> notNull()
```
Description copied from interface: Filterable
Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
```
Specified by:

notNull in interface Filterable<PT>

Returns:

Filterable with nulls removed

cast
```
default <U> Xor<ST,U> cast(java.lang.Class<? extends U> type)
```
Description copied from interface: Functor

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

Specified by:

cast in interface Functor<PT>

trampoline

default <R> Xor<ST,R> trampoline(java.util.function.Function<? super PT,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Functor

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 Functor<PT>
Returns:

Interface Xor<ST,PT>

Nested Class Summary

Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

Nested classes/interfaces inherited from interface com.aol.cyclops.types.Value

Nested classes/interfaces inherited from interface com.aol.cyclops.types.Convertable

Method Summary

Methods inherited from interface com.aol.cyclops.types.applicative.ApplicativeFunctor

Methods inherited from interface com.aol.cyclops.types.Value

Methods inherited from interface com.aol.cyclops.types.Foldable

Methods inherited from interface com.aol.cyclops.types.Convertable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.function.Predicate

Method Detail

fromPublisher

fromIterable

secondary

primary

anyM

coflatMap

nest

combine

unit

toOptional

filter

secondaryToPrimayMap

secondaryMap

map

secondaryPeek

peek

swap

toIor

isPresent

toXor

toXor

sequenceSecondary

accumulateSecondary

accumulateSecondary

sequencePrimary

accumulatePrimary

accumulatePrimary

accumulatePrimary

accumulateSecondary

visit

visitXor

patternMatch

matches

get

secondaryValue

secondaryGet

secondaryToOptional

secondaryToStream

flatMap

secondaryFlatMap

secondaryToPrimayFlatMap

peek

isPrimary

isSecondary

ap

list

apToList

ap

zip

zip

ofType

filterNot

notNull

cast

trampoline