Package net.tangly.commons.lang.functional

Interface Try<T>

Type Parameters:

T - type of the computed result in the successful case

All Known Implementing Classes:

Try.Failure, Try.Success

public sealed interface Try<T>
permits Try.Success<T>, Try.Failure<T>

Functional programming strives to minimize side effects, so throwing exceptions is avoided. Instead, if an operation can fail, it should return a representation of its outcome including an indication of success or failure, as well as its result (if successful), or some error data otherwise. In other words, errors in functional programming are just payload.

Try should be preferred in functional programming approaches in particular in the context of stream pipelines.

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static final class	Try.Failure<T>
static final class	Try.Success<T>

Method Summary

Modifier and Type	Method	Description
static <T> Try<T>	failure(@NotNull Throwable t)
<U> Try<U>	flatMap(@NotNull Function<? super T,Try<U>> fn)
T	get()
Throwable	getThrown()
default boolean	isFailure()
boolean	isSuccess()
<U> Try<U>	map(@NotNull Function<? super T,? extends U> fn)
static <T> Try<T>	of(@NotNull Supplier<T> fn)
Try<T>	onFailure(@NotNull Consumer<Throwable> consumer)
Try<T>	onSuccess(@NotNull Consumer<T> consumer)
static <V> Try.Success<V>	success(V value)

Method Details

isSuccess

boolean isSuccess()

isFailure

default boolean isFailure()

onSuccess

Try<T> onSuccess(@NotNull
 @NotNull Consumer<T> consumer)

onFailure

Try<T> onFailure(@NotNull
 @NotNull Consumer<Throwable> consumer)

getThrown

Throwable getThrown()

get

T get()
throws Throwable

Throws:

Throwable

map

<U> Try<U> map(@NotNull
 @NotNull Function<? super T,? extends U> fn)

flatMap

<U> Try<U> flatMap(@NotNull
 @NotNull Function<? super T,Try<U>> fn)

failure

static <T> Try<T> failure(@NotNull
 @NotNull Throwable t)

success

static <V> Try.Success<V> success(@NotNull
 V value)

of

static <T> Try<T> of(@NotNull
 @NotNull Supplier<T> fn)