Ior.Primary (cyclops-react 2.0.0-MI6 API)

java.lang.Object
- cyclops.control.Ior.Primary<ST,PT>

All Implemented Interfaces:

Unit<PT>, Filters<PT>, Convertable<PT>, Folds<PT>, To<Ior<ST,PT>>, Visitable<PT>, BiTransformable<ST,PT>, Transformable<PT>, MonadicValue<PT>, Value<PT>, Zippable<PT>, Ior<ST,PT>, Fn0<PT>, java.lang.Iterable<PT>, java.util.function.Predicate<PT>, java.util.function.Supplier<PT>, org.jooq.lambda.function.Function0<PT>, org.reactivestreams.Publisher<PT>

Enclosing interface:

Ior<ST,PT>
```
public static class Ior.Primary<ST,PT>
extends java.lang.Object
implements Ior<ST,PT>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.control.Ior
  Ior.Both<ST,PT>, Ior.Primary<ST,PT>, Ior.Secondary<ST,PT>
- Nested classes/interfaces inherited from interface com.aol.cyclops2.types.Value
  Value.ValueImpl<T>
- Nested classes/interfaces inherited from interface com.aol.cyclops2.types.foldable.Convertable
  Convertable.SupplierToConvertable<T>
- Nested classes/interfaces inherited from interface cyclops.function.Fn0
  Fn0.FunctionalOperations<R>, Fn0.Instances, Fn0.SupplierKind<R>

Constructor Summary

Constructors
Constructor and Description

Primary()

Constructors
Constructor and Description
`Primary()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<R1,R2> Ior<R1,R2>`	`bimap(java.util.function.Function<? super ST,? extends R1> fn1, java.util.function.Function<? super PT,? extends R2> fn2)` Transform this BiTransformable, changing two value types at once.
`Ior<ST,PT>`	`bipeek(java.util.function.Consumer<? super ST> stAction, java.util.function.Consumer<? super PT> ptAction)` Peek at two data types simulatanously (typically toNested perform a side-effect with each data point)
`java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>>`	`both()`
`<T2,R> Ior<ST,R>`	`combine(Value<? extends T2> app, java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)` Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
`Ior<ST,PT>`	`filter(java.util.function.Predicate<? super PT> test)` Keep only elements for which the supplied predicates hold e.g.
`<RT1> Ior<ST,RT1>`	`flatMap(java.util.function.Function<? super PT,? extends MonadicValue<? extends RT1>> mapper)` A flattening transformation operation (@see `Optional.flatMap(Function)`
`PT`	`get()` Apply this function to the arguments.
`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
`java.lang.String`	`mkString()` Returns the class name and the name of the subclass, if there is any value, the value is showed between square brackets.
`Ior<ST,PT>`	`peek(java.util.function.Consumer<? super PT> action)` Peek at the current value of this Transformable, without transforming it
`<LT1> Ior<LT1,PT>`	`secondaryFlatMap(java.util.function.Function<? super ST,? extends Ior<LT1,PT>> mapper)` Perform a flatMap operation on the Secondary type
`ST`	`secondaryGet()`
`<R> Ior<R,PT>`	`secondaryMap(java.util.function.Function<? super ST,? extends R> fn)` Always map the Secondary type of this Ior if it is present using the provided transformation function
`Ior<ST,PT>`	`secondaryPeek(java.util.function.Consumer<? super ST> action)` Peek at the Secondary type value if present
`java.util.Optional<ST>`	`secondaryToOptional()`
`Ior<ST,PT>`	`secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Ior<ST,PT>> fn)` A flatMap operation that keeps the Secondary and Primary types the same
`Ior<ST,PT>`	`secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)` If this Ior contains the Secondary type only, map it's value so that it contains the Primary type only If this Ior contains both types, this method has no effect in the default implementations
`ReactiveSeq<ST>`	`secondaryToStream()`
`Value<ST>`	`secondaryValue()`
`Ior<PT,ST>`	`swap()`
`java.lang.String`	`toString()`
`Xor<ST,PT>`	`toXor()`
`Xor<ST,PT>`	`toXorDropPrimary()`
`<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)` Visitor pattern for this Ior.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface cyclops.control.Ior
accumulatePrimary, accumulatePrimary, accumulatePrimary, accumulateSecondary, accumulateSecondary, accumulateSecondary, anyM, applyAny, bicast, bitrampoline, both, both, bothValue, cast, coflatMap, combineEager, consumeAny, filterNot, flatMapI, flatMapP, flatMapS, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, fromIterable, fromPublisher, isPresent, nest, notNull, ofType, primary, retry, retry, secondary, sequencePrimary, sequenceSecondary, toIor, toXor, trampoline, unit, visitAny, visitAny, zip, zip, zip, zip3, zip3, zip4, zip4, zipP, zipP, zipS, zipS, zipWith, zipWithP, zipWithS

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

