Ior (simple-react 1.0.0-RC3 API)

Type Parameters:

ST - Secondary type

PT - Primary type

All Superinterfaces:

Applicativable<PT>, BiFunctor<ST,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>

All Known Implementing Classes:

Ior.Both, Ior.Primary, Ior.Secondary
```
public interface Ior<ST,PT>
extends java.util.function.Supplier<PT>, MonadicValue2<ST,PT>, BiFunctor<ST,PT>, Functor<PT>, Filterable<PT>, Applicativable<PT>
```
An Either or Union type, but right biased. Primary and Secondary are used instead of Right & Left. 'Right' (or primary type) biased disjunct union. No 'projections' are provided, swap() and secondaryXXXX alternative methods can be used instead.

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Ior.Both<ST,PT>

static class Ior.Primary<ST,PT>

static class Ior.Secondary<ST,PT>
- Nested classes/interfaces inherited from interface com.aol.cyclops.types.applicative.Applicativable
  Applicativable.Applicatives, Applicativable.SemigroupApplyer<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`	`Ior.Both<ST,PT>`
`static class`	`Ior.Primary<ST,PT>`
`static class`	`Ior.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> Ior<?,R>`	`accumulatePrimary(CollectionX<Ior<ST,PT>> iors, java.util.function.Function<? super PT,R> mapper, Semigroup<R> reducer)`
`static <ST,PT,R> Ior<?,R>`	`accumulatePrimary(CollectionX<Ior<ST,PT>> iors, Reducer<R> reducer)`
`static <ST,PT> Ior<?,PT>`	`accumulatePrimary(CollectionX<Ior<ST,PT>> iors, Semigroup<PT> reducer)`
`static <ST,PT,R> Ior<?,R>`	`accumulateSecondary(CollectionX<Ior<ST,PT>> iors, java.util.function.Function<? super ST,R> mapper, Semigroup<R> reducer)`
`static <ST,PT,R> Ior<?,R>`	`accumulateSecondary(CollectionX<Ior<ST,PT>> iors, Reducer<R> reducer)`
`static <ST,PT> Ior<?,ST>`	`accumulateSecondary(CollectionX<Ior<ST,PT>> iors, Semigroup<ST> reducer)`
`default AnyMValue<PT>`	`anyM()`
`default <U1,U2> Ior<U1,U2>`	`bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default <R1,R2> Ior<R1,R2>`	`bimap(java.util.function.Function<? super ST,? extends R1> fn1, java.util.function.Function<? super PT,? extends R2> fn2)`
`default Ior<ST,PT>`	`bipeek(java.util.function.Consumer<? super ST> c1, java.util.function.Consumer<? super PT> c2)`
`default <R1,R2> Ior<R1,R2>`	`bitrampoline(java.util.function.Function<? super ST,? extends Trampoline<? extends R1>> mapper1, java.util.function.Function<? super PT,? extends Trampoline<? extends R2>> mapper2)` Performs a map operation that can call a recursive method without running out of stack space
`java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>>`	`both()`
`static <ST,PT> Ior<ST,PT>`	`both(Ior<ST,PT> secondary, Ior<ST,PT> primary)`
`static <ST,PT> Ior<ST,PT>`	`both(ST secondary, PT primary)`
`default Value<java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>>>`	`bothValue()`
`default <U> Ior<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> Ior<ST,R>`	`coflatMap(java.util.function.Function<? super MonadicValue<PT>,R> mapper)`
`default Ior<ST,PT>`	`combine(Monoid<PT> monoid, MonadicValue2<? extends ST,? extends PT> v2)` Eagerly combine two MonadicValues using the supplied monoid
`Ior<ST,PT>`	`filter(java.util.function.Predicate<? super PT> test)` Keep only elements for which the supplied predicates hold e.g.
`default Ior<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> Ior<LT1,RT1>`	`flatMap(java.util.function.Function<? super PT,? extends MonadicValue2<? extends LT1,? extends RT1>> mapper)`
`PT`	`get()`
`boolean`	`isBoth()`
`boolean`	`isPrimary()`
`boolean`	`isSecondary()`
`<R> Ior<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>> secondary, java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> primary, java.util.function.Function<Matchable.CheckValue2<ST,PT,R>,Matchable.CheckValue2<ST,PT,R>> both, java.util.function.Supplier<? extends R> otherwise)`
`default Ior<ST,MonadicValue<PT>>`	`nest()`
`default Ior<ST,PT>`	`notNull()` Filter elements retaining only values which are not null
`default <U> Ior<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
`Ior<ST,PT>`	`peek(java.util.function.Consumer<? super PT> action)` Peek at the current value of this Functor, without transforming it
`static <ST,PT> Ior<ST,PT>`	`primary(PT primary)`
`static <ST,PT> Ior<ST,PT>`	`secondary(ST secondary)`
`<LT1,RT1> Ior<LT1,RT1>`	`secondaryFlatMap(java.util.function.Function<? super ST,? extends Ior<LT1,RT1>> mapper)`
`ST`	`secondaryGet()`
`<R> Ior<R,PT>`	`secondaryMap(java.util.function.Function<? super ST,? extends R> fn)`
`Ior<ST,PT>`	`secondaryPeek(java.util.function.Consumer<? super ST> action)`
`java.util.Optional<ST>`	`secondaryToOptional()`
`Ior<ST,PT>`	`secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Ior<ST,PT>> fn)`
`Ior<ST,PT>`	`secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)`
`ReactiveSeq<ST>`	`secondaryToStream()`
`Value<ST>`	`secondaryValue()`
`static <ST,PT> Ior<ListX<ST>,ListX<PT>>`	`sequencePrimary(CollectionX<Ior<ST,PT>> iors)`
`static <ST,PT> Ior<ListX<PT>,ListX<ST>>`	`sequenceSecondary(CollectionX<Ior<ST,PT>> iors)`
`Ior<PT,ST>`	`swap()`
`default Ior<ST,PT>`	`toIor()`
`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
`Xor<ST,PT>`	`toXorDropPrimary()`
`default <R> Ior<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> Ior<ST,T>`	`unit(T unit)`
`default <R> R`	`visit(java.util.function.Function<? super ST,? extends R> secondary, java.util.function.Function<? super PT,? extends R> primary, java.util.function.BiFunction<? super ST,? super PT,? extends R> both)`
`default <R1,R2> Ior<R1,R2>`	`visitIor(java.util.function.Function<? super ST,? extends R1> secondary, java.util.function.Function<? super PT,? extends R2> primary)`

Methods inherited from interface com.aol.cyclops.types.MonadicValue
isPresent

Methods inherited from interface com.aol.cyclops.types.applicative.Applicativable
ap, ap, ap1, ap2, ap3, ap4, ap5

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

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, headAndTail, 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, visit, visit, xMatch

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

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

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

Method Detail

primary

static <ST,PT> Ior<ST,PT> primary(PT primary)

secondary

static <ST,PT> Ior<ST,PT> secondary(ST secondary)

both

static <ST,PT> Ior<ST,PT> both(Ior<ST,PT> secondary,
                               Ior<ST,PT> primary)

both

static <ST,PT> Ior<ST,PT> both(ST secondary,
                               PT primary)

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

anyM in interface MonadicValue<PT>

unit
```
default <T> Ior<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>

