Resolvable<T extends Object> class sealed

A Monad that represents a value which can be resolved either synchronously Sync or asynchronously Async.

The value of a Sync is never a Future while the value of an Async is always a Future.

Inheritance

Object
Monad<T>
Resolvable

Available extensions

Constructors

Resolvable.new(@mustBeAnonymous @mustAwaitAllFutures FutureOr<T> mustAwaitAllFutures(), {@noFutures TOnErrorCallback<T>? onError, @noFutures TVoidCallback? onFinalize}): Creates a Sync or Async depending on the return type of mustAwaitAllFutures.
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
value → FutureOr<Result<T>>: no setteroverride

Methods

asResolvable() → Resolvable<T>: Returns this as a base Resolvable type.
async() → Result<Async<T>>: Safely gets the Async instance. Returns an Ok on Async, or an Err on Sync.
asyncOr(Resolvable<T> other) → Resolvable<T>: Returns this if it's Async, otherwise returns other.
end() → FutureOr<void>: Suppresses the linter error must_use_monad.
inherited
err() → FutureOr<Option<Err<T>>>: Safely gets the Err instance, resolving any Future.
errOr(Resolvable<T> other) → Resolvable<T>: Returns this if it contains an Err, otherwise returns other.
flatten() → Resolvable<T>: Available on Resolvable<Result<T>>, provided by the FlattenResolvableResultExt2 extension
flatten() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>>, provided by the FlattenResolvableExt6 extension
flatten() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<Result<Result<Result<Result<T>>>>>>>>>, provided by the FlattenResolvableResulteExt9 extension
flatten() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<Result<Result<Result<T>>>>>>>>, provided by the FlattenResolvableResulteExt8 extension
flatten() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>>>>>, provided by the FlattenResolvableExt9 extension
flatten() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<Result<Result<T>>>>>>>, provided by the FlattenResolvableResulteExt7 extension
flatten() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<Result<T>>>>>>, provided by the FlattenResolvableResulteExt6 extension
flatten() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<T>>>>>, provided by the FlattenResolvableResulteExt5 extension
flatten() → Resolvable<T>: Available on Resolvable<Result<Result<Result<T>>>>, provided by the FlattenResolvableResulteExt4 extension
flatten() → Resolvable<T>: Available on Resolvable<Result<Result<T>>>, provided by the FlattenResolvableResulteExt3 extension
flatten() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>>>>, provided by the FlattenResolvableExt8 extension
flatten() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>>>, provided by the FlattenResolvableExt7 extension
flatten() → Resolvable<T>: Available on Resolvable<Resolvable<T>>, provided by the FlattenResolvableExt2 extension
flatten() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<T>>>, provided by the FlattenResolvableExt3 extension
flatten() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<T>>>>, provided by the FlattenResolvableExt4 extension
flatten() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>, provided by the FlattenResolvableExt5 extension
flatten2() → Resolvable<T>: Available on Resolvable<Result<T>>, provided by the FlattenResolvableResultExt2 extension
flatten2() → Resolvable<T>: Available on Resolvable<Resolvable<T>>, provided by the FlattenResolvableExt2 extension
flatten3() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<T>>>, provided by the FlattenResolvableExt3 extension
flatten3() → Resolvable<T>: Available on Resolvable<Result<Result<T>>>, provided by the FlattenResolvableResulteExt3 extension
flatten4() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<T>>>>, provided by the FlattenResolvableExt4 extension
flatten4() → Resolvable<T>: Available on Resolvable<Result<Result<Result<T>>>>, provided by the FlattenResolvableResulteExt4 extension
flatten5() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<T>>>>>, provided by the FlattenResolvableResulteExt5 extension
flatten5() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>, provided by the FlattenResolvableExt5 extension
flatten6() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>>, provided by the FlattenResolvableExt6 extension
flatten6() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<Result<T>>>>>>, provided by the FlattenResolvableResulteExt6 extension
flatten7() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>>>, provided by the FlattenResolvableExt7 extension
flatten7() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<Result<Result<T>>>>>>>, provided by the FlattenResolvableResulteExt7 extension
flatten8() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>>>>, provided by the FlattenResolvableExt8 extension
flatten8() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<Result<Result<Result<T>>>>>>>>, provided by the FlattenResolvableResulteExt8 extension
flatten9() → Resolvable<T>: Available on Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<Resolvable<T>>>>>>>>>, provided by the FlattenResolvableExt9 extension
flatten9() → Resolvable<T>: Available on Resolvable<Result<Result<Result<Result<Result<Result<Result<Result<T>>>>>>>>>, provided by the FlattenResolvableResulteExt9 extension
fold(Resolvable<Object>? onSync(Sync<T> sync), Resolvable<Object>? onAsync(Async<T> async)) → Resolvable<Object>: Handles Sync and Async cases to produce a new Resolvable.
foldResult(Result<Object>? onOk(Ok<T> ok), Result<Object>? onErr(Err<T> err)) → Resolvable<Object>: Exhaustively handles the inner Ok and Err cases, returning a new Resolvable.
ifAsync(void noFutures(Resolvable<T> self, Async<T> async)) → Resolvable<T>: Performs a side-effect if this is Async.
ifErr(void noFutures(Resolvable<T> self, Err<T> err)) → Resolvable<T>: Performs a side-effect if this is Err.
ifOk(void noFutures(Resolvable<T> self, Ok<T> ok)) → Resolvable<T>: Performs a side-effect if this is Ok.
ifSync(void noFutures(Resolvable<T> self, Sync<T> sync)) → Resolvable<T>: Performs a side-effect if this is Sync.
isAsync() → bool: Returns true if this is an Async instance.
isSync() → bool: Returns true if this is a Sync instance.
map<R extends Object>(R noFutures(T value)) → Resolvable<R>: Prefer using then for Resolvable.
override
map10<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Monad<Monad<Monad<Monad<Monad<Monad<Monad<Monad<Object>>>>>>>>>>, provided by the MapMonadExt10 extension
map2<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Object>>, provided by the MapMonadExt2 extension
map3<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Monad<Object>>>, provided by the MapMonadExt3 extension
map4<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Monad<Monad<Object>>>>, provided by the MapMonadExt4 extension
map5<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Monad<Monad<Monad<Object>>>>>, provided by the MapMonadExt5 extension
map6<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Monad<Monad<Monad<Monad<Object>>>>>>, provided by the MapMonadExt6 extension
map7<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Monad<Monad<Monad<Monad<Monad<Object>>>>>>>, provided by the MapMonadExt7 extension
map8<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Monad<Monad<Monad<Monad<Monad<Monad<Object>>>>>>>>, provided by the MapMonadExt8 extension
map9<R extends Object>(R mapper(T)) → TResolvableOption<Object>: Available on Monad<Monad<Monad<Monad<Monad<Monad<Monad<Monad<Monad<Object>>>>>>>>>, provided by the MapMonadExt9 extension
mapFutureOr<R extends Object>(FutureOr<R> mapper(T value)) → Resolvable<R>: Maps the contained Ok value using a function that returns a FutureOr.
noSuchMethod(Invocation invocation) → dynamic: Invoked when a nonexistent method or property is accessed.
inherited
ok() → FutureOr<Option<Ok<T>>>: Safely gets the Ok instance, resolving any Future.
okOr(Resolvable<T> other) → Resolvable<T>: Returns this if it contains an Ok, otherwise returns other.
orNull() → Future<T?>: Returns the contained Ok value or null, resolving any Future.
raw({required FutureOr<Object> onErr(Err<Object> err), required FutureOr<Object> onNone()}) → FutureOr<Object>: The low-level primitive for reducing a Monad chain. It recursively unwraps all Monad layers to return the innermost raw value, forcing the caller to handle terminal states via callbacks.
inherited
rawAsync() → Async<Object>: Reduces any Monad chain to a single Async.
inherited
rawSync() → Sync<Object>: Safely reduces any Monad chain to a single Sync.
inherited
reduce<R extends Object>() → TResolvableOption<R>: Reduces any nested Monad structure into a single TResolvableOption.
inherited
resultMap<R extends Object>(Result<R> noFutures(Result<T> value)) → Resolvable<R>: Maps the inner Result of this Resolvable using mapper.
swap() → None<Resolvable<T>>: Available on Resolvable<None<T>>, provided by the SwapResolvableNoneExt extension
swap() → Ok<Resolvable<T>>: Available on Resolvable<Ok<T>>, provided by the SwapResolvableOkExt extension
swap() → Some<Resolvable<T>>: Available on Resolvable<Some<T>>, provided by the SwapResolvableSomeExt extension
sync() → Result<Sync<T>>: Safely gets the Sync instance. Returns an Ok on Sync, or an Err on Async.
syncOr(Resolvable<T> other) → Resolvable<T>: Returns this if it's Sync, otherwise returns other.
then<R extends Object>(R noFutures(T value)) → Resolvable<R>
toAsync() → Async<T>: Converts this Resolvable to an Async.
toString() → String: A string representation of this object.
inherited
toUnit() → Monad<Unit>: Available on Monad<Object>, provided by the ToUnitOnObjectMonad extension
toUnit() → Resolvable<Unit>: Available on Resolvable<Object>, provided by the ToUnitOnObjectResolvable extension
toVoid() → Monad<void>: Available on Monad<T>, provided by the ToVoidOnMonadExt extension
toVoid() → Resolvable<void>: Available on Resolvable<T>, provided by the ToVoidOnResolvableExt extension
transf<R extends Object>([R noFutures(T e)?]) → Resolvable<R>: Transforms the Monad's generic type from T to R.
override
unwrap() → FutureOr<T>: Strongly discouraged: Unsafely returns the contained value.
override
unwrapAsync() → Future<T>: Available on Resolvable<Option<T>>, provided by the ResolvableOptionExt extension
unwrapOr(T fallback) → FutureOr<T>: Returns the contained value, or the fallback if the Monad is in an Err or None state.
override
unwrapSync() → T: Available on Resolvable<Option<T>>, provided by the ResolvableOptionExt extension
whenComplete<R extends Object>(Resolvable<R> noFutures(Sync<T> resolved)) → Resolvable<R>
withMinDuration(Duration? duration) → Resolvable<T>: Ensures that resolving this value takes at least a specified duration. If duration is null, this method returns the original value immediately.
wrapInAsync() → Async<M>: Available on M, provided by the WrapOnMonadExt extension
wrapInOk() → Ok<M>: Available on M, provided by the WrapOnMonadExt extension
wrapInResolvable() → Resolvable<M>: Available on M, provided by the WrapOnMonadExt extension
wrapInSome() → Some<M>: Available on M, provided by the WrapOnMonadExt extension
wrapInSync() → Sync<M>: Available on M, provided by the WrapOnMonadExt extension
wrapValueInAsync() → Monad<Async<T>>: Available on M, provided by the WrapOnMonadExt extension
wrapValueInAsync() → Resolvable<Async<T>>: Available on Resolvable<T>, provided by the WrapOnResolvableExt extension
wrapValueInOk() → Monad<Ok<T>>: Available on M, provided by the WrapOnMonadExt extension
wrapValueInOk() → Resolvable<Ok<T>>: Available on Resolvable<T>, provided by the WrapOnResolvableExt extension
wrapValueInResolvable() → Monad<Resolvable<T>>: Available on M, provided by the WrapOnMonadExt extension
wrapValueInResolvable() → Resolvable<Resolvable<T>>: Available on Resolvable<T>, provided by the WrapOnResolvableExt extension
wrapValueInSome() → Monad<Some<T>>: Available on M, provided by the WrapOnMonadExt extension
wrapValueInSome() → Resolvable<Some<T>>: Available on Resolvable<T>, provided by the WrapOnResolvableExt extension
wrapValueInSync() → Monad<Sync<T>>: Available on M, provided by the WrapOnMonadExt extension
wrapValueInSync() → Resolvable<Sync<T>>: Available on Resolvable<T>, provided by the WrapOnResolvableExt extension

Operators

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

Static Methods

combine2<T1 extends Object, T2 extends Object>(Resolvable<T1> r1, Resolvable<T2> r2, [Err<(T1, T2)> onErr(Result<T1>, Result<T2>)?]) → Resolvable<(T1, T2)>: Combines 2 Resolvable monads into 1 containing a tuple of their values if all resolve to Ok.
combine3<T1 extends Object, T2 extends Object, T3 extends Object>(Resolvable<T1> r1, Resolvable<T2> r2, Resolvable<T3> r3, [Err<(T1, T2, T3)> onErr(Result<T1>, Result<T2>, Result<T3>)?]) → Resolvable<(T1, T2, T3)>: Combines 3 Resolvable monads into 1 containing a tuple of their values if all resolve to Ok.