Good (Javactic API)

java.lang.Object
- com.github.javactic.Good<G,B>

Type Parameters:

G - the success type of the Or

B - the failure type of the Or

All Implemented Interfaces:

Or<G,B>, Serializable
```
public final class Good<G,B>
extends Object
implements Or<G,B>, Serializable
```
Contains a "success" value. You can decide what "success" means, but it is expected Good will be commonly used to hold valid results for processes that may fail with an error instead of producing a valid result.

Author:

mvh

See Also:

Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Or<G,One<B>>`	`accumulating()` Converts this `Or` to an `Or` with the same `Good` type and a `Bad` type consisting of `One` parameterized by this `Or`'s `Bad` type.
`Or<G,B>`	`asOr()` Returns this Good with the type widened to Or.
`<C> Or<G,C>`	`badMap(Function<? super B,? extends C> mapper)` Maps the given function to this `Or`'s value if it is a `Bad` or returns `this` if it is a `Good`.
`boolean`	`contains(G good)` Returns true if this Or is a Good and its value is deeply equals to the given argument according to `Objects.deepEquals(Object, Object)`.
`boolean`	`containsBad(B bad)` Returns true if this Or is a Bad and its value is deeply equals to the given argument according to `Objects.deepEquals(Object, Object)`.
`boolean`	`equals(Object obj)`
`boolean`	`exists(Predicate<? super G> predicate)` Returns `true` if this `Or` is a `Good` and the predicate `p` returns true when applied to this `Good`'s value.
`Or<G,B>`	`filter(Function<? super G,? extends Validation<? extends B>> validator)` Returns this `Or` if either 1) it is a `Bad` or 2) it is a `Good` and applying the validation function `validation` to this `Good`'s value returns `Pass`; otherwise, returns a new `Bad` containing the error value contained in the `Fail` resulting from applying the validation function `validation` to this `Good`'s value.
`<H> Or<H,B>`	`flatMap(Function<? super G,? extends Or<? extends H,? extends B>> func)` Returns the given function applied to the value contained in this `Or` if it is a `Good`, or returns `this` if it is a `Bad`.
`<V> V`	`fold(Function<? super G,? extends V> good, Function<? super B,? extends V> bad)` Folds this `Or` into a value of type `V` by applying the given `gf` function if this is a `Good` else the given `bf` function if this is a `Bad`.
`boolean`	`forAll(Predicate<? super G> predicate)` Returns `true` if either this `Or` is a `Bad` or if the predicate `p` returns `true` when applied to this `Good`'s value.
`void`	`forEach(Consumer<? super G> action)` Applies the given function `action` to the contained value if this `Or` is a `Good`; does nothing if this `Or` is a `Bad`.
`void`	`forEach(Consumer<? super G> gc, Consumer<? super B> bc)` A terminal operation to handle both success and failure cases.
`G`	`get()` Returns the `Or`'s value if it is a `Good` or throws `NoSuchElementException` if it is a `Bad`.
`B`	`getBad()` Returns the `Or`'s value if it is a `Bad` or throws `NoSuchElementException` if it is a `Good`.
`G`	`getOrElse(Function<? super B,? extends G> def)` Returns, if this `Or` is `Good`, this `Good`'s value; otherwise returns the result of evaluating `default`.
`G`	`getOrElse(G alt)` Returns, if this `Or` is `Good`, this `Good`'s value; otherwise returns `default`.
`int`	`hashCode()`
`boolean`	`isBad()` Indicates whether this `Or` is a `Bad`.
`boolean`	`isGood()` Indicates whether this `Or` is a `Good`.
`<H> Or<H,B>`	`map(Function<? super G,? extends H> mapper)` Maps the given function to this `Or`'s value if it is a `Good` or returns `this` if it is a `Bad`.
`static <G,B> Good<G,B>`	`of(G value)`
`Or<G,B>`	`orElse(Or<? extends G,? extends B> alt)` Returns this `Or` if it is a `Good`, otherwise returns the passed `alt`.
`Or<G,B>`	`orElse(Supplier<? extends Or<? extends G,? extends B>> alt)` Returns this `Or` if it is a `Good`, otherwise returns the result of evaluating the passed `alt`.
`Or<G,B>`	`recover(Function<? super B,? extends G> func)` Maps the given function to this `Or`'s value if it is a `Bad`, transforming it into a `Good`, or returns `this` if it is already a `Good`.
`<C> Or<G,C>`	`recoverWith(Function<? super B,? extends Or<? extends G,? extends C>> func)` Maps the given function to this `Or`'s value if it is a `Bad`, returning the result, or returns `this` if it is already a `Good`.
`Or<B,G>`	`swap()` Returns an `Or` with the `Good` and `Bad` types swapped: `Bad` becomes `Good` and `Good` becomes `Bad`.
`Either<B,G>`	`toEither()` Returns an `Either`: a right `Either` containing the `Good` value, if this is a `Good`; a left `Either` containing the `Bad` value, if this is a `Bad`.
`Optional<G>`	`toJavaOptional()` Returns an `Optional` that is defined if this is a `Good` and not if this is a `Bad`.
`Option<G>`	`toOption()` Returns a `Option` containing the `Good` value, if this `Or` is a `Good`, else none.
`String`	`toString()`
`<H,C> Or<H,C>`	`transform(Function<? super G,? extends H> gf, Function<? super B,? extends C> bf)` Transforms this `Or` by applying the function `gf` to this `Or`'s `Good` value if it is a `Good`, or by applying `bf` to this `Or`'s `Bad` value if it is a `Bad`.

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

Methods inherited from interface com.github.javactic.Or
bad, from, from, from, from, fromAny, fromJavaOptional, fromJavaOptional, good, toAny, toTry

- Method Detail
  - of
```
public static <G,B> Good<G,B> of(G value)
```
  - accumulating
```
public Or<G,One<B>> accumulating()
```
    Description copied from interface: Or
    Converts this Or to an Or with the same Good type and a Bad type consisting of One parameterized by this Or's Bad type.
    For example, invoking the accumulating method on an Or<Int,ErrorMessage> would convert it to an Or<Int,One<ErrorMessage>>. This result type, because the Bad type is an Every, can be used with the mechanisms provided in class Accumulation to accumulate errors.
    Note that if this Or is already an accumulating Or, the behavior of this accumulating method does not change. For example, if you invoke accumulating on an Or<Int,One<ErrorMessage>> you will be rewarded with an Or<Int,One<One<ErrorMessage>>>.
```
 Scalactic: def accumulating: Or[G, One[B]] 
