Result<S, F extends Object> class sealed

Result class representing the type union between Ok and Err.

S is the ok type (aka success) and F is an error (aka failure). Aims to implements at minimum, through methods or extensions, the Rust Result specification here: https://doc .rust-lang .org/std/result/enum.Result.html

Implementers

• Err
• Ok

Available extensions

• AnyhowResultExtensions
• BaseResultExtension
• FlattenExtension
• InfallibleErrExtension
• InfallibleOkExtension
• ResultFutureToFutureResultExtension
• ResultToFutureResultExtension
• TransposeResultExtension

Properties

hashCode → int

The hash code for this object.

no setter, inherited

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

Methods

and<S2>(Result<S2, F> other) → Result<S2, F>

Performs an "and" operation on the results. Returns the first result that is Err, otherwise if both are Ok, other Ok Result is returned.

andThen<W>(Result<W, F> fn(S ok)) → Result<W, F>

If Ok, Returns a new Result by passing the Ok value to the provided function.

andThenErr<W extends Object>(Result<S, W> fn(F error)) → Result<S, W>

/ If Err, Returns a new Result by passing the Err value to the provided function.

copy() → Result<S, F>

Performs a shallow copy of this result.

expect(String message) → S

Returns the ok value if Result is Ok. Throws a Panic if the Result is Err, with the provided message.

expectErr(String message) → F

Returns the err value if Result is Err. Throws a Panic if the Result is Ok, with the provided message.

inspect(void fn(S ok)) → Result<S, F>

If Ok, Calls the provided closure with the ok value, else does nothing.

inspectErr(void fn(F error)) → Result<S, F>

If Err, Calls the provided closure with the err value, else does nothing.

intoUnchecked<S2>() → Result<S2, F>

Changes the Ok type to S2. See into for a safe implementation of intoUnchecked. This is usually used when "this" is known to be an Err and you want to return to the calling function, but the returning function's Ok type is different from this Ok type.

isErr() → bool

Returns true if the current result is an Err.

isErrAnd(bool fn(F)) → bool

Returns true if the result is Err and the value inside of it matches a predicate.

isOk() → bool

Returns true if the current result is a Ok.

isOkAnd(bool fn(S)) → bool

Returns true if the result is Ok and the value inside of it matches a predicate.

iter() → Iterable<S>

Returns an iterable over the possibly contained value. The iterator yields one value if the result is Ok, otherwise none.

map<W>(W fn(S ok)) → Result<W, F>

Returns a new Result, mapping any Ok value using the given transformation.

mapErr<W extends Object>(W fn(F error)) → Result<S, W>

Returns a new Result, mapping any Err value using the given transformation.

mapOr<W>(W defaultValue, W fn(S ok)) → W

Returns the provided default (if Err), or applies a function to the contained value (if Ok).

mapOrElse<W>(W defaultFn(F err), W fn(S ok)) → W

Evaluates the provided defaultFn (if Err), or applies a function to the contained value (if Ok).

match<W>({required W ok(S), required W err(F)}) → W

Returns the result of ok for the encapsulated value if this instance represents Ok or the result of err function for the encapsulated value if it is Err.

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

or<F2 extends Object>(Result<S, F2> other) → Result<S, F2>

Performs an "or" operation on the results. Returns the first Ok value, if neither are Ok, returns the other Err.

orElse<F2 extends Object>(Result<S, F2> fn(F)) → Result<S, F2>

Calls fn if the result is Err, otherwise returns the Ok value of this.

toString() → String

A string representation of this object.

inherited

unwrap() → S

Returns the ok value if Result is Ok. Throws a Panic if the Result is Err.

unwrapErr() → F

Returns the err value if Result is Err. Throws a Panic if the Result is Ok.

unwrapErrOr(F defaultValue) → F

Returns the encapsulated value if this instance represents Err or the defaultValue if it is Ok.

unwrapErrOrElse(F onOk(S ok)) → F

Returns the encapsulated value if this instance represents Err or the result of onError function for the encapsulated a Err value.

unwrapErrOrNull() → F?

Returns the err value if Result is Err, otherwise returns null. This can be used to determine is Ok or is Err, since when the failure type is not nullable, so a returned null value means this is not an Err. Same as "err()" in Rust, but "err" is a field name here

unwrapOr(S defaultValue) → S

Returns the encapsulated value if this instance represents Ok or the defaultValue if it is Err. Note: This should not be used to determine is Ok or is Err, since when the success type is nullable, a default value of null can be provided, which is ambiguous in meaning.

unwrapOrElse(S onError(F error)) → S

Returns the encapsulated value if this instance represents Ok or the result of onError function for the encapsulated a Err value. Note: This should not be used to determine is Ok or is Err, since when the success type is nullable, the value returned can be null, which is ambiguous in meaning.

unwrapOrNull() → S?

Returns the value of Ok or null. Note: This should not be used to determine is Ok or is Err, since when the success type is nullable, a null is ambiguous in meaning.

Operators

operator ==(Object other) → bool

The equality operator.

inherited