Package ru.progrm_jarvis.javacommons.object

Interface Result<T,E>

Type Parameters:

T - type of successful result

E - type of error result

All Superinterfaces:

Supplier<T>

All Known Implementing Classes:

Result.Error, Result.Success

public interface Result<T,E>
extends Supplier<T>

A tagged union representing either a successful result or an error.

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static final class	Result.Error<T,E>	Representation of an error result.
static final class	Result.Extensions	Extensions for Result providing type-specific specializations which are impossible via generic virtual methods.
static class	Result.NotErrorException	An exception thrown whenever unwrapError() is called on a successful result.
static class	Result.NotSuccessException	An exception thrown whenever unwrap() is called on an error result.
static final class	Result.NullError	Holder of a null-error result.
static final class	Result.NullSuccess	Holder of a null-success result.
static final class	Result.Success<T,E>	Representation of a successful result.

Method Summary

Modifier and Type	Method	Description
<R> @NotNull Result<R,E>	and(@NonNull Result<R,E> nextResult)	Returns the given result if this is a successful result otherwise keeping the error result.
@NotNull Optional<E>	asErrorOptional()	Converts this result into an Optional of its error.
@NotNull Stream<E>	asErrorStream()	Converts this result into a Stream of its error value.
@NotNull ValueContainer<E>	asErrorValueContainer()	Converts this result into a ValueContainer of its error value.
@NotNull Optional<T>	asOptional()	Converts this result into an Optional of its successful value.
@NotNull Stream<T>	asStream()	Converts this result into a Stream of its successful value.
@NotNull ValueContainer<T>	asValueContainer()	Converts this result into a ValueContainer of its successful value.
static <T, E> @NotNull Result<T,E>	error(E error)	Creates a new error result.
E	errorOrComputeDefault(@NonNull Function<? super T,? extends E> defaultErrorFactory)	Gets the value of this result if this is a successful otherwise returning the value computed by applying the given function to the error value.
E	errorOrDefault(E defaultError)	Gets the error of this result if this is an error otherwise returning default value.
default <X extends Throwable> E	errorOrElseSneakyThrow(@NonNull Function<? super T,? extends X> exceptionFactory)	Gets the error of this result throwing X got by using the specified supplier if this is a successful result.
<X extends Throwable> E	errorOrElseThrow(@NonNull Function<? super T,? extends X> exceptionFactory)	Gets the error of this result throwing X got by using the specified supplier if this is a successful result.
E	errorOrGetDefault(@NonNull Supplier<? extends E> defaultErrorSupplier)	Gets the value of this result if this is an error otherwise returning the value got by using the specified supplier.
E	errorOrNull()	Gets the error of this result if this is an error otherwise returning null.
T	expect(@NonNull String message)	Gets the value of this result throwing a Result.NotSuccessException if this is an error result.
E	expectError(String message)	Gets the error of this result throwing a Result.NotErrorException if this is a successful result.
<R> @NotNull Result<R,E>	flatMap(@NonNull Function<? super T,? extends @NotNull Result<R,E>> mapper)	Also known as andThen.
static <T, E> @NotNull Result<T,@Nullable E>	from(@NonNull Optional<? extends T> optional)	Converts the given Optional into a null-error result.
static <T, E> @NotNull Result<T,E>	from(@NonNull Optional<? extends T> optional, @NonNull Supplier<? extends E> errorSupplier)	Converts the given Optional into an error result.
default T	get()
void	handle(@NonNull Consumer<? super T> successConsumer, @NonNull Consumer<? super E> errorConsumer)	Invokes the corresponding function depending on this result's type.
void	ifError(@NonNull Consumer<? super E> errorConsumer)	Invokes the given function if this result is an error result.
void	ifSuccess(@NonNull Consumer<? super T> successConsumer)	Invokes the given function if this result is a successful result.
boolean	isError()	Checks is this result is an error.
boolean	isSuccess()	Checks is this result is successful.
<R> @NotNull Result<R,E>	map(@NonNull Function<? super T,? extends R> mappingFunction)	Maps the result if it is successful returning a new result with the result of mapping otherwise keeping the error result.
<R> @NotNull Result<T,R>	mapError(@NonNull Function<? super E,? extends R> mappingFunction)	Maps the result if it is an error result returning a new result with the result of mapping otherwise keeping the error result.
static <T, @Any E> @NotNull Result<@Nullable T,@NotNull E>	nonNullError(@Any E error)	Creates a new error result if the value is not null.
static <T, @Any E> @NotNull Result<@NotNull T,@Nullable E>	nonNullSuccess(T value)	Creates a new successful result if the value is not null.
static <T, E> @NotNull Result<T,@Nullable E>	nullError()	Creates a new void-error result.
static <T, E> @NotNull Result<@Nullable T,E>	nullSuccess()	Creates a new successful result with null value.
<R> @NotNull Result<T,R>	or(@NonNull Result<T,R> alternateResult)	Returns this result if this is a successful result otherwise returning the given result.
T	orComputeDefault(@NonNull Function<? super E,? extends T> defaultValueFactory)	Gets the value of this result if this is a successful otherwise returning the value computed by applying the given function to the error value.
T	orDefault(T defaultValue)	Gets the value of this result if this is a successful otherwise returning default value.
<R> @NotNull Result<T,R>	orElse(@NonNull Function<? super E,? extends @NotNull Result<T,R>> mapper)	Maps the result if this is an error result returning the result of mapping otherwise keeping the successful result.
default <X extends Throwable> T	orElseSneakyThrow(@NonNull Function<? super E,? extends X> exceptionFactory)	Gets the value of this result throwing X got by using the specified supplier if this is an error result.
<X extends Throwable> T	orElseThrow(@NonNull Function<? super E,? extends X> exceptionFactory)	Gets the value of this result throwing X got by using the specified supplier if this is an error result.
T	orGetDefault(@NonNull Supplier<? extends T> defaultValueSupplier)	Gets the value of this result if this is a successful otherwise returning the value got by using the specified supplier.
T	orNull()	Gets the value of this result if this is a successful otherwise returning null.
@NotNull Result<T,E>	peek(@NonNull Consumer<? super T> consumer)	Consumes the result if it is successful returning the same result.
@NotNull Result<T,E>	peekError(@NonNull Consumer<? super E> consumer)	Consumes the result if it is an error result returning the same result.
static <T, E> @NotNull Result<T,E>	success(T value)	Creates a new successful result.
@NotNull Result<E,T>	swap()	Swaps this result making an error result from a successful result and a successful result from an error result.
static <T> @NotNull Result<T,@NotNull Exception>	tryCall(@NonNull Callable<? extends T> callable)	Creates a result by calling the specified callable.
static <T> @NotNull Result<T,@NotNull Exception>	tryFrom(@NonNull Callable<? extends T> callable)	Deprecated. in favor of tryCall(Callable)
static <T, X extends Throwable> Result<T,@NotNull X>	tryGet(@NonNull ThrowingSupplier<? extends T,? extends X> supplier, @NonNull Class<? super X> throwableType)	Creates a result by getting the value of the specified supplier.
static <T, X extends Throwable> Result<T,@NotNull X>	tryGet(@NonNull ThrowingSupplier<? extends T,? extends X> supplier, @Nullable X @NonNull ... throwableTypeHint)	Creates a result by getting the value of the specified supplier.
static <T> Result<T,@NotNull Throwable>	tryGetCatchAny(@NonNull ThrowingSupplier<? extends T,Throwable> supplier)	Creates a result by getting the value of the specified supplier.
static <X extends Throwable> @NotNull Result<@Nullable Void,@NotNull X>	tryRun(@NonNull ThrowingRunnable<? extends X> runnable, @NonNull Class<? super X> throwableType)	Creates a result by running the specified runnable.
static <X extends Throwable> @NotNull Result<@Nullable Void,@NotNull X>	tryRun(@NonNull ThrowingRunnable<? extends X> runnable, @Nullable X @NonNull ... throwableTypeHint)	Creates a result by running the specified runnable.
static @NotNull Result<@Nullable Void,? extends @NotNull Throwable>	tryRunCatchAny(@NonNull ThrowingRunnable<? extends Throwable> runnable)	Creates a result by running the specified runnable.
T	unwrap()	Gets the value of this result throwing a Result.NotSuccessException if this is an error result.
E	unwrapError()	Gets the error of this result throwing a Result.NotErrorException if this is a successful result.