```
    Specified by:
    
    accumulating in interface Or<G,B>
    
    Returns:
    
    this Good, if this Or is a Good; or this Bad value wrapped in a One if this Or is a Bad.
  - asOr
```
public Or<G,B> asOr()
```
    Returns this Good with the type widened to Or.
```
 Scalactic: def asOr: Or[G, B] 
```
    Returns:
    
    this Good with the type widened to Or
  - map
```
public <H> Or<H,B> map(Function<? super G,? extends H> mapper)
```
    Description copied from interface: Or
    Maps the given function to this Or's value if it is a Good or returns this if it is a Bad.
```
Scalactic: def map[H](f: (G) => H): Or[H, B] 
```
    Specified by:
    
    map in interface Or<G,B>
    
    Type Parameters:
    
    H - The element type of the new Good
    
    Parameters:
    
    mapper - the function to apply
    
    Returns:
    
    if this is a Good, the result of applying the given function to the contained value wrapped in a Good, else this Bad is returned
  - badMap
```
public <C> Or<G,C> badMap(Function<? super B,? extends C> mapper)
```
    Description copied from interface: Or
    Maps the given function to this Or's value if it is a Bad or returns this if it is a Good.
```
Scalactic: def badMap[C](f: (B) => C): Or[G, C] 
```
    Specified by:
    
    badMap in interface Or<G,B>
    
    Type Parameters:
    
    C - The element type of the new Bad
    
    Parameters:
    
    mapper - the function to apply
    
    Returns:
    
    if this is a Bad, the result of applying the given function to the contained value wrapped in a Bad, else this Good is returned
  - contains
```
public boolean contains(G good)
```
    Description copied from interface: Or
    
    Returns true if this Or is a Good and its value is deeply equals to the given argument according to Objects.deepEquals(Object, Object).
    
    Specified by:
    
    contains in interface Or<G,B>
    
    Parameters:
    
    good - the value to compare to this Or's value if it is a Good
    
    Returns:
    
    true if this Or is a Good and its value is deeply equals to the given argument.
  - containsBad
```
public boolean containsBad(B bad)
```
    Description copied from interface: Or
    
    Returns true if this Or is a Bad and its value is deeply equals to the given argument according to Objects.deepEquals(Object, Object).
    
    Specified by:
    
    containsBad in interface Or<G,B>
    
    Parameters:
    
    bad - the value to compare to this Or's value if it is a Bad
    
    Returns:
    
    true if this Or is a Bad and its value is deeply equals to the given argument.
  - exists
```
public boolean exists(Predicate<? super G> predicate)
```
    Description copied from interface: Or
    Returns true if this Or is a Good and the predicate p returns true when applied to this Good's value.
    Note: The exists method will return the same result as Or.forAll(java.util.function.Predicate<? super G>) if this Or is a Good, but the opposite result if this Or is a Bad.
```
Scalactic: def exists(p: (G) => Boolean): Boolean 
```
    Specified by:
    
    exists in interface Or<G,B>
    
    Parameters:
    
    predicate - the predicate to apply to the Good value, if this is a Good
    
    Returns:
    
    the result of applying the passed predicate p to the Good value, if this is a Good, else false
  - flatMap
```
public <H> Or<H,B> flatMap(Function<? super G,? extends Or<? extends H,? extends B>> func)
```
    Description copied from interface: Or
    Returns the given function applied to the value contained in this Or if it is a Good, or returns this if it is a Bad.
```
Scalactic: def flatMap[H, C >: B](f: (G) => Or[H, C]): Or[H, C] 
```
    Specified by:
    
    flatMap in interface Or<G,B>
    
    Type Parameters:
    
    H - the element type of the new Good
    
    Parameters:
    
    func - the function to apply
    
    Returns:
    
    if this is a Good, the result of applying the given function to the contained value wrapped in a Good, else this Bad is returned
  - fold
```
public <V> V fold(Function<? super G,? extends V> good,
                  Function<? super B,? extends V> bad)
