Represents an asynchronously computed value.
final class Promise<T, E> where T : Sendable, E : ErrorPromises are executed immediately, i.e. is body runs synchronously with the constructor, similar to e.g. JavaScript’s promises, but different from Python/Rust.
Sendable safety: Promises are sendable because they guard their internal state with a mutex.
import Utilsprotocol Sendableprotocol Error : SendableA type representing an error value that can be thrown.
required init(_ value: Result<T, E>) Creates a finished promise.
convenience init(_ value: T) Creates a finished, succeeded promise.
required init(_ thenable: (@escaping (Result<T, E>) -> Void) -> Void) Creates a promise from the given thenable and synchronously begins running it.
func forget() Convenience method for discarding the promise in a method chain. Making this explicit helps preventing accidental race conditions.
func get() async throws -> T Fetches the result asynchronously.
func getOrLogError(file: String = #file, line: Int = #line) async -> T? Fetches the result asynchronously and logs an error if absent.
func listen(_ listener: @escaping (Result<T, E>) -> Void) Listens for the result. Only fires once.
func listenOrLogError(file: String = #file, line: Int = #line, _ listener: @escaping (T) -> Void) Listens for a successful result or logs an error otherwise. Only fires once.
func map<U>(_ transform: @escaping (T) -> U) -> Promise<U, E> where U : Sendable Chains another synchronous computation after this one.
func mapResult<U>(_ transform: @escaping (Result<T, E>) -> Result<U, E>) -> Promise<U, E> where U : Sendable Chains another synchronous computation after this one.
func peekListen(_ listener: @escaping (Result<T, E>) -> Void) -> Self Listens for the result. Only fires once. Returns the promise.
func swallow() -> Promise<Void, E> Voids the result and swallows the error.
func then<U>(_ next: @escaping (T) -> Promise<U, E>) -> Promise<U, E> where U : Sendable Chains another asynchronous computation after this one.
func void() -> Promise<Void, E> Ignores the return value of the promise.
func wait() throws -> T Awaits the promise result synchronously by blocking the current thread. You should make sure to not run this method from the same thread that also fulfills your promise since that might result in a deadlock.
static func catching(_ block: () throws -> T) -> Self Creates a (finished) promise catching the given block.
static func catchingThen(_ block: () throws -> Promise<T, Error>) -> Promise<T, Error> Creates a promise catching the given block returning another promise.
func mapCatching<U>(_ transform: @escaping (T) throws -> U) -> Promise<U, E> where U : Sendable Creates another promise from mapping the current one with a callback that may synchronously throw.
func thenCatching<U>(_ next: @escaping (T) throws -> Promise<U, Error>) -> Promise<U, Error> where U : Sendable Chains another promise with a callback that may synchronously throw.