Method Details

success

@NotNull
static <T,
E> @NotNull Result<T,E> success(T value)

Creates a new successful result.

Type Parameters:

T - type of successful result

E - type of error result

Parameters:

value - value of the successful result

Returns:

created successful result

nullSuccess

@NotNull
static <T,
E> @NotNull Result<@Nullable T,E> nullSuccess()

Creates a new successful result with null value.

Type Parameters:

T - type of successful result

E - type of error result

Returns:

created successful result

error

@NotNull
static <T,
E> @NotNull Result<T,E> error(E error)

Creates a new error result.

Type Parameters:

T - type of successful result

E - type of error result

Parameters:

error - value of the error result

Returns:

created error result

nullError

@NotNull
static <T,
E> @NotNull Result<T,@Nullable E> nullError()

Creates a new void-error result.

Type Parameters:

T - type of successful result

E - type of error result

Returns:

created error result

nonNullSuccess

@NotNull
static <T,
@Any E>
@NotNull Result<@NotNull T,@Nullable E> nonNullSuccess(@Nullable
 T value)

Creates a new successful result if the value is not null.

Type Parameters:

T - type of the successful value

E - any formal type of the error value

Parameters:

value - value which should be non-null to be considered a successful value

Returns:

a successful result if the value is not null or a null error otherwise