```
    Description copied from interface: Or
    Folds this Or into a value of type V by applying the given gf function if this is a Good else the given bf function if this is a Bad.
```
Scalactic: def fold[V](gf: (G) => V, bf: (B) => V): V 
```
    Specified by:
    
    fold in interface Or<G,B>
    
    Type Parameters:
    
    V - the type of the fold's result
    
    Parameters:
    
    good - the function to apply to this Or's Good value, if it is a Good
    
    bad - the function to apply to this Or's Bad value, if it is a Bad
    
    Returns:
    
    the result of applying the appropriate one of the two passed functions, gf or bf, to this Or's value
  - forAll
```
public boolean forAll(Predicate<? super G> predicate)
```
    Description copied from interface: Or
    Returns true if either this Or is a Bad or if the predicate p returns true when applied to this Good's value.
    Note: This method will return the same result as Or.exists(java.util.function.Predicate<? super G>) if this Or is a Good, but the opposite result if this Or is a Bad.
```
Scalactic: def forall(f: (G) => Boolean): Boolean 
```
    Specified by:
    
    forAll in interface Or<G,B>
    
    Parameters:
    
    predicate - the predicate to apply to the Good value, if this is a Good
    
    Returns:
    
    the result of applying the passed predicate p to the Good value, if this is a Good, else true
  - forEach
```
public void forEach(Consumer<? super G> action)
```
    Description copied from interface: Or
    Applies the given function action to the contained value if this Or is a Good; does nothing if this Or is a Bad.
```
Scalactic: def foreach(f: (G) => Unit): Unit 
```
    Specified by:
    
    forEach in interface Or<G,B>
    
    Parameters:
    
    action - the function to apply
  - get
```
public G get()
```
    Description copied from interface: Or
    Returns the Or's value if it is a Good or throws NoSuchElementException if it is a Bad.
```
Scalactic: def get: G 
```
    Specified by:
    
    get in interface Or<G,B>
    
    Returns:
    
    the contained value if this is a Good
  - getBad
```
public B getBad()
```
    Description copied from interface: Or
    
    Returns the Or's value if it is a Bad or throws NoSuchElementException if it is a Good.
    
    Specified by:
    
    getBad in interface Or<G,B>
    
    Returns:
    
    the contained value if this is a Bad
  - getOrElse
```
public G getOrElse(G alt)
```
    Description copied from interface: Or
    Returns, if this Or is Good, this Good's value; otherwise returns default.
```
Scalactic: def getOrElse[H >: G](default: => H): H 
```
    Specified by:
    
    getOrElse in interface Or<G,B>
    
    Parameters:
    
    alt - the default expression to evaluate if this Or is a Bad
    
    Returns:
    
    the contained value, if this Or is a Good, else given default
  - getOrElse
```
public G getOrElse(Function<? super B,? extends G> def)
```
    Description copied from interface: Or
    Returns, if this Or is Good, this Good's value; otherwise returns the result of evaluating default.
```
Scalactic: def getOrElse[H >: G](default: => H): H 
```
    Specified by:
    
    getOrElse in interface Or<G,B>
    
    Parameters:
    
    def - the default expression to evaluate if this Or is a Bad
    
    Returns:
    
    the contained value, if this Or is a Good, else the result of evaluating the given default
  - orElse
```
public Or<G,B> orElse(Supplier<? extends Or<? extends G,? extends B>> alt)
```
    Description copied from interface: Or
    Returns this Or if it is a Good, otherwise returns the result of evaluating the passed alt.
```
Scalactic: def orElse[H >: G, C >: B](alternative: => Or[H, C]): Or[H, C] 
```
    Specified by:
    
    orElse in interface Or<G,B>
    
    Parameters:
    
    alt - the alternative supplier to evaluate if this Or is a Bad
    
    Returns:
    
    this Or, if it is a Good, else the result of evaluating alt
  - orElse
```
public Or<G,B> orElse(Or<? extends G,? extends B> alt)
```
    Description copied from interface: Or
    Returns this Or if it is a Good, otherwise returns the passed alt.
```
Scalactic: def orElse[H >: G, C >: B](alternative: => Or[H, C]): Or[H, C] 
```
    Specified by:
    
    orElse in interface Or<G,B>
    
    Parameters:
    
    alt - the alternative to return if this Or is a Bad
    
    Returns:
    
    this Or, if it is a Good, else the result of evaluating alt
  - recover
```
public Or<G,B> recover(Function<? super B,? extends G> func)
```
    Description copied from interface: Or
    Maps the given function to this Or's value if it is a Bad, transforming it into a Good, or returns this if it is already a Good.
```
Scalactic: def recover[H >: G](f: (B) => H): Or[H, B] 
```
    Specified by:
    
    recover in interface Or<G,B>
    
    Parameters:
    
    func - the function to apply
    
    Returns:
    
    if this is a Bad, the result of applying the given function to the contained value wrapped in a Good, else this Good is returned
  - recoverWith
```
public <C> Or<G,C> recoverWith(Function<? super B,? extends Or<? extends G,? extends C>> func)
```
    Description copied from interface: Or
    Maps the given function to this Or's value if it is a Bad, returning the result, or returns this if it is already a Good.
```
Scalactic: def recoverWith[H >: G, C](f: (B) => Or[H, C]): Or[H, C] 
```
    Specified by:
    
    recoverWith in interface Or<G,B>
    
    Type Parameters:
    
    C - the recovered value of the Bad
    
    Parameters:
    
    func - the function to apply
    
    Returns:
    
    if this is a Bad, the result of applying the given function to the contained value, else this Good is returned
  - swap
```
public Or<B,G> swap()
```
    Description copied from interface: Or
    Returns an Or with the Good and Bad types swapped: Bad becomes Good and Good becomes Bad.
```
Scalactic: def swap: Or[B, G] 
```
    Specified by:
    
    swap in interface Or<G,B>
    
    Returns:
    
    if this Or is a Good, its Good value wrapped in a Bad; if this Or is a Bad, its Bad value wrapped in a Good.
  - toJavaOptional
```
public Optional<G> toJavaOptional()
```
    Description copied from interface: Or
    
    Returns an Optional that is defined if this is a Good and not if this is a Bad.
    
    Specified by:
    
    toJavaOptional in interface Or<G,B>
    
    Returns:
    
    an Optional
  - toOption
```
public Option<G> toOption()
```
    Description copied from interface: Or
    Returns a Option containing the Good value, if this Or is a Good, else none.
```
Scalactic: def toOption: Option[G] 
```
    Specified by:
    
    toOption in interface Or<G,B>
    
    Returns:
    
    the contained “success” value wrapped in an Option.
  - toEither
```
public Either<B,G> toEither()
```
    Description copied from interface: Or
    Returns an Either: a right Either containing the Good value, if this is a Good; a left Either containing the Bad value, if this is a Bad.
    Note that values effectively switch sides when converting an Or to an Either. If the type of the Or on which you invoke this method is Or<Int,ErrorMessage> for example, the result will be an Either<ErrorMessage,Int>. The reason is that the convention for Either is that left Either is used for failure values and right Either is used for success ones.
```
Scalactic: def toEither: Either[B, G] 
```
    Specified by:
    
    toEither in interface Or<G,B>
    
    Returns:
    
    this Good value, wrapped in a right Either, or this Bad value, wrapped in a left Either.
  - isGood
```
public boolean isGood()
```
    Description copied from interface: Or
    Indicates whether this Or is a Good.
```
Scalactic: def isGood: Boolean 
```
    Specified by:
    
    isGood in interface Or<G,B>
    
    Returns:
    
    true if this Or is a Good, false if it is a Bad.
  - isBad
```
public boolean isBad()
```
    Description copied from interface: Or
    Indicates whether this Or is a Bad.
```
Scalactic: def isBad: Boolean 
```
    Specified by:
    
    isBad in interface Or<G,B>
    
    Returns:
    
    true if this Or is a Bad, false if it is a Good.
  - transform
```
public <H,C> Or<H,C> transform(Function<? super G,? extends H> gf,
                               Function<? super B,? extends C> bf)
