gossamer - v9.2.0

gossamer/promise

Types

Promise

</>

A proxy for a value that may not be known when the promise is created.

See Promise on MDN.

pub type Promise(a)

PromiseSettledResult

</> 
pub type PromiseSettledResult(a) {
  Fulfilled(value: a)
  Rejected(reason: dynamic.Dynamic)
}

Constructors

PromiseWithResolvers

</> 
pub type PromiseWithResolvers(a, r) {
  PromiseWithResolvers(
    promise: Promise(Result(a, js_error.JsError)),
    resolve: fn(a) -> Nil,
    reject: fn(r) -> Nil,
  )
}

Constructors 

  • PromiseWithResolvers(
  promise: Promise(Result(a, js_error.JsError)),
  resolve: fn(a) -> Nil,
  reject: fn(r) -> Nil,
)

Values

all

</> 
pub fn all(
  values: List(Promise(a)),
) -> Promise(Result(List(a), js_error.JsError))

Resolves with a list of the fulfilled values when all provided promises fulfill, or rejects as soon as any promise rejects.

all_settled

</> 
pub fn all_settled(
  values: List(Promise(a)),
) -> Promise(List(PromiseSettledResult(a)))

Resolves with a list of PromiseSettledResults when all provided promises have settled (resolved or rejected), never short-circuiting on rejection.

any

</> 
pub fn any(
  values: List(Promise(a)),
) -> Promise(Result(a, js_error.JsError))

Resolves with the first fulfilled promise’s value. Rejects only if all provided promises reject.

catch

</> 
pub fn catch(
  promise: Promise(a),
  apply onrejected: fn(dynamic.Dynamic) -> a,
) -> Promise(a)

Chains onrejected to run if promise rejects. The returned promise resolves with the callback’s return value.

finally

</> 
pub fn finally(
  promise: Promise(a),
  run onfinally: fn() -> b,
) -> Promise(a)

Chains onfinally to run after promise settles (either fulfills or rejects), without affecting the resolved value.

from_option

</> 
pub fn from_option(option: option.Option(a)) -> Promise(a)

Converts an Option into a promise. Some becomes resolved; None becomes rejected with Nil.

from_result

</> 
pub fn from_result(result: Result(a, r)) -> Promise(a)

Converts a Result into a promise. Ok becomes resolved; Error becomes rejected.

new

</> 
pub fn new(
  executor: fn(fn(a) -> b, fn(r) -> c) -> d,
) -> Promise(Result(a, js_error.JsError))

Creates a new Promise by running executor. executor receives resolve and reject callbacks; calling resolve fulfills the promise, calling reject (or throwing) rejects it.

race

</> 
pub fn race(
  values: List(Promise(a)),
) -> Promise(Result(a, js_error.JsError))

Resolves or rejects as soon as any of the provided promises resolves or rejects, taking on that promise’s value.

reject

</> 
pub fn reject(reason: r) -> Promise(a)

Creates a promise already rejected with reason.

resolve

</> 
pub fn resolve(value: a) -> Promise(a)

Creates a promise already fulfilled with value.

then

</> 
pub fn then(
  promise: Promise(a),
  apply onfulfilled: fn(a) -> b,
) -> Promise(b)

Chains onfulfilled to run after promise fulfills. The returned promise resolves with the callback’s return value.

try

</> 
pub fn try(
  func: fn() -> a,
) -> Promise(Result(a, js_error.JsError))

Runs func and wraps the result in a promise. The returned promise resolves with the function’s return value or rejects if it throws or returns a rejecting promise.

with_resolvers

</> 
pub fn with_resolvers() -> PromiseWithResolvers(a, r)

Creates a promise along with resolve and reject callbacks that can settle it from outside. Useful when the settling logic isn’t known at construction time.

✨ Search Document