nonNullError

@NotNull
static <T,
@Any E>
@NotNull Result<@Nullable T,@NotNull E> nonNullError(@Nullable
 @Any E error)

Creates a new error result if the value is not null.

Type Parameters:

T - any formal type of the successful value

E - type of the error value

Parameters:

error - value which should be non-null to be considered an error value

Returns:

a error result if the value is not null or a null success otherwise

from

@NotNull
static <T,
E> @NotNull Result<T,@Nullable E> from(@NonNull
 @NonNull Optional<? extends T> optional)

Converts the given Optional into a null-error result.

Type Parameters:

T - type of successful result

E - type of error result

Parameters:

optional - optional to be converted into the result

Returns:

successful result if the value Optional.isPresent() in the optional and a null-error result otherwise

See Also:

• alternative with customizable error value

from

@NotNull
static <T,
E> @NotNull Result<T,E> from(@NonNull
 @NonNull Optional<? extends T> optional,
 @NonNull
 @NonNull Supplier<? extends E> errorSupplier)

Converts the given Optional into an error result.

Type Parameters:

T - type of successful result

E - type of error result

Parameters:

optional - optional to be converted into the result

errorSupplier - supplier to create an error if the given Optional is empty

Returns:

successful result if the value Optional.isPresent() in the optional and an error result with an error supplied from error supplier otherwise

See Also:

• alternative with default (i.e. null) error

tryRun

@NotNull
static <X extends Throwable>
@NotNull Result<@Nullable Void,@NotNull X> tryRun(@NonNull
 @NonNull ThrowingRunnable<? extends X> runnable,
 @NonNull
 @NonNull Class<? super X> throwableType)

Creates a result by running the specified runnable.

Type Parameters:

X - type of the thrown throwable

Parameters:

runnable - function whose failure indicates the error result

throwableType - class instance representing the type of the thrown exception

Returns:

successful void-result if the runnable runs unexceptionally or an error result containing the thrown throwable if it is of the expected type

API note

if an unexpected exception is thrown then it will be rethrown

tryRun

@SafeVarargs
@NotNull
static <X extends Throwable>
@NotNull Result<@Nullable Void,@NotNull X> tryRun(@NonNull
 @NonNull ThrowingRunnable<? extends X> runnable,
 @TypeHint @Nullable
 @Nullable X @NonNull ... throwableTypeHint)

Creates a result by running the specified runnable.

Type Parameters:

X - type of the thrown throwable

Parameters:

runnable - function whose failure indicates the error result

throwableTypeHint - array used for throwable type discovery

Returns:

successful void-result if the runnable runs unexceptionally or an error result containing the thrown throwable if it is of the expected type

API note

if an unexpected exception is thrown then it will be rethrown

tryRunCatchAny

@NotNull
static @NotNull Result<@Nullable Void,? extends @NotNull Throwable> tryRunCatchAny(@NonNull
 @NonNull ThrowingRunnable<? extends Throwable> runnable)

Creates a result by running the specified runnable.

Parameters:

runnable - function whose failure indicates the error result

Returns:

successful void-result if the runnable runs unexceptionally or an error result containing the thrown throwable otherwise

tryGet

static <T,
X extends Throwable> Result<T,@NotNull X> tryGet(@NonNull
 @NonNull ThrowingSupplier<? extends T,? extends X> supplier,
 @NonNull
 @NonNull Class<? super X> throwableType)

Creates a result by getting the value of the specified supplier.

Type Parameters:

T - type of the successful result provided by the given supplier

X - type of the thrown throwable

Parameters:

supplier - provider of the result whose failure indicates the error result

throwableType - class instance representing the type of the thrown exception

Returns:

