co.unruly.control.result

Class Result<S,F>

java.lang.Object

co.unruly.control.result.Result<S,F>

Type Parameters:

S - The type of a success

F - The type of a failure

All Implemented Interfaces:

Serializable

public abstract class Result<S,F>
extends Object
implements Serializable

Represents the result of an operation which could fail, represented as either a Success (wrapping the successful output) or a Failure (wrapping a value describing how it failed).

The interface for Result is minimal: many common sample operations are implemented with static methods on Introducers, Transformers, and Resolvers. These can be composed upon a Result by passing them as arguments to then().

See Also:

Serialized Form

Method Summary

Modifier and Type	Method and Description
abstract <R,R1 extends R,R2 extends R> R	either(Function<S,R1> onSuccess, Function<F,R2> onFailure) Takes two functions, the first of which is executed in the case that this Result is a Success, the second of which is executed in the case that it is a Failure, on the wrapped value in either case.
static <S,F> Result<S,F>	failure(F error) Creates a new Failure
static <S,F> Result<S,F>	failure(F error, Class<S> successType) Creates a new Failure, taking the success type for contexts where it can't be inferred.
static <S,F> Result<S,F>	success(S value) Creates a new Success
static <S,F> Result<S,F>	success(S value, Class<F> failureType) Creates a new Success, taking the failure type for contexts where it can't be inferred.
<T,T2 extends T> T	then(Function<Result<S,F>,T2> biMapper) Applies a function to this Result.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

success

public static <S,F> Result<S,F> success(S value)

Creates a new Success

success

public static <S,F> Result<S,F> success(S value,
                                        Class<F> failureType)

Creates a new Success, taking the failure type for contexts where it can't be inferred.

failure

public static <S,F> Result<S,F> failure(F error)

Creates a new Failure

failure

public static <S,F> Result<S,F> failure(F error,
                                        Class<S> successType)

Creates a new Failure, taking the success type for contexts where it can't be inferred.

either

public abstract <R,R1 extends R,R2 extends R> R either(Function<S,R1> onSuccess,
                                                       Function<F,R2> onFailure)

Takes two functions, the first of which is executed in the case that this Result is a Success, the second of which is executed in the case that it is a Failure, on the wrapped value in either case.

Type Parameters:

R - the type of the end result

Parameters:

onSuccess - the function to process the success value, if this is a Success

onFailure - the function to process the failure value, if this is a Failure

Returns:

The result of executing onSuccess if this result is a Success, or onFailure if it's a failure

then

public <T,T2 extends T> T then(Function<Result<S,F>,T2> biMapper)

Applies a function to this Result. This permits inverting the calling convention, so that instead of the following:

 
 Result<Shop, String> shop;
 Result<Hat, String> hat = map(shop, Shop::purchaseHat);
 
 

We can write:

 
 Result<Shop, String> shop;
 Result<Hat, String> hat = shop.then(map(Shop::purchaseHat));
 
 

The advantage of this is that it composes more nicely: instead of this:

 
 Result<Town, String> town;
 Result<Hat, String> hat = map(map(shop, Town::findHatShop), Shop::purchaseHat);
 
 

We can write: *

 
 Result<Town, String> town;
 Result<Hat, String> hat = town.then(map(Town::findHatShop)
                               .then(map(Shop::purchaseHat));