Methods inherited from interface com.aol.cyclops2.types.Value
apply, generate, iterate, iterator, newSubscriber, of, stream, subscribe, test, toEvalAlways, toEvalLater, toEvalNow, toMaybe, toTry, toTry, toTry

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, xMatch

Methods inherited from interface com.aol.cyclops2.types.foldable.Convertable
collect, fromSupplier, orElse, orElseGet, orElseThrow, toCompletableFuture, toCompletableFutureAsync, toFuture, toFutureAsync, toOptional, toStream, visit

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

Methods inherited from interface cyclops.function.Fn0
andThen, fnTo, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, memoizeAsync, memoizeAsync, run, suspend, λ, λv

Methods inherited from interface org.jooq.lambda.function.Function0
apply, from, toSupplier

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

- Constructor Detail
  - Primary
```
public Primary()
```
- Method Detail
  - toXor
```
public Xor<ST,PT> toXor()
```
    Specified by:
    
    toXor in interface Value<PT>
    
    Specified by:
    
    toXor in interface Ior<ST,PT>
    
    Returns:
    
    Primary Xor that has the same value as this Value
  - toXorDropPrimary
```
public Xor<ST,PT> toXorDropPrimary()
```
    Specified by:
    
    toXorDropPrimary in interface Ior<ST,PT>
    
    Returns:
    
    Convert to an Xor, dropping the primary type if this Ior contains both
  - secondaryToPrimayMap
```
public Ior<ST,PT> secondaryToPrimayMap(java.util.function.Function<? super ST,? extends PT> fn)
```
    Description copied from interface: Ior
    
    If this Ior contains the Secondary type only, map it's value so that it contains the Primary type only If this Ior contains both types, this method has no effect in the default implementations
    
    Specified by:
    
    secondaryToPrimayMap in interface Ior<ST,PT>
    
    Parameters:
    
    fn - Function to map secondary type to primary
    
    Returns:
    
    Ior with secondary type mapped to primary
  - secondaryMap
```
public <R> Ior<R,PT> secondaryMap(java.util.function.Function<? super ST,? extends R> fn)
```
    Description copied from interface: Ior
    
    Always map the Secondary type of this Ior if it is present using the provided transformation function
    
    Specified by:
    
    secondaryMap in interface Ior<ST,PT>
    
    Parameters:
    
    fn - Transformation function for Secondary types
    
    Returns:
    
    Ior with Secondary type transformed
  - map
```
public <R> Ior<ST,R> map(java.util.function.Function<? super PT,? 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<PT>
    
    Specified by:
    
    map in interface MonadicValue<PT>
    
    Specified by:
    
    map in interface Ior<ST,PT>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Transformable
  - secondaryPeek
```
public Ior<ST,PT> secondaryPeek(java.util.function.Consumer<? super ST> action)
```
    Description copied from interface: Ior
    
    Peek at the Secondary type value if present
    
    Specified by:
    
    secondaryPeek in interface Ior<ST,PT>
    
    Parameters:
    
    action - Consumer to peek at the Secondary type value
    
    Returns:
    
    Ior with the same values as before
  - visit
```
public <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)
```
    Description copied from interface: Ior
    Visitor pattern for this Ior. Execute the secondary function if this Ior contains an element of the secondary type only Execute the primary function if this Ior contains an element of the primary type only Execute the both function if this Ior contains an element of both type
```
 
  Ior.primary(10)
     .visit(secondary->"no", primary->"yes",(sec,pri)->"oops!")
  //Ior["yes"]

        Ior.secondary(90)
           .visit(secondary->"no", primary->"yes",(sec,pri)->"oops!")
        //Ior["no"]

        Ior.both(10, "eek")
           .visit(secondary->"no", primary->"yes",(sec,pri)->"oops!")
        //Ior["oops!"]


 
 