successful result if the supplier provides the value unexceptionally or an error result containing the thrown throwable if it is of the expected type if it is of the expected type

API note

if an unexpected exception is thrown then it will be rethrown

tryGet

@SafeVarargs
static <T,
X extends Throwable> Result<T,@NotNull X> tryGet(@NonNull
 @NonNull ThrowingSupplier<? extends T,? extends X> supplier,
 @TypeHint @Nullable
 @Nullable X @NonNull ... throwableTypeHint)

Creates a result by getting the value of the specified supplier.

Type Parameters:

T - type of the successful result provided by the given supplier

X - type of the thrown throwable

Parameters:

supplier - provider of the result whose failure indicates the error result

throwableTypeHint - array used for throwable type discovery

Returns:

successful result if the supplier provides the value unexceptionally or an error result containing the thrown throwable otherwise if it is of the expected type

API note

if an unexpected exception is thrown then it will be rethrown

tryGetCatchAny

static <T> Result<T,@NotNull Throwable> tryGetCatchAny(@NonNull
 @NonNull ThrowingSupplier<? extends T,Throwable> supplier)

Creates a result by getting the value of the specified supplier.

Type Parameters:

T - type of the successful result value

Parameters:

supplier - provider of the result whose failure indicates the error result

Returns:

successful result if the supplier provides the value unexceptionally or an error result containing the thrown throwable

tryCall

@NotNull
static <T> @NotNull Result<T,@NotNull Exception> tryCall(@NonNull
 @NonNull Callable<? extends T> callable)

Creates a result by calling the specified callable.

Type Parameters:

T - type of the successful result provided by the given supplier

Parameters:

callable - provider of the result whose failure indicates the error result

Returns:

successful result if the callable completes unexceptionally or an error result containing the thrown exception otherwise

tryFrom

@Deprecated
@NotNull
static <T> @NotNull Result<T,@NotNull Exception> tryFrom(@NonNull
 @NonNull Callable<? extends T> callable)

Deprecated.

in favor of tryCall(Callable)

Creates a result by calling the specified callable.

Type Parameters:

T - type of the successful result provided by the given supplier

Parameters:

callable - provider of the result whose failure indicates the error result

Returns:

successful result if the callable completes unexceptionally or an error result containing the thrown exception otherwise

isSuccess

boolean isSuccess()

Checks is this result is successful.

Returns:

true if this is a successful result and false otherwise

isError

boolean isError()

Checks is this result is an error.

Returns:

true if this is an error result and false otherwise

get

default T get()

Specified by:

get in interface Supplier<T>

unwrap

T unwrap()

Gets the value of this result throwing a Result.NotSuccessException if this is an error result.

Returns:

successful value of this result

Throws:

Result.NotSuccessException - if this is an error result

See Also:

• analog with exception message specification
• analog with exception specification
• analog with unchecked exception specification

expect

T expect(@NonNull
 @NonNull String message)

Gets the value of this result throwing a Result.NotSuccessException if this is an error result.

Parameters:

message - message to be specified to Result.NotSuccessException

Returns:

successful value of this result

Throws:

Result.NotSuccessException - if this is an error result

See Also:

• analog with default message
• analog with exception specification
• analog with unchecked exception specification

orElseThrow

<X extends Throwable> T orElseThrow(@NonNull
 @NonNull Function<? super E,? extends X> exceptionFactory)
                             throws X

Gets the value of this result throwing X got by using the specified supplier if this is an error result.

Type Parameters:

X - type of exception thrown if this is an error result

Parameters:

exceptionFactory - factory of a thrown exception consuming the error value of this result

Returns:

successful value of this result

Throws:

X - if this is an error result

See Also:

• NotSuccessException analog
• default message NotSuccessException analog
• unchecked equivalent

orElseSneakyThrow

default <X extends Throwable> T orElseSneakyThrow(@NonNull
 @NonNull Function<? super E,? extends X> exceptionFactory)

Gets the value of this result throwing X got by using the specified supplier if this is an error result. Throws X if this is an error result. This differs from orElseThrow(Function) as this does not declare X as a thrown exception.

Type Parameters:

X - type of exception thrown if this is an error result

Parameters:

exceptionFactory - factory of a thrown exception consuming the error value of this result

Returns:

successful value of this result

See Also:

• NotSuccessException analog
• default message NotSuccessException analog
• checked equivalent

orDefault

T orDefault(T defaultValue)

Gets the value of this result if this is a successful otherwise returning default value.

Parameters:

defaultValue - default value to be returned if this is an error value

Returns:

