LazyEither4.Left3 (cyclops 10.3.3 API)

java.lang.Object
- cyclops.control.LazyEither4.Left3<ST,M,M2,PT>

All Implemented Interfaces:

Convert<Higher<Higher<Higher<Higher<DataWitness.lazyEither4,ST>,M>,M2>,PT>>, Higher<Higher<Higher<Higher<DataWitness.lazyEither4,ST>,M>,M2>,PT>, Higher2<Higher<Higher<DataWitness.lazyEither4,ST>,M>,M2,PT>, Higher3<Higher<DataWitness.lazyEither4,ST>,M,M2,PT>, Higher4<DataWitness.lazyEither4,ST,M,M2,PT>, Sealed4<ST,M,M2,PT>, SealedOr<PT>, Unit<PT>, Filters<PT>, To<LazyEither4<ST,M,M2,PT>>, BiTransformable<M2,PT>, Transformable<PT>, OrElseValue<PT,LazyEither4<ST,M,M2,PT>>, Value<PT>, LazyEither4<ST,M,M2,PT>, io.kindedj.Hk<Higher<Higher<Higher<DataWitness.lazyEither4,ST>,M>,M2>,PT>, java.lang.Iterable<PT>, org.reactivestreams.Publisher<PT>

Enclosing interface:

LazyEither4<LT1,LT2,LT3,RT>
```
public static class LazyEither4.Left3<ST,M,M2,PT>
extends java.lang.Object
implements LazyEither4<ST,M,M2,PT>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.control.LazyEither4
  LazyEither4.CompletableEither4<ORG,LT1,LT2,RT>, LazyEither4.Lazy<ST,M,M2,PT>, LazyEither4.Left1<ST,M,M2,PT>, LazyEither4.Left2<ST,M,M2,PT>, LazyEither4.Left3<ST,M,M2,PT>, LazyEither4.Right<ST,M,M2,PT>

Constructor Summary

Constructors
Constructor and Description

Left3()

Constructors
Constructor and Description
`Left3()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<R1,R2> LazyEither4<ST,M,R1,R2>`	`bimap(java.util.function.Function<? super M2,? extends R1> fn1, java.util.function.Function<? super PT,? extends R2> fn2)` Transform this BiTransformable, changing two value types at once.
`boolean`	`equals(java.lang.Object obj)`
`Maybe<PT>`	`filter(java.util.function.Predicate<? super PT> test)` Filter this Either4 resulting in a Maybe#none if it is not a Right instance or if the predicate does not hold.
`<RT1> LazyEither4<ST,M,M2,RT1>`	`flatMap(java.util.function.Function<? super PT,? extends LazyEither4<ST,M,M2,? extends RT1>> mapper)` Flattening transformation on this Either4.
`<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 M,? extends R> mid1, java.util.function.Function<? super M2,? extends R> mid2, java.util.function.Function<? super PT,? extends R> primary)`
`Option<PT>`	`get()`
`int`	`hashCode()`
`boolean`	`isLeft1()`
`boolean`	`isLeft2()`
`boolean`	`isLeft3()`
`boolean`	`isRight()`
`java.util.Iterator<PT>`	`iterator()`
`<R> LazyEither4<ST,M,M2,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.
`LazyEither4<ST,M,M2,PT>`	`peek(java.util.function.Consumer<? super PT> action)` Peek at the current value of this Transformable, without transforming it
`ReactiveSeq<PT>`	`stream()`
`void`	`subscribe(org.reactivestreams.Subscriber<? super PT> s)`
`LazyEither4<PT,M,M2,ST>`	`swap1()`
`LazyEither4<ST,PT,M2,M>`	`swap2()`
`LazyEither4<ST,M,PT,M2>`	`swap3()`
`java.lang.String`	`toString()`
`<T> LazyEither4<ST,M,M2,T>`	`unit(T unit)`

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

Methods inherited from interface cyclops.control.LazyEither4
accumulate, always, applyAny, bipeek, coflatMap, consumeAny, either4, filter, filterNot, foldAny, forEach2, forEach3, forEach4, fromFuture, fromIterable, fromLazy, fromPublisher, later, left1, left1Eval, left2, left2Eval, left3, left3Eval, narrowK, narrowK3, nest, notNull, ofType, right, rightEval, sequence, sequence, toEither, toIor, toTrampoline, traverse, traverse, visitAny, visitAny, widen, zip

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

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

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, isPresent, iterate, nonEmptyList, nonEmptyListGet, orElse, orElseGet, print, print, printErr, printOut, toEither, toLazyEither, toLeft, toMaybe, toOption, toOptional, toRight, toTry, toTry, toTry

Methods inherited from interface java.lang.Iterable
spliterator

- Constructor Detail
  - Left3
```
public Left3()
```
- Method Detail
  - map
