Result<T extends Object, E extends Object> class abstract

Result is a type that represents either success (Ok) or failure (Err).

Result<T, E> is the type used for returning and propagating errors. It is an object with an Ok value, representing success and containing a value, and Err, representing error and containing an error value.

Implementers

Available Extensions

Constructors

Result.err(E err): Create an Err result with the given error.
const

factory
Result.of(T catching()): Call the catching function and produce a Result.
factory
Result.ok(T s): Create an Ok result with the given value.
const

factory

Properties

hashCode → int: The hash code for this object.
no setterinherited
props → List<Object?>: The list of properties that will be used to determine whether two instances are equal.
no setterinherited
runtimeType → Type: A representation of the runtime type of the object.
no setterinherited
stringify → bool?: If set to true, the toString method will be overridden to output this instance's props.
no setterinherited

Methods

and(Result<U, E> res) → Result<U, E>: Returns res if the result is Ok, otherwise returns this.
andThen(Result<U, E> op(T)) → Result<U, E>: Calls op with the Ok value if the result is Ok, otherwise returns this.
andThenAsync(Future<Result<U, E>> op(T)) → Future<Result<U, E>>: Asynchronously calls op with the Ok value if the result is Ok, otherwise returns this.
err() → Option<E>: Converts the Result into an Option containing the error, if any. Otherwise returns None if the result is a value.
expect(String msg) → T: Unwraps a result, yielding the content of an Ok.
expectErr(String msg) → E: Unwraps a result, yielding the content of an Err.
fold(U ok(T), F err(E)) → Result<U, F>: Invoke either the ok or the err function based on the result.
foldAsync(Future ok(T), Future<F> err(E)) → Future<Result<U, F>>: Asynchronously invoke either the ok or the err function based on the result.
isErr() → bool: Returns true if the option is a Err value.
isOk() → bool: Returns true if the option is a Ok value.
map(U op(T)) → Result<U, E>: Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value, leaving an Err value untouched.
mapAsync(Future op(T)) → Future<Result<U, E>>: Maps a Result<T, E> to Result<U, E> by applying an asynchronous function to a contained Ok value, leaving an Err value untouched.
mapErr<F extends Object>(F op(E)) → Result<T, F>: Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value, leaving an Ok value untouched.
mapErrAsync<F extends Object>(Future<F> op(E)) → Future<Result<T, F>>: Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value, leaving an Ok value untouched.
mapOr(U op(T), U opt) → U: Applies a function to the contained value (if any), or returns the provided default (if not).
mapOrAsync(Future op(T), U opt) → Future: Applies an asynchronous function to the contained value (if any), or returns the provided default (if not).
mapOrElse(U op(T), U errOp(E)) → U: Maps a Result<T, E> to U by applying a function to a contained Ok value, or a fallback function to a contained Err value.
mapOrElseAsync(Future op(T), Future errOp(E)) → Future: Maps a Result<T, E> to U by applying a function to a contained Ok value, or a fallback function to a contained Err value.
match<R>(R okop(T), R errop(E)) → R: Invokes either the okop or the errop depending on the result.
matchAsync<R>(Future<R> okop(T), Future<R> errop(E)) → Future<R>: Asynchronously invokes either the okop or the errop depending on the result.
noSuchMethod(Invocation invocation) → dynamic: Invoked when a nonexistent method or property is accessed.
inherited
ok() → Option<T>: Converts the Result into an Option containing the value, if any. Otherwise returns None if the result is an error.
or<F extends Object>(Result<T, F> res) → Result<T, F>: Returns res if the result is an Err, otherwise returns this.
orElse<F extends Object>(Result<T, F> op(E)) → Result<T, F>: Calls op with the Err value if the result is Err, otherwise returns this.
orElseAsync<F extends Object>(Future<Result<T, F>> op(E)) → Future<Result<T, F>>: Calls op with the Err value if the result is Err, otherwise returns this.
toString() → String: A string representation of this object.
inherited
unwrap() → T: Unwraps a result, yielding the content of an Ok.
unwrapErr() → E: Unwraps a result, yielding the content of an Err.
unwrapOr(T opt) → T: Unwraps a result, yielding the content of an Ok. Else, it returns opt.
unwrapOrElse(T op(E)) → T: Unwraps a result, yielding the content of an Ok. If the value is an Err then it calls op with its value.
unwrapOrElseAsync(Future<T> op(E)) → Future<T>: Unwraps a result, yielding the content of an Ok. If the value is an Err then it asynchronously calls op with its value.
when<R>({required R ok(T), required R err(E)}) → R: Invokes either ok or err depending on the result.
whenAsync<R>({required Future<R> ok(T), required Future<R> err(E)}) → Future<R>: Asynchronously invokes either ok or err depending on the result.

Operators

operator ==(Object other) → bool: The equality operator.
inherited

Static Methods

asyncOf<T extends Object, E extends Object>(Future<T> catching()) → Future<Result<T, E>>: Call the catching function and produce a Future<Result<T, E>>.