successful value if this a successful result or defaultValue otherwise

orNull

@Nullable
T orNull()

Gets the value of this result if this is a successful otherwise returning null.

Returns:

successful value if this a successful result or null otherwise

orGetDefault

T orGetDefault(@NonNull
 @NonNull Supplier<? extends T> defaultValueSupplier)

Gets the value of this result if this is a successful otherwise returning the value got by using the specified supplier.

Parameters:

defaultValueSupplier - supplier of the default value to be returned if this is an error value

Returns:

successful value if this a successful result or got default otherwise

orComputeDefault

T orComputeDefault(@NonNull
 @NonNull Function<? super E,? extends T> defaultValueFactory)

Gets the value of this result if this is a successful otherwise returning the value computed by applying the given function to the error value.

Parameters:

defaultValueFactory - factory used for creation of the default value to be returned if this is an error value

Returns:

successful value if this a successful result or the computed default otherwise

unwrapError

E unwrapError()

Gets the error of this result throwing a Result.NotErrorException if this is a successful result.

Returns:

error value of this result

Throws:

Result.NotErrorException - if this is a successful result

See Also:

• analog with exception message specification
• analog with exception specification
• analog with unchecked exception specification

expectError

E expectError(String message)

Gets the error of this result throwing a Result.NotErrorException if this is a successful result.

Parameters:

message - message to be specified to Result.NotErrorException

Returns:

error value of this result

Throws:

Result.NotErrorException - if this is a successful result

See Also:

• analog with default message
• analog with exception specification
• analog with unchecked exception specification

errorOrElseThrow

<X extends Throwable> E errorOrElseThrow(@NonNull
 @NonNull Function<? super T,? extends X> exceptionFactory)
                                  throws X

Gets the error of this result throwing X got by using the specified supplier if this is a successful result.

Type Parameters:

X - type of exception thrown if this is a successful result

Parameters:

exceptionFactory - factory of a thrown exception consuming the successful value of this result

Returns:

error value of this result

Throws:

X - if this is an error result

See Also:

• default message NotErrorException analog
• NotErrorException analog
• unchecked equivalent

errorOrElseSneakyThrow

default <X extends Throwable> E errorOrElseSneakyThrow(@NonNull
 @NonNull Function<? super T,? extends X> exceptionFactory)

Gets the error of this result throwing X got by using the specified supplier if this is a successful result. Throws X if this is an error result. This differs from orElseThrow(Function) as this does not declare X as a thrown exception.

Type Parameters:

X - type of exception thrown if this is a successful result

Parameters:

exceptionFactory - factory of a thrown exception consuming the successful value of this result

Returns:

error value of this result

See Also:

• default message NotErrorException analog
• NotErrorException analog
• checked equivalent

errorOrDefault

E errorOrDefault(E defaultError)

Gets the error of this result if this is an error otherwise returning default value.

Parameters:

defaultError - default value to be returned if this is an successful result

Returns:

error value if this an error result or defaultError otherwise

errorOrNull

@Nullable
E errorOrNull()

Gets the error of this result if this is an error otherwise returning null.

Returns:

error value if this an error result or null otherwise

errorOrGetDefault

E errorOrGetDefault(@NonNull
 @NonNull Supplier<? extends E> defaultErrorSupplier)

Gets the value of this result if this is an error otherwise returning the value got by using the specified supplier.

Parameters:

defaultErrorSupplier - supplier of the default error to be returned if this is a successful value

Returns:

error value if this an error result or got default otherwise

errorOrComputeDefault

E errorOrComputeDefault(@NonNull
 @NonNull Function<? super T,? extends E> defaultErrorFactory)

Gets the value of this result if this is a successful otherwise returning the value computed by applying the given function to the error value.

Parameters:

defaultErrorFactory - factory used for creation of the default error to be returned if this is a successful value

Returns:

successful value if this an error result or the computed default otherwise

ifSuccess

void ifSuccess(@NonNull
 @NonNull Consumer<? super T> successConsumer)

Invokes the given function if this result is a successful result.

Parameters:

successConsumer - consumer accepting the successful value

ifError

void ifError(@NonNull
 @NonNull Consumer<? super E> errorConsumer)

Invokes the given function if this result is an error result.

Parameters:

errorConsumer - consumer accepting the error value

handle

void handle(@NonNull
 @NonNull Consumer<? super T> successConsumer,
 @NonNull
 @NonNull Consumer<? super E> errorConsumer)

Invokes the corresponding function depending on this result's type.

Parameters:

