Ior.Primary (cyclops-reactor 8.4.2 API)

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

All Implemented Interfaces:

Ior<ST,PT>, ApplicativeFunctor<PT>, BiFunctor<ST,PT>, Combiner<PT>, Convertable<PT>, ConvertableFunctor<PT>, Filterable<PT>, Foldable<PT>, Functor<PT>, MonadicValue<PT>, To<Ior<ST,PT>>, Unit<PT>, Value<PT>, Visitable<PT>, Zippable<PT>, java.lang.Iterable<PT>, java.util.function.Predicate<PT>, java.util.function.Supplier<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 com.aol.cyclops.control.Ior
  Ior.Both<ST,PT>, Ior.Primary<ST,PT>, Ior.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>

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 BiFunctor, 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 to 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()`
`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)` Pattern match on the value/s inside this Ior.
`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 Functor, 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 com.aol.cyclops.control.Ior
accumulatePrimary, accumulatePrimary, accumulatePrimary, accumulateSecondary, accumulateSecondary, accumulateSecondary, anyM, bicast, bitrampoline, both, both, bothValue, cast, coflatMap, combine, combineEager, filterNot, flatMapIterable, flatMapPublisher, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, fromIterable, fromPublisher, isPresent, nest, notNull, ofType, patternMatch, primary, secondary, sequencePrimary, sequenceSecondary, toIor, toXor, trampoline, unit, zip, zip, zip, zip, zip, zip, zip

Methods inherited from interface com.aol.cyclops.types.To
to

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, iterator, mapReduce, 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, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toFutureWAsync, toFutureWAsync, toOptional, toOptionalAtomicReference, toStream, visit

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

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

- Constructor Detail
  - Primary
```
public Primary()
```
- Method Detail
  - toXor
```
public Xor<ST,PT> toXor()
```
    Specified by:
    
    toXor in interface Ior<ST,PT>
    
    Specified by:
    
    toXor in interface Value<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: 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 Ior<ST,PT>
    
    Specified by:
    
    map in interface ConvertableFunctor<PT>
    
    Specified by:
    
    map in interface Functor<PT>
    
    Specified by:
    
    map in interface MonadicValue<PT>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Functor
  - 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: 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 Ior<ST,PT>
    
    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
  - filter
```
public 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 Ior<ST,PT>
    
    Specified by:
    
    filter in interface Filterable<PT>
    
    Specified by:
    
    filter in interface MonadicValue<PT>
    
    Parameters:
    
    test - to filter elements by, retaining matches
    
    Returns:
    
    Filterable 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: BiFunctor
    Transform this BiFunctor, 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 Ior<ST,PT>
    
    Specified by:
    
    bimap in interface BiFunctor<ST,PT>
    
    Parameters:
    
    fn1 - transformation function for the first type
    
    fn2 - transformation function for the second type
    
    Returns:
    
    New BiFunctor 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()
```
    Specified by:
    
    get in interface Ior<ST,PT>
    
    Specified by:
    
    get in interface Convertable<PT>
    
    Specified by:
    
    get in interface java.util.function.Supplier<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 Ior<ST,PT>
    
    Specified by:
    
    flatMap in interface MonadicValue<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: BiFunctor
    Peek at two data types simulatanously (typically to 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 Ior<ST,PT>
    
    Specified by:
    
    bipeek in interface BiFunctor<ST,PT>
    
    Parameters:
    
    stAction - consumer for the first type
    
    ptAction - consumer for the second type
    
    Returns:
    
    New BiFunctor 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 either 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: Combiner
    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 Ior<ST,PT>
    
    Specified by:
    
    combine in interface Combiner<PT>
    
    Parameters:
    
    app - Value to combine with this one.
    
    fn - BiFunction to combine them
    
    Returns:
    
    New Applicativefunctor that represents the combined values
  - matches
```
public <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)
```
    Description copied from interface: Ior
    Pattern match on the value/s inside this Ior.
```
  
 import static com.aol.cyclops.control.Matchable.otherwise;
       import static com.aol.cyclops.control.Matchable.then;
       import static com.aol.cyclops.control.Matchable.when;
       import static com.aol.cyclops.util.function.Predicates.instanceOf;

       Ior.primary(10)
          .matches(c->c.is(when("10"),then("hello")),
                   c->c.is(when(instanceOf(Integer.class)), then("error")),
                   c->c.is(when("10",10), then("boo!")),
                   otherwise("miss"));
                   
       //Eval["error"]
 
 
 
 
```
    Specified by:
    
    matches in interface Ior<ST,PT>
    
    Parameters:
    
    secondary - Pattern matching function executed if this Ior has the secondary type only
    
    primary - Pattern matching function executed if this Ior has the primary type only
    
    both - Pattern matching function executed if this Ior has both types
    
    otherwise - Supplier used to provide a value if the selecting pattern matching function fails to find a match
    
    Returns:
    
    Lazy result of the pattern matching

Class Ior.Primary<ST,PT>

Nested Class Summary

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

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.control.Ior

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

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.util.function.Predicate

Methods inherited from interface java.lang.Iterable

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

matches