LazyEither.Lazy (cyclops 10.0.0-RC1 API)

java.lang.Object
- cyclops.control.LazyEither.Lazy<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 final class LazyEither.Lazy<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

Lazy()

Constructors
Constructor and Description
`Lazy()`

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.
`LazyEither<ST,PT>`	`filter(java.util.function.Predicate<? super PT> test, java.util.function.Function<? super PT,? extends ST> rightToLeft)`
`<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()`
`java.util.Iterator<PT>`	`iterator()`
`ST`	`leftOrElse(ST alt)`
`ReactiveSeq<ST>`	`leftToStream()`
`<R> LazyEither<ST,R>`	`map(java.util.function.Function<? super PT,? extends R> mapper)` 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
`Eval<Either<ST,PT>>`	`nestedEval()`
`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<ST,PT>`	`resolve()`
`void`	`subscribe(org.reactivestreams.Subscriber<? super PT> sub)`
`LazyEither<PT,ST>`	`swap()` Swap types so operations directly affect the current (pre-swap) Left type
`Trampoline<LazyEither<ST,PT>>`	`toEitherTrampoline()`
`Ior<ST,PT>`	`toIor()`
`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, applyAny, arity, async, bimap, bipeek, combine, combine, combineToLazySeq, combineToList, consumeAny, either, forEach2, forEach3, forEach4, fromEither, fromFuture, fromIterable, fromLazy, fromPublisher, isPresent, lazySeq, left, leftEval, narrow, narrowK, narrowK2, nest, right, rightEval, sequence, sequenceLeft, sequenceRight, tailRec, toEither, toEither, 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, fromIterable, 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, mkString, newSubscriber, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, stream, toLazyEither, toLeft, toMaybe, toOption, toOptional, toRight, toTry, toTry, toTry, transform

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
  - Lazy
```
public Lazy()
```
- 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>
  - nestedEval
```
public Eval<Either<ST,PT>> nestedEval()
```
    Specified by:
    
    nestedEval in interface Either<ST,PT>
  - toEitherTrampoline
```
public Trampoline<LazyEither<ST,PT>> toEitherTrampoline()
```
    Specified by:
    
    toEitherTrampoline in interface LazyEither<ST,PT>
  - iterator
```
public java.util.Iterator<PT> iterator()
```
    Specified by:
    
    iterator in interface Value<PT>
    
    Specified by:
    
    iterator in interface java.lang.Iterable<PT>
  - resolve
```
public LazyEither<ST,PT> resolve()
```
  - map
```
public <R> LazyEither<ST,R> map(java.util.function.Function<? super PT,? extends R> mapper)
```
    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:
    
    mapper - Transformation function
    
    Returns:
    
    Transformed Transformable
  - 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>
  - subscribe
```
public final void subscribe(org.reactivestreams.Subscriber<? super PT> sub)
```
    Specified by:
    
    subscribe in interface Value<PT>
    
    Specified by:
    
    subscribe in interface org.reactivestreams.Publisher<PT>
  - 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
  - filter
```
public LazyEither<ST,PT> filter(java.util.function.Predicate<? super PT> test,
                                java.util.function.Function<? super PT,? extends ST> rightToLeft)
```
    Specified by:
    
    filter in interface Either<ST,PT>
    
    Specified by:
    
    filter in interface LazyEither<ST,PT>
  - 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
  - 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
  - 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
  - toIor
```
public Ior<ST,PT> toIor()
```
    Specified by:
    
    toIor in interface Either<ST,PT>
    
    Specified by:
    
    toIor in interface LazyEither<ST,PT>
  - 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
  - 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
  - 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
  - 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
  - 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
  - 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
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString 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.Lazy<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

Lazy

Method Detail

recover

recover

recoverWith

nestedEval

toEitherTrampoline

iterator

resolve

map

flatMap

subscribe

filter

filter

mapLeftToRight

mapLeft

peekLeft

peek

swap

toIor

fold

get

getLeft

leftOrElse

leftToStream

flatMapLeft

flatMapLeftToRight

isRight

isLeft

hashCode

equals

toString

fold