successConsumer - consumer accepting the successful value

errorConsumer - consumer accepting the error value

map

@NotNull
<R> @NotNull Result<R,E> map(@NonNull
 @NonNull Function<? super T,? extends R> mappingFunction)

Maps the result if it is successful returning a new result with the result of mapping otherwise keeping the error result.

Type Parameters:

R - type of the resulting successful value

Parameters:

mappingFunction - function to map the successful result

Returns:

mapped successful result if it was a successful result or an error result if it was an error result

peek

@NotNull
@NotNull Result<T,E> peek(@NonNull
 @NonNull Consumer<? super T> consumer)

Consumes the result if it is successful returning the same result.

Parameters:

consumer - consumer to accept the successful result

Returns:

the same result

mapError

@NotNull
<R> @NotNull Result<T,R> mapError(@NonNull
 @NonNull Function<? super E,? extends R> mappingFunction)

Maps the result if it is an error result returning a new result with the result of mapping otherwise keeping the error result.

Type Parameters:

R - type of the resulting error value

Parameters:

mappingFunction - function to map the error result

Returns:

mapped error result if it was an an error result or a successful result if it was a successful result

peekError

@NotNull
@NotNull Result<T,E> peekError(@NonNull
 @NonNull Consumer<? super E> consumer)

Consumes the result if it is an error result returning the same result.

Parameters:

consumer - consumer to accept the successful result

Returns:

the same result

and

@NotNull
<R> @NotNull Result<R,E> and(@NonNull
 @NonNull Result<R,E> nextResult)

Returns the given result if this is a successful result otherwise keeping the error result.

Type Parameters:

R - type of the resulting successful value

Parameters:

nextResult - result to be returned if this is a successful result

Returns:

nextResult if this is a successful result or this error result otherwise

See Also:

• lazy analog

flatMap

@NotNull
<R> @NotNull Result<R,E> flatMap(@NonNull
 @NonNull Function<? super T,? extends @NotNull Result<R,E>> mapper)

Also known as andThen. Maps the result if this is a successful result returning the result of mapping otherwise keeping the error result.

Type Parameters:

R - type of the resulting successful value

Parameters:

mapper - function to create a new result from current successful one

Returns:

mapped successful result if this was the one or this error result otherwise

See Also:

• non-lazy analog

or

@NotNull
<R> @NotNull Result<T,R> or(@NonNull
 @NonNull Result<T,R> alternateResult)

Returns this result if this is a successful result otherwise returning the given result.

Type Parameters:

R - type of the resulting error value

Parameters:

alternateResult - result to be returned if this is an error result

Returns:

successful result if this is the one or alternateResult otherwise

See Also:

• lazy analog

orElse

@NotNull
<R> @NotNull Result<T,R> orElse(@NonNull
 @NonNull Function<? super E,? extends @NotNull Result<T,R>> mapper)

Maps the result if this is an error result returning the result of mapping otherwise keeping the successful result.

Type Parameters:

R - type of the resulting error value

Parameters:

mapper - function to create a new result from current error one

Returns:

mapped error result if this was the one or this successful result otherwise

See Also:

• non-lazy analog

swap

@NotNull
@NotNull Result<E,T> swap()

Swaps this result making an error result from a successful result and a successful result from an error result.

Returns:

error result if this was a successful result and a successful result if this was an error result

asOptional

@NotNull
@NotNull Optional<T> asOptional()

Converts this result into an Optional of its successful value.

Returns:

optional containing the value if this is a successful result or an empty optional otherwise

asErrorOptional

@NotNull
@NotNull Optional<E> asErrorOptional()

Converts this result into an Optional of its error.

Returns:

optional containing the error if this is an error result or an empty optional otherwise

asValueContainer

@NotNull
@NotNull ValueContainer<T> asValueContainer()

Converts this result into a ValueContainer of its successful value.

Returns:

value container containing the value if this is a successful result or an empty value-container otherwise

asErrorValueContainer

@NotNull
@NotNull ValueContainer<E> asErrorValueContainer()

Converts this result into a ValueContainer of its error value.

Returns:

value container containing the error if this is an error result or an empty value-container otherwise

asStream

@NotNull
@NotNull Stream<T> asStream()

Converts this result into a Stream of its successful value.

Returns:

stream of the value if this is a successful result or an empty stream otherwise

asErrorStream

@NotNull
@NotNull Stream<E> asErrorStream()

Converts this result into a Stream of its error value.

Returns:

stream containing the error if this is an error result or an empty stream otherwise