Either.Left (cyclops 10.3.2 API)

java.lang.Object
- cyclops.control.Either.Left<L,R>

All Implemented Interfaces:

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

Enclosing interface:

Either<LT,RT>
```
public static class Either.Left<L,R>
extends java.lang.Object
implements Either<L,R>
```
See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.control.Either
  Either.Left<L,R>, Either.Right<L,RT>

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)`
`Option<R>`	`filter(java.util.function.Predicate<? super R> test)` Keep only elements for which the supplied predicates hold e.g.
`Either<L,R>`	`filter(java.util.function.Predicate<? super R> test, java.util.function.Function<? super R,? extends L> rightToLeft)`
`<RT1> Either<L,RT1>`	`flatMap(java.util.function.Function<? super R,? extends Either<? extends L,? extends RT1>> mapper)`
`<LT1> Either<LT1,R>`	`flatMapLeft(java.util.function.Function<? super L,? extends Either<LT1,R>> mapper)` Perform a flatMap operation on the Left type
`Either<L,R>`	`flatMapLeftToRight(java.util.function.Function<? super L,? extends Either<L,R>> fn)` A flatMap operation that keeps the Left and Right types the same
`<R2> R2`	`fold(java.util.function.Function<? super L,? extends R2> fn1, java.util.function.Function<? super R,? extends R2> fn2)` Visitor pattern for this Ior.
`<R2> R2`	`fold(java.util.function.Function<? super R,? extends R2> present, java.util.function.Supplier<? extends R2> absent)`
`Option<R>`	`get()`
`Option<L>`	`getLeft()`
`int`	`hashCode()`
`boolean`	`isLeft()`
`boolean`	`isRight()`
`L`	`leftOrElse(L alt)`
`ReactiveSeq<L>`	`leftToStream()`
`<R2> Either<L,R2>`	`map(java.util.function.Function<? super R,? extends R2> fn)` Transform this functor using the supplied transformation function
`<R2> Either<R2,R>`	`mapLeft(java.util.function.Function<? super L,? extends R2> fn)` Always transform the Left type of this Either if it is present using the provided transformation function
`Either<L,R>`	`mapLeftToRight(java.util.function.Function<? super L,? extends R> 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.
`Either<L,R>`	`peek(java.util.function.Consumer<? super R> action)` Peek at the current value of this Transformable, without transforming it
`Either<L,R>`	`peekLeft(java.util.function.Consumer<? super L> action)` Peek at the Left type value if present
`Either<L,R>`	`recover(R value)`
`Either<L,R>`	`recover(java.util.function.Supplier<? extends R> value)`
`Either<L,R>`	`recoverWith(java.util.function.Supplier<? extends Either<L,R>> fn)`
`Either<R,L>`	`swap()` Swap types so operations directly affect the current (pre-swap) Left type
`Ior<L,R>`	`toIor()`
`Maybe<R>`	`toMaybe()`
`java.util.Optional<R>`	`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.Either
accumulateLeft, accumulateLeft, accumulateLeft, accumulateRight, accumulateRight, accumulateRight, applyAny, arity, bimap, bipeek, combine, combineToLazySeq, combineToVector, consumeAny, filterNot, foldAny, forEach2, forEach3, forEach4, fromIterable, fromPublisher, isPresent, lazySeq, left, narrowK, narrowK2, nest, nestedEval, notNull, ofType, right, sequence, sequenceLeft, sequenceRight, tailRec, toEither, toTrampoline, traverse, unit, visitAny, visitAny, widen, zip, zip

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<L,R> recover(java.util.function.Supplier<? extends R> value)
```
    Specified by:
    
    recover in interface Either<L,R>
  - recover
```
public Either<L,R> recover(R value)
```
    Specified by:
    
    recover in interface Either<L,R>
  - recoverWith
```
public Either<L,R> recoverWith(java.util.function.Supplier<? extends Either<L,R>> fn)
```
    Specified by:
    
    recoverWith in interface Either<L,R>
  - isLeft
```
public boolean isLeft()
```
    Specified by:
    
    isLeft in interface Either<L,R>
    
    Returns:
    
    True if this is a left Either
  - isRight
```
public boolean isRight()
```
    Specified by:
    
    isRight in interface Either<L,R>
    
    Returns:
    
    True if this is a right Either
  - mapLeftToRight
```
public Either<L,R> mapLeftToRight(java.util.function.Function<? super L,? extends R> fn)
```
    Description copied from interface: Either
    
    If this Either contains the Left type, transform it's value so that it contains the Right type
    
    Specified by:
    
    mapLeftToRight in interface Either<L,R>
    
    Parameters:
    
    fn - Function to transform left type to right
    
    Returns:
    
    Either with left type mapped to right
  - mapLeft
```
public <R2> Either<R2,R> mapLeft(java.util.function.Function<? super L,? extends R2> fn)
```
    Description copied from interface: Either
    
    Always transform the Left type of this Either if it is present using the provided transformation function
    
    Specified by:
    
    mapLeft in interface Either<L,R>
    
    Parameters:
    
    fn - Transformation function for Left types
    
    Returns:
    
    Either with Left type transformed
  - map
```
public <R2> Either<L,R2> map(java.util.function.Function<? super R,? extends R2> 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<R>
    
    Specified by:
    
    map in interface Either<L,R>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Transformable
  - peekLeft
```
public Either<L,R> peekLeft(java.util.function.Consumer<? super L> action)
```
    Description copied from interface: Either
    
    Peek at the Left type value if present
    
    Specified by:
    
    peekLeft in interface Either<L,R>
    
    Parameters:
    
    action - Consumer to peek at the Left type value
    
    Returns:
    
    Either with the same values as before
  - peek
```
public Either<L,R> peek(java.util.function.Consumer<? super R> 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<R>
    
    Specified by:
    
    peek in interface Either<L,R>
    
    Parameters:
    
    action - Consumer that recieves each element from this Transformable
    
    Returns:
    
    Transformable that will peek at each value
  - filter
```
public Option<R> filter(java.util.function.Predicate<? super R> 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<R>
    
    Specified by:
    
    filter in interface Either<L,R>
    
    Parameters:
    
    test - to filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - filter
```
public Either<L,R> filter(java.util.function.Predicate<? super R> test,
                          java.util.function.Function<? super R,? extends L> rightToLeft)
```
    Specified by:
    
    filter in interface Either<L,R>
  - swap
```
public Either<R,L> swap()
```
    Description copied from interface: Either
    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<L,R>
    
    Returns:
    
    Swap the right and left types, allowing operations directly on what was the Left type
  - get
```
public Option<R> get()
```
    Specified by:
    
    get in interface Either<L,R>
  - getLeft
```
public Option<L> getLeft()
```
    Specified by:
    
    getLeft in interface Either<L,R>
    
    Returns:
    
    The Left Value if present, otherwise null
  - leftOrElse
```
public L leftOrElse(L alt)
```
    Specified by:
    
    leftOrElse in interface Either<L,R>
  - leftToStream
```
public ReactiveSeq<L> leftToStream()
```
    Specified by:
    
    leftToStream in interface Either<L,R>
    
    Returns:
    
    A Stream containing the Either Left value if present, otherwise an zero Stream
  - flatMap
```
public <RT1> Either<L,RT1> flatMap(java.util.function.Function<? super R,? extends Either<? extends L,? extends RT1>> mapper)
```
    Specified by:
    
    flatMap in interface Either<L,R>
  - flatMapLeft
```
public <LT1> Either<LT1,R> flatMapLeft(java.util.function.Function<? super L,? extends Either<LT1,R>> mapper)
```
    Description copied from interface: Either
    
    Perform a flatMap operation on the Left type
    
    Specified by:
    
    flatMapLeft in interface Either<L,R>
    
    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 Either<L,R> flatMapLeftToRight(java.util.function.Function<? super L,? extends Either<L,R>> fn)
```
    Description copied from interface: Either
    
    A flatMap operation that keeps the Left and Right types the same
    
    Specified by:
    
    flatMapLeftToRight in interface Either<L,R>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Either
  - toMaybe
```
public Maybe<R> toMaybe()
```
    Specified by:
    
    toMaybe in interface Value<R>
  - toOptional
```
public java.util.Optional<R> toOptional()
```
    Specified by:
    
    toOptional in interface Value<R>
  - 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<R>
    
    Returns:
    
    String
  - toIor
```
public Ior<L,R> toIor()
```
    Specified by:
    
    toIor in interface Either<L,R>
  - 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 <R2> R2 fold(java.util.function.Function<? super L,? extends R2> fn1,
                    java.util.function.Function<? super R,? extends R2> fn2)
```
    Description copied from interface: Either
    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<L,R>
    
    Specified by:
    
    fold in interface Either<L,R>
    
    Parameters:
    
    fn1 - Function to execute if this is a Left Either
    
    fn2 - Function to execute if this is a Right Ior
    
    Returns:
    
    Result of executing the appropriate function
  - fold
```
public <R2> R2 fold(java.util.function.Function<? super R,? extends R2> present,
                    java.util.function.Supplier<? extends R2> absent)
```
    Specified by:
    
    fold in interface SealedOr<R>

Class Either.Left<L,R>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

filter

swap

get

getLeft

leftOrElse

leftToStream

flatMap

flatMapLeft

flatMapLeftToRight

toMaybe

toOptional

toString

mkString

toIor

hashCode

equals

fold

fold