filter
```
Ior<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

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

toXor in interface Value<PT>

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

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:

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

toIor in interface Value<PT>

secondaryToPrimayMap

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

secondaryMap

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

map
```
<R> Ior<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

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

peek
```
Ior<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
```
Ior<PT,ST> swap()
```

coflatMap

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

Specified by:: coflatMap in interface MonadicValue<PT>

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

nest in interface MonadicValue<PT>

combine

default Ior<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:

both

java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>> both()

bothValue

default Value<java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>>> bothValue()

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

bimap

default <R1,R2> Ior<R1,R2> bimap(java.util.function.Function<? super ST,? extends R1> fn1,
                                 java.util.function.Function<? super PT,? extends R2> fn2)

Specified by:: bimap in interface BiFunctor<ST,PT>

visit

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

visitIor

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

matches

<R> Eval<R> matches(java.util.function.Function<Matchable.CheckValue1<ST,R>,Matchable.CheckValue1<ST,R>> secondary,
                    java.util.function.Function<Matchable.CheckValue1<PT,R>,Matchable.CheckValue1<PT,R>> primary,
                    java.util.function.Function<Matchable.CheckValue2<ST,PT,R>,Matchable.CheckValue2<ST,PT,R>> both,
                    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> Ior<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> Ior<LT1,RT1> secondaryFlatMap(java.util.function.Function<? super ST,? extends Ior<LT1,RT1>> mapper)

secondaryToPrimayFlatMap

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

isPrimary
```
boolean isPrimary()
```

isSecondary
```
boolean isSecondary()
```

isBoth
```
boolean isBoth()
```

sequenceSecondary

static <ST,PT> Ior<ListX<PT>,ListX<ST>> sequenceSecondary(CollectionX<Ior<ST,PT>> iors)

accumulateSecondary

static <ST,PT,R> Ior<?,R> accumulateSecondary(CollectionX<Ior<ST,PT>> iors,
                                              Reducer<R> reducer)

accumulateSecondary

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

accumulateSecondary

static <ST,PT> Ior<?,ST> accumulateSecondary(CollectionX<Ior<ST,PT>> iors,
                                             Semigroup<ST> reducer)

sequencePrimary

static <ST,PT> Ior<ListX<ST>,ListX<PT>> sequencePrimary(CollectionX<Ior<ST,PT>> iors)

accumulatePrimary

static <ST,PT,R> Ior<?,R> accumulatePrimary(CollectionX<Ior<ST,PT>> iors,
                                            Reducer<R> reducer)

accumulatePrimary

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

accumulatePrimary

static <ST,PT> Ior<?,PT> accumulatePrimary(CollectionX<Ior<ST,PT>> iors,
                                           Semigroup<PT> reducer)

ofType
```
default <U> Ior<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 Ior<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 Ior<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> Ior<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> Ior<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:

