Sign in

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

    AggregateError

    pub suberror AggregateError Array[Error]

    Resolver

    type Resolver[A]

    Resolver::future

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

    Resolver::reject

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

    Resolver::resolve

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

    Resolver::try_complete

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

    type T[A]

    T::await

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

    T::bind

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

    T::finally

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

    T::get

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

    T::on_failure

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

    T::on_success

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

    T::zip

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

    T::zip_with

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

    all

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

    any

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

    make

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

    reject

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

    resolve

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

    spawn

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

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io