```
    Specified by:
    
    visit in interface Ior<ST,PT>
    
    Parameters:
    
    secondary - Function to execute if this is a Secondary Ior
    
    primary - Function to execute if this is a Primary Ior
    
    both - Function to execute if this Ior contains both types
    
    Returns:
    
    Result of executing the appropriate function
  - peek
```
public Ior<ST,PT> peek(java.util.function.Consumer<? super PT> action)
```
    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<PT>
    
    Specified by:
    
    peek in interface Ior<ST,PT>
    
    Parameters:
    
    action - Consumer that recieves each element from this Transformable
    
    Returns:
    
    Transformable that will peek at each value
  - filter
```
public Ior<ST,PT> filter(java.util.function.Predicate<? super PT> test)
```
    Description copied from interface: Filters
    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 Filters<PT>
    
    Specified by:
    
    filter in interface MonadicValue<PT>
    
    Specified by:
    
    filter in interface Ior<ST,PT>
    
    Parameters:
    
    test - toNested filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - bimap
```
public <R1,R2> Ior<R1,R2> bimap(java.util.function.Function<? super ST,? extends R1> fn1,
                                java.util.function.Function<? super PT,? extends R2> fn2)
```
    Description copied from interface: BiTransformable
    Transform this BiTransformable, changing two value types at once.
```
 
     MapX<String,Integer> map = MapXs.of("hello",2);
     MapX<String,Integer> transformedMap = map.bimap(s->s+" world",i->i*4);
     //["hello world",8]
 
 