```
public <R> LazyEither4<ST,M,M2,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 LazyEither4<ST,M,M2,PT>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Transformable
  - peek
```
public LazyEither4<ST,M,M2,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 LazyEither4<ST,M,M2,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: LazyEither4
    
    Filter this Either4 resulting in a Maybe#none if it is not a Right instance or if the predicate does not hold. Otherwise results in a Maybe containing the current value
    
    Specified by:
    
    filter in interface Filters<PT>
    
    Specified by:
    
    filter in interface LazyEither4<ST,M,M2,PT>
    
    Parameters:
    
    test - Predicate to applyHKT to filter this Either4
    
    Returns:
    
    Maybe containing the current value if this is a Right instance and the predicate holds, otherwise Maybe#none
  - subscribe
```
public void subscribe(org.reactivestreams.Subscriber<? super PT> s)
```
    Specified by:
    
    subscribe in interface Value<PT>
    
    Specified by:
    
    subscribe in interface org.reactivestreams.Publisher<PT>
  - get
```
public Option<PT> get()
```
    Specified by:
    
    get in interface LazyEither4<ST,M,M2,PT>
  - flatMap
```
public <RT1> LazyEither4<ST,M,M2,RT1> flatMap(java.util.function.Function<? super PT,? extends LazyEither4<ST,M,M2,? extends RT1>> mapper)
```
    Description copied from interface: LazyEither4
    
    Flattening transformation on this Either4. Contains an internal trampoline so will convert tail-recursive calls to iteration.
    
    Specified by:
    
    flatMap in interface LazyEither4<ST,M,M2,PT>
    
    Parameters:
    
    mapper - Mapping function
    
    Returns:
    
    Mapped Either4
  - isRight
```
public boolean isRight()
```
    Specified by:
    
    isRight in interface LazyEither4<ST,M,M2,PT>
    
    Returns:
    
    True if this lazy contains the right type
  - isLeft1
```
public boolean isLeft1()
```
    Specified by:
    
    isLeft1 in interface LazyEither4<ST,M,M2,PT>
    
    Returns:
    
    True if this lazy contains the left1 type
  - isLeft3
```
public boolean isLeft3()
```
    Specified by:
    
    isLeft3 in interface LazyEither4<ST,M,M2,PT>
    
    Returns:
    
    True if this lazy contains the left3 type
  - 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
  - fold
```
public <R> R fold(java.util.function.Function<? super ST,? extends R> secondary,
                  java.util.function.Function<? super M,? extends R> mid1,
                  java.util.function.Function<? super M2,? extends R> mid2,
                  java.util.function.Function<? super PT,? extends R> primary)
```
    Specified by:
    
    fold in interface Sealed4<ST,M,M2,PT>
    
    Specified by:
    
    fold in interface LazyEither4<ST,M,M2,PT>
  - bimap
```
public <R1,R2> LazyEither4<ST,M,R1,R2> bimap(java.util.function.Function<? super M2,? 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<M2,PT>
    
    Specified by:
    
    bimap in interface LazyEither4<ST,M,M2,PT>
    
    Parameters:
    
    fn1 - transformation function for the first type
    
    fn2 - transformation function for the second type
    
    Returns:
    
    New BiTransformable containing transformed data
  - stream
```
public ReactiveSeq<PT> stream()
```
    Specified by:
    
    stream in interface Value<PT>
  - iterator
```
public java.util.Iterator<PT> iterator()
```
    Specified by:
    
    iterator in interface Value<PT>
    
    Specified by:
    
    iterator in interface java.lang.Iterable<PT>
  - 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>
  - unit
```
public <T> LazyEither4<ST,M,M2,T> unit(T unit)
```
    Specified by:
    
    unit in interface Unit<PT>
    
    Specified by:
    
    unit in interface LazyEither4<ST,M,M2,PT>
  - swap3
```
public LazyEither4<ST,M,PT,M2> swap3()
```
    Specified by:
    
    swap3 in interface LazyEither4<ST,M,M2,PT>
    
    Returns:
    
    Swap the third and the right types
  - swap2
```
public LazyEither4<ST,PT,M2,M> swap2()
```
    Specified by:
    
    swap2 in interface LazyEither4<ST,M,M2,PT>
    
    Returns:
    
    Swap the second and the right types
  - swap1
```
public LazyEither4<PT,M,M2,ST> swap1()
```
    Specified by:
    
    swap1 in interface LazyEither4<ST,M,M2,PT>
    
    Returns:
    
    Swap the right and left types
  - isLeft2
```
public boolean isLeft2()
```
    Specified by:
    
    isLeft2 in interface LazyEither4<ST,M,M2,PT>
    
    Returns:
    
    True if this lazy contains the left2 type
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object

Class LazyEither4.Left3<ST,M,M2,PT>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.control.LazyEither4

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

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

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

Constructor Detail

Left3

Method Detail

map

peek

filter

subscribe

get

flatMap

isRight

isLeft1

isLeft3

toString

mkString

fold

bimap

stream

iterator

fold

unit

swap3

swap2

swap1

isLeft2

equals

hashCode