class Promise(T)

Defined in:

promise.cr

Constructors

Class Method Summary

Instance Method Summary

Constructor Detail

def self.new(&block : T -> Nil, String | Exception -> Nil -> _) #

The Promise(T).new(&block : (T -> Nil), (String | Exception -> Nil) -> _) method Creates a new Promise with procs for how to resolve and how to reject the promise.

NOTE: Raised exceptions will also trigger a reject.


[View source]

Class Method Detail

def self.all(promises : Array(Promise(T | Nil))) #

The Promise(T).all(promises : Array(Promise(T | Nil)) method returns a promise that resolves when all of the promises in the iterable argument have resolved, or rejects with the reason of the first passed promise that rejects.


[View source]
def self.execute(&block : -> T) #

The Promise(T).execute(&block : -> T) method returns a Promise object that is resolved by the return value of the block.


[View source]
def self.race(promises : Array(Promise(T | Nil))) #

The Promise.race(promises : Array(Promise(T | Nil)) method returns a Promise that is settled the same way as the first passed promise to settle. It resolves or rejects, whichever happens first.


[View source]
def self.reject(message : String) #

The Promise(T).reject(message : String) method returns a Promise object that is rejected with the given reason.

Rejects with a string message


[View source]
def self.reject(ex : Exception) #

The Promise(T).reject(ex : Exception) method returns a Promise object that is rejected with the given reason.

Rejects with an exception.


[View source]
def self.resolve(value : T) #

The Promise(T).resolve(value : T) method returns a Promise.then object that is resolved with the given value.


[View source]

Instance Method Detail

def await #

The #await method will block until the chain before the specified wait has finished it's operations, then returns the last value.

NOTE: This is typically used to prevent the application from terminating before the operations are complete, this may not be required if you have something else handling the process.


[View source]
def catch(&block : Exception -> _) #

The catch(&block : Exception -> _) method specifies an operation to complete after the previous operation has been rejected.

NOTE: Using a catch will allow the continuation of the chain after the catch.


[View source]
def pending? #

The #pending? method will return true if the Promise is pending.


[View source]
def rejected? #

The #rejected? method will return true if the Promise is rejected.


[View source]
def resolved? #

The #resolved? method will return true if the Promise is resolved.


[View source]
def state #

The #state method will return the current state of the Promise.


[View source]
def then(&block : T -> _) #

The then(&block : T -> _) method Specifies an operation to complete after the previous operation has been resolved.


[View source]