LazyEither.Left (cyclops 10.3.3 API)

java.lang.Object
- cyclops.control.LazyEither.Left<ST,PT>

All Implemented Interfaces:

Convert<Higher<Higher<DataWitness.either,ST>,PT>>, Higher<Higher<DataWitness.either,ST>,PT>, Higher2<DataWitness.either,ST,PT>, Sealed2<ST,PT>, SealedOr<PT>, Unit<PT>, Filters<PT>, To<Either<ST,PT>>, BiTransformable<ST,PT>, Transformable<PT>, OrElseValue<PT,Either<ST,PT>>, Value<PT>, Either<ST,PT>, LazyEither<ST,PT>, io.kindedj.Hk<Higher<DataWitness.either,ST>,PT>, java.io.Serializable, java.lang.Iterable<PT>, org.reactivestreams.Publisher<PT>

Enclosing interface:

LazyEither<LT,RT>
```
public static class LazyEither.Left<ST,PT>
extends java.lang.Object
implements LazyEither<ST,PT>
```
See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.control.LazyEither
  LazyEither.CompletableEither<ORG,RT>, LazyEither.Lazy<ST,PT>, LazyEither.Left<ST,PT>, LazyEither.Right<ST,PT>

Constructor Summary

Constructors
Constructor and Description

Left()