```
    Specified by:
    
    bimap in interface BiTransformable<ST,PT>
    
    Specified by:
    
    bimap in interface Ior<ST,PT>
    
    Parameters:
    
    fn1 - transformation function for the first type
    
    fn2 - transformation function for the second type
    
    Returns:
    
    New BiTransformable containing transformed data
  - swap
```
public Ior<PT,ST> swap()
```
    Specified by:
    
    swap in interface Ior<ST,PT>
    
    Returns:
    
    Ior with Primary and Secondary types and value swapped
  - get
```
public PT get()
```
    Description copied from interface: org.jooq.lambda.function.Function0
    
    Apply this function to the arguments.
    
    Specified by:
    
    get in interface Convertable<PT>
    
    Specified by:
    
    get in interface Ior<ST,PT>
    
    Specified by:
    
    get in interface java.util.function.Supplier<PT>
    
    Specified by:
    
    get in interface org.jooq.lambda.function.Function0<PT>
    
    Returns:
    
    Contained value, maybe null
  - secondaryGet
```
public ST secondaryGet()
```
    Specified by:
    
    secondaryGet in interface Ior<ST,PT>
    
    Returns:
    
    The Secondary Value if present, otherwise null
  - secondaryToOptional
```
public java.util.Optional<ST> secondaryToOptional()
```
    Specified by:
    
    secondaryToOptional in interface Ior<ST,PT>
    
    Returns:
    
    The Secondary value wrapped in an Optional if present, otherwise an empty Optional
  - secondaryToStream
```
public ReactiveSeq<ST> secondaryToStream()
```
    Specified by:
    
    secondaryToStream in interface Ior<ST,PT>
    
    Returns:
    
    A Stream containing the secondary value if present, otherwise an empty Stream
  - flatMap
```
public <RT1> Ior<ST,RT1> flatMap(java.util.function.Function<? super PT,? extends MonadicValue<? extends RT1>> mapper)
```
    Description copied from interface: MonadicValue
    A flattening transformation operation (@see Optional.flatMap(Function)
```
  
   Eval.now(1).map(i->i+2).flatMap(i->Eval.later(()->i*3);
   //Eval[9]
 
 
```
    Specified by:
    
    flatMap in interface MonadicValue<PT>
    
    Specified by:
    
    flatMap in interface Ior<ST,PT>
    
    Parameters:
    
    mapper - transformation function
    
    Returns:
    
    MonadicValue
  - secondaryFlatMap
```
public <LT1> Ior<LT1,PT> secondaryFlatMap(java.util.function.Function<? super ST,? extends Ior<LT1,PT>> mapper)
```
    Description copied from interface: Ior
    
    Perform a flatMap operation on the Secondary type
    
    Specified by:
    
    secondaryFlatMap in interface Ior<ST,PT>
    
    Parameters:
    
    mapper - Flattening transformation function
    
    Returns:
    
    Ior containing the value inside the result of the transformation function as the Secondary value, if the Secondary type was present
  - secondaryToPrimayFlatMap
```
public Ior<ST,PT> secondaryToPrimayFlatMap(java.util.function.Function<? super ST,? extends Ior<ST,PT>> fn)
```
    Description copied from interface: Ior
    
    A flatMap operation that keeps the Secondary and Primary types the same
    
    Specified by:
    
    secondaryToPrimayFlatMap in interface Ior<ST,PT>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Ior
  - bipeek
```
public Ior<ST,PT> bipeek(java.util.function.Consumer<? super ST> stAction,
                         java.util.function.Consumer<? super PT> ptAction)
```
    Description copied from interface: BiTransformable
    Peek at two data types simulatanously (typically toNested perform a side-effect with each data point)
```
 
     MapX<String,Integer> map = MapXs.of("hello",2);
     map.bipeek(s->System.out.pritnln("key = " + s),System.out::println);
 
 
```
    Specified by:
    
    bipeek in interface BiTransformable<ST,PT>
    
    Specified by:
    
    bipeek in interface Ior<ST,PT>
    
    Parameters:
    
    stAction - consumer for the first type
    
    ptAction - consumer for the second type
    
    Returns:
    
    New BiTransformable with the same data
  - both
```
public java.util.Optional<org.jooq.lambda.tuple.Tuple2<ST,PT>> both()
```
    Specified by:
    
    both in interface Ior<ST,PT>
    
    Returns:
    
    An empty Optional if this Ior only has lazy the Secondary or Primary type. Or an Optional containing a Tuple2 with both the Secondary and Primary types if they are both present.
  - isPrimary
```
public boolean isPrimary()
```
    Specified by:
    
    isPrimary in interface Ior<ST,PT>
    
    Returns:
    
    True if this is a primary (only) Ior
  - isSecondary
```
public boolean isSecondary()
```
    Specified by:
    
    isSecondary in interface Ior<ST,PT>
    
    Returns:
    
    True if this was a secondary (only) Ior
  - isBoth
```
public boolean isBoth()
```
    Specified by:
    
    isBoth in interface Ior<ST,PT>
    
    Returns:
    
    True if this Ior has both secondary and primary types
  - secondaryValue
```
public Value<ST> secondaryValue()
```
    Specified by:
    
    secondaryValue in interface Ior<ST,PT>
    
    Returns:
    
    A Value containing the secondary Value if present
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - mkString
```
public java.lang.String mkString()
```
    Description copied from interface: Value
    
    Returns the class name and the name of the subclass, if there is any value, the value is showed between square brackets.
    
    Specified by:
    
    mkString in interface Value<PT>
    
    Returns:
    
    String
  - combine
```
public <T2,R> Ior<ST,R> combine(Value<? extends T2> app,
                                java.util.function.BiFunction<? super PT,? super T2,? extends R> fn)
```
    Description copied from interface: MonadicValue
    Lazily combine this ApplicativeFunctor with the supplied value via the supplied BiFunction Example
```
 
   Maybe<Integer> some = Maybe.just(10);
   just.combine(Eval.now(20), this::add);
   //Some[30]

   Maybe<Integer> none = Maybe.none();
   none.combine(Eval.now(20), this::add);
   //None

 
 
```
    Specified by:
    
    combine in interface MonadicValue<PT>
    
    Specified by:
    
    combine in interface Ior<ST,PT>
    
    Parameters:
    
    app - Value toNested combine with this one.
    
    fn - BiFunction toNested combine them
    
    Returns:
    
    New Applicativefunctor that represents the combined values

Class Ior.Primary<ST,PT>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.control.Ior

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

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

Nested classes/interfaces inherited from interface cyclops.function.Fn0

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.control.Ior

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

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

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

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface cyclops.function.Fn0

Methods inherited from interface org.jooq.lambda.function.Function0

Methods inherited from interface java.util.function.Predicate

Constructor Detail

Primary

Method Detail

toXor

toXorDropPrimary

secondaryToPrimayMap

secondaryMap

map

secondaryPeek

visit

peek

filter

bimap

swap

get

secondaryGet

secondaryToOptional

secondaryToStream

flatMap

secondaryFlatMap

secondaryToPrimayFlatMap

bipeek

both

isPrimary

isSecondary

isBoth

secondaryValue

toString

mkString

combine