```
    Description copied from interface: Or
    Transforms this Or by applying the function gf to this Or's Good value if it is a Good, or by applying bf to this Or's Bad value if it is a Bad.
```
Scalactic: def transform[H, C](gf: (G) => Or[H, C], bf: (B) => Or[H, C]): Or[H, C] 
```
    Specified by:
    
    transform in interface Or<G,B>
    
    Type Parameters:
    
    H - the type of the transformed Good
    
    C - the type of the transformed Bad
    
    Parameters:
    
    gf - the function to apply to this Or's Good value, if it is a Good
    
    bf - the function to apply to this Or's Bad value, if it is a Bad
    
    Returns:
    
    the result of applying the appropriate one of the two passed functions, gf or bf, to this Or's value
  - forEach
```
public void forEach(Consumer<? super G> gc,
                    Consumer<? super B> bc)
```
    Description copied from interface: Or
    
    A terminal operation to handle both success and failure cases.
    
    Specified by:
    
    forEach in interface Or<G,B>
    
    Parameters:
    
    gc - a function to be executed if this Or is a Good
    
    bc - a function to be executed if this Or is a Bad
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - filter
```
public Or<G,B> filter(Function<? super G,? extends Validation<? extends B>> validator)
```
    Description copied from interface: Or
    Returns this Or if either 1) it is a Bad or 2) it is a Good and applying the validation function validation to this Good's value returns Pass; otherwise, returns a new Bad containing the error value contained in the Fail resulting from applying the validation function validation to this Good's value.
    For examples of filter used in for expressions, see the main documentation for interface Validation.
```
Scalactic: def filter[C >: B](f: (G) => Validation[C]): Or[G, C] 
```
    Specified by:
    
    filter in interface Or<G,B>
    
    Parameters:
    
    validator - the validation function to apply
    
    Returns:
    
    a Good if this Or is a Good that passes the validation function, else a Bad.
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object

Class Good<G,B>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.github.javactic.Or

Method Detail

of

accumulating

asOr

map

badMap

contains

containsBad

exists

flatMap

fold

forAll

forEach

get

getBad

getOrElse

getOrElse

orElse

orElse

recover

recoverWith

swap

toJavaOptional

toOption

toEither

isGood

isBad

transform

forEach

toString

filter

hashCode

equals