🥮 mooncakes.io
README

peter-jerry-ye/async/promise does not have a README file

#
AggregateError

source
pub suberror AggregateError Array[Error]

#
Resolver

source
type Resolver[A]

#
Resolver::future

source
fn[A] Resolver::future(self : Resolver[A]) -> T[A]

#
Resolver::reject

source
fn[A] Resolver::reject(self : Resolver[A], err : Error) -> Unit

#
Resolver::resolve

source
fn[A] Resolver::resolve(self : Resolver[A], result : A) -> Unit

#
Resolver::try_complete

source
fn[A] Resolver::try_complete(self : Resolver[A], result : () -> A raise) -> Bool

type T[A]

#
T::await

source
async fn[A] T::await(self : T[A]) -> A

#
T::bind

source
fn[A, B] T::bind(self : T[A], callback : (A) -> T[B]) -> T[B]

#
T::finally

source
fn[A] T::finally(self : T[A], callback : () -> Unit) -> T[A]

#
T::get

source
fn[A] T::get(self : T[A]) -> Result[A, Error]?

#
T::on_failure

source
fn[A] T::on_failure(self : T[A], callback : (Error) -> Unit) -> Unit

#
T::on_success

source
fn[A] T::on_success(self : T[A], callback : (A) -> Unit) -> Unit

#
T::zip

source
fn[A, B] T::zip(self : T[A], that : T[B]) -> T[(A, B)]

#
T::zip_with

source
fn[A, B, C] T::zip_with(self : T[A], that : T[B], f : (A, B) -> C) -> T[C]

#
all

source
fn[A] all(promises : Array[T[A]]) -> T[Array[A]]

#
any

source
fn[A] any(promises : Array[T[A]]) -> T[A]

#
make

source
fn[A] make() -> Resolver[A]

#
reject

source
fn[A] reject(err : Error) -> T[A]

#
resolve

source
fn[A] resolve(a : A) -> T[A]

#
spawn

source
fn[A] spawn(cb : async () -> A) -> T[A]

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io