bipeek

default Ior<ST,PT> bipeek(java.util.function.Consumer<? super ST> c1,
                          java.util.function.Consumer<? super PT> c2)

Specified by:: bipeek in interface BiFunctor<ST,PT>

bicast
```
default <U1,U2> Ior<U1,U2> bicast(java.lang.Class<U1> type1,
                                  java.lang.Class<U2> type2)
```
Description copied from interface: BiFunctor

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:

bicast in interface BiFunctor<ST,PT>

bitrampoline

default <R1,R2> Ior<R1,R2> bitrampoline(java.util.function.Function<? super ST,? extends Trampoline<? extends R1>> mapper1,
                                        java.util.function.Function<? super PT,? extends Trampoline<? extends R2>> mapper2)

Description copied from interface: BiFunctor

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:: bitrampoline in interface BiFunctor<ST,PT>
Returns:

Interface Ior<ST,PT>

Nested Class Summary

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

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.MonadicValue

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

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

primary

secondary

both

both

anyM

unit

filter

toXor

toXorDropPrimary

toXor

toIor

secondaryToPrimayMap

secondaryMap

map

secondaryPeek

peek

swap

coflatMap

nest

combine

both

bothValue

patternMatch

bimap

visit

visitIor

matches

get

secondaryValue

secondaryGet

secondaryToOptional

secondaryToStream

flatMap

secondaryFlatMap

secondaryToPrimayFlatMap

isPrimary

isSecondary

isBoth

sequenceSecondary

accumulateSecondary

accumulateSecondary

accumulateSecondary

sequencePrimary

accumulatePrimary

accumulatePrimary

accumulatePrimary

ofType

filterNot

notNull

cast

trampoline

bipeek

bicast

bitrampoline