Constructors
Constructor and Description
`Left()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`equals(java.lang.Object obj)`
`Maybe<PT>`	`filter(java.util.function.Predicate<? super PT> test)` Keep only elements for which the supplied predicates hold e.g.
`<RT1> LazyEither<ST,RT1>`	`flatMap(java.util.function.Function<? super PT,? extends Either<? extends ST,? extends RT1>> mapper)`
`<LT1> LazyEither<LT1,PT>`	`flatMapLeft(java.util.function.Function<? super ST,? extends Either<LT1,PT>> mapper)` Perform a flatMap operation on the Left type
`LazyEither<ST,PT>`	`flatMapLeftToRight(java.util.function.Function<? super ST,? extends Either<ST,PT>> fn)` A flatMap operation that keeps the Left and Right types the same
`<R> R`	`fold(java.util.function.Function<? super PT,? extends R> present, java.util.function.Supplier<? extends R> absent)`
`<R> R`	`fold(java.util.function.Function<? super ST,? extends R> secondary, java.util.function.Function<? super PT,? extends R> primary)` Visitor pattern for this Ior.
`Option<PT>`	`get()`
`Option<ST>`	`getLeft()`
`int`	`hashCode()`
`boolean`	`isLeft()`
`boolean`	`isRight()`
`ST`	`leftOrElse(ST alt)`
`ReactiveSeq<ST>`	`leftToStream()`
`<R> LazyEither<ST,R>`	`map(java.util.function.Function<? super PT,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> LazyEither<R,PT>`	`mapLeft(java.util.function.Function<? super ST,? extends R> fn)` Always transform the Left type of this Either if it is present using the provided transformation function
`LazyEither<ST,PT>`	`mapLeftToRight(java.util.function.Function<? super ST,? extends PT> fn)` If this Either contains the Left type, transform it's value so that it contains the Right type
`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.
`LazyEither<ST,PT>`	`peek(java.util.function.Consumer<? super PT> action)` Peek at the current value of this Transformable, without transforming it
`LazyEither<ST,PT>`	`peekLeft(java.util.function.Consumer<? super ST> action)` Peek at the Left type value if present
`Either<ST,PT>`	`recover(PT value)`
`Either<ST,PT>`	`recover(java.util.function.Supplier<? extends PT> value)`
`Either<ST,PT>`	`recoverWith(java.util.function.Supplier<? extends Either<ST,PT>> fn)`
`LazyEither<PT,ST>`	`swap()` Swap types so operations directly affect the current (pre-swap) Left type
`Ior<ST,PT>`	`toIor()`
`Maybe<PT>`	`toMaybe()`
`java.util.Optional<PT>`	`toOptional()`
`java.lang.String`	`toString()`

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

Methods inherited from interface cyclops.control.LazyEither
accumulate, always, applyAny, arity, async, bimap, bipeek, combine, combine, combineToLazySeq, combineToList, consumeAny, either, filter, foldAny, forEach2, forEach3, forEach4, fromEither, fromFuture, fromIterable, fromLazy, fromPublisher, isPresent, later, lazySeq, left, leftEval, narrow, narrowK, narrowK2, nest, right, rightEval, sequence, sequenceLeft, sequenceRight, tailRec, toEither, toEither, toEitherTrampoline, toTrampoline, toTrampoline, toTrampoline, traverse, traverseLeft, traverseRight, unit, visitAny, visitAny, zip, zip

Methods inherited from interface cyclops.control.Either
accumulateLeft, accumulateLeft, accumulateLeft, accumulateRight, accumulateRight, accumulateRight, applyAny, combineToVector, consumeAny, filterNot, foldAny, fromIterable, nestedEval, notNull, ofType, sequence, sequenceLeft, sequenceRight, tailRec, traverse, visitAny, visitAny, widen

Methods inherited from interface com.oath.cyclops.types.foldable.To
to

Methods inherited from interface com.oath.cyclops.types.OrElseValue
orElseUse, orElseUse

Methods inherited from interface com.oath.cyclops.types.Value
asSupplier, collect, fold, forEach, generate, iterate, iterator, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, stream, subscribe, toLazyEither, toLeft, toOption, toRight, toTry, toTry, toTry

Methods inherited from interface java.lang.Iterable
spliterator

Methods inherited from interface com.oath.cyclops.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.oath.cyclops.hkt.Convert
convert

- Constructor Detail
  - Left
```
public Left()
```
- Method Detail
  - recover
```
public Either<ST,PT> recover(java.util.function.Supplier<? extends PT> value)
```
    Specified by:
    
    recover in interface Either<ST,PT>
  - recover
```
public Either<ST,PT> recover(PT value)
```
    Specified by:
    
    recover in interface Either<ST,PT>
  - recoverWith
```
public Either<ST,PT> recoverWith(java.util.function.Supplier<? extends Either<ST,PT>> fn)
```
    Specified by:
    
    recoverWith in interface Either<ST,PT>
  - isLeft
```
public boolean isLeft()
```
    Specified by:
    
    isLeft in interface Either<ST,PT>
    
    Specified by:
    
    isLeft in interface LazyEither<ST,PT>
    
    Returns:
    
    True if this is a left Either
  - isRight
```
public boolean isRight()
```
    Specified by:
    
    isRight in interface Either<ST,PT>
    
    Specified by:
    
    isRight in interface LazyEither<ST,PT>
    
    Returns:
    
    True if this is a right Either
  - mapLeftToRight
```
public LazyEither<ST,PT> mapLeftToRight(java.util.function.Function<? super ST,? extends PT> fn)
```
    Description copied from interface: LazyEither
    
    If this Either contains the Left type, transform it's value so that it contains the Right type
    
    Specified by:
    
    mapLeftToRight in interface Either<ST,PT>
    
    Specified by:
    
    mapLeftToRight in interface LazyEither<ST,PT>
    
    Parameters:
    
    fn - Function to transform left type to right
    
    Returns:
    
    Either with left type mapped to right
  - mapLeft
```
public <R> LazyEither<R,PT> mapLeft(java.util.function.Function<? super ST,? extends R> fn)
```
    Description copied from interface: LazyEither
    
    Always transform the Left type of this Either if it is present using the provided transformation function
    
    Specified by:
    
    mapLeft in interface Either<ST,PT>
    
    Specified by:
    
    mapLeft in interface LazyEither<ST,PT>
    
    Parameters:
    
    fn - Transformation function for Left types
    
    Returns:
    
    Either with Left type transformed
  - map
```
public <R> LazyEither<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 Either<ST,PT>
    
    Specified by:
    
    map in interface LazyEither<ST,PT>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Transformable
  - peekLeft
```
public LazyEither<ST,PT> peekLeft(java.util.function.Consumer<? super ST> action)
```
    Description copied from interface: LazyEither
    
    Peek at the Left type value if present
    
    Specified by:
    
    peekLeft in interface Either<ST,PT>
    
    Specified by:
    
    peekLeft in interface LazyEither<ST,PT>
    
    Parameters:
    
    action - Consumer to peek at the Left type value
    
    Returns:
    
    Either with the same values as before
  - peek
```
public LazyEither<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 Either<ST,PT>
    
    Specified by:
    
    peek in interface LazyEither<ST,PT>
    
    Parameters:
    
    action - Consumer that recieves each element from this Transformable
    
    Returns:
    
    Transformable that will peek at each value
  - filter
```
public Maybe<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 Either<ST,PT>
    
    Specified by:
    
    filter in interface LazyEither<ST,PT>
    
    Parameters:
    
    test - to filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - swap
```
public LazyEither<PT,ST> swap()
```
    Description copied from interface: LazyEither
    Swap types so operations directly affect the current (pre-swap) Left type
```
  

    Either.left("hello")
       .map(v->v+" world")
    //Either.seconary["hello"]

    Either.left("hello")
       .swap()
       .map(v->v+" world")
       .swap()
    //Either.seconary["hello world"]
  
  
```
    Specified by:
    
    swap in interface Either<ST,PT>
    
    Specified by:
    
    swap in interface LazyEither<ST,PT>
    
    Returns:
    
    Swap the right and left types, allowing operations directly on what was the Left type
  - get
```
public Option<PT> get()
```
    Specified by:
    
    get in interface Either<ST,PT>
    
    Specified by:
    
    get in interface LazyEither<ST,PT>
  - getLeft
```
public Option<ST> getLeft()
```
    Specified by:
    
    getLeft in interface Either<ST,PT>
    
    Specified by:
    
    getLeft in interface LazyEither<ST,PT>
    
    Returns:
    
    The Left Value if present, otherwise null
  - leftOrElse
```
public ST leftOrElse(ST alt)
```
    Specified by:
    
    leftOrElse in interface Either<ST,PT>
  - leftToStream
```
public ReactiveSeq<ST> leftToStream()
```
    Specified by:
    
    leftToStream in interface Either<ST,PT>
    
    Specified by:
    
    leftToStream in interface LazyEither<ST,PT>
    
    Returns:
    
    A Stream containing the left value if present, otherwise an zero Stream
  - flatMap
```
public <RT1> LazyEither<ST,RT1> flatMap(java.util.function.Function<? super PT,? extends Either<? extends ST,? extends RT1>> mapper)
```
    Specified by:
    
    flatMap in interface Either<ST,PT>
    
    Specified by:
    
    flatMap in interface LazyEither<ST,PT>
  - flatMapLeft
```
public <LT1> LazyEither<LT1,PT> flatMapLeft(java.util.function.Function<? super ST,? extends Either<LT1,PT>> mapper)
```
    Description copied from interface: LazyEither
    
    Perform a flatMap operation on the Left type
    
    Specified by:
    
    flatMapLeft in interface Either<ST,PT>
    
    Specified by:
    
    flatMapLeft in interface LazyEither<ST,PT>
    
    Parameters:
    
    mapper - Flattening transformation function
    
    Returns:
    
    Either containing the value inside the result of the transformation function as the Left value, if the Left type was present
  - flatMapLeftToRight
```
public LazyEither<ST,PT> flatMapLeftToRight(java.util.function.Function<? super ST,? extends Either<ST,PT>> fn)
```
    Description copied from interface: LazyEither
    
    A flatMap operation that keeps the Left and Right types the same
    
    Specified by:
    
    flatMapLeftToRight in interface Either<ST,PT>
    
    Specified by:
    
    flatMapLeftToRight in interface LazyEither<ST,PT>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Either
  - fold
```
public <R> R fold(java.util.function.Function<? super ST,? extends R> secondary,
                  java.util.function.Function<? super PT,? extends R> primary)
```
    Description copied from interface: LazyEither
    Visitor pattern for this Ior. Execute the left function if this Either contains an element of the left type Execute the right function if this Either contains an element of the right type
```
 
  Either.right(10)
     .visit(left->"no", right->"yes")
  //Either["yes"]

        Either.left(90)
           .visit(left->"no", right->"yes")
        //Either["no"]



 
 
```
    Specified by:
    
    fold in interface Sealed2<ST,PT>
    
    Specified by:
    
    fold in interface Either<ST,PT>
    
    Specified by:
    
    fold in interface LazyEither<ST,PT>
    
    Parameters:
    
    secondary - Function to execute if this is a Left Either
    
    primary - Function to execute if this is a Right Ior
    
    Returns:
    
    Result of executing the appropriate function
  - toMaybe
```
public Maybe<PT> toMaybe()
```
    Specified by:
    
    toMaybe in interface Value<PT>
  - toOptional
```
public java.util.Optional<PT> toOptional()
```
    Specified by:
    
    toOptional in interface Value<PT>
  - 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
  - toIor
```
public Ior<ST,PT> toIor()
```
    Specified by:
    
    toIor in interface Either<ST,PT>
    
    Specified by:
    
    toIor in interface LazyEither<ST,PT>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - fold
```
public <R> R fold(java.util.function.Function<? super PT,? extends R> present,
                  java.util.function.Supplier<? extends R> absent)
```
    Specified by:
    
    fold in interface SealedOr<PT>

Class LazyEither.Left<ST,PT>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.control.LazyEither

Methods inherited from interface cyclops.control.Either

Methods inherited from interface com.oath.cyclops.types.foldable.To

Methods inherited from interface com.oath.cyclops.types.OrElseValue

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.oath.cyclops.hkt.Higher

Methods inherited from interface com.oath.cyclops.hkt.Convert

Constructor Detail

Left

Method Detail

recover

recover

recoverWith

isLeft

isRight

mapLeftToRight

mapLeft

map

peekLeft

peek

filter

swap

get

getLeft

leftOrElse

leftToStream

flatMap

flatMapLeft

flatMapLeftToRight

fold

toMaybe

toOptional

toString

mkString

toIor

hashCode

equals

fold