google/promises
Promises
This project is a promise-based concurrency framework and asynchronous task library for Swift and Objective-C. It functions as a workflow orchestrator that uses monadic transformations to chain operations and propagate results through a state machine.
The library specializes in transforming traditional completion-handler APIs into promise-based structures to enable sequential execution. It provides mechanisms for coordinating simultaneous background processes, including the ability to aggregate results from multiple tasks or synchronize operations through racing and waiting.
The framework covers comprehensive asynchronous workflow management, including pipeline chaining and concurrency control. It includes fault-tolerance primitives for error interception, automated retry logic, and recovery fallbacks, as well as utilities for execution timeouts and result validation.
The project also provides tools for synchronous testing by blocking execution until pending promises resolve to facilitate deterministic assertions in unit tests.
Features
- Asynchronous Workflow Orchestrators - Functions as a workflow orchestrator for coordinating simultaneous background processes and aggregating results with thread-safe synchronization.
- Swift Task Libraries - Provides low-level primitives for managing complex asynchronous workflows and promise-based task chaining specifically for Swift and Objective-C.
- Monadic Pipelines - Implements sequential chaining of asynchronous computations where the output of one task serves as the input to the next.
- Asynchronous Operation Chaining - Sequences multiple asynchronous tasks in a pipeline where each operation feeds its output into the next.
- Asynchronous Task Orchestration - Provides utilities for managing complex background operations and controlling execution flow to maintain application responsiveness.
- Error Recovery - Intercepts failures in background task chains to provide recovery via fallback values or automated retries.
- Future-Based Concurrency Frameworks - Provides a concurrency framework that uses futures and promises to simplify complex asynchronous logic and result propagation.
- Task Result Aggregation - Provides mechanisms to gather outputs and errors from multiple simultaneous asynchronous tasks into a single unified result.
- Callback-to-Promise Converters - Transforms traditional completion-handler patterns into promise objects to enable sequential asynchronous execution.
- Fallback Handlers - Provides fallback handlers that return a default value if an asynchronous operation fails, keeping the chain active.
- Asynchronous Operation Retries - Implements automated retry logic to reattempt rejected operations multiple times using specified delays.
- Result Aggregators - Provides mechanisms for coordinating simultaneous background processes by aggregating results from multiple asynchronous tasks.
- Async Task Timeouts - Automatically rejects a task if it fails to resolve within a specified time limit to prevent hanging operations.
- Promise-Based API Wrappers - Offers wrappers that convert traditional asynchronous completion-handler APIs into standardized promise-based interfaces.
- Error Interception Handlers - Provides programmable handlers that intercept errors in a promise chain to perform cleanup or report failures.
- Async Task Wrappers - Allows wrapping blocks of work to resolve with a value or error on a specified execution queue.
- Dispatch Queues - Offloads asynchronous work to system-managed dispatch queues to prevent blocking the main application thread.
- Promise Lifecycle State Machines - Tracks the internal transition of asynchronous tasks through distinct states to ensure consistent result propagation.
- Parallel Task Synchronization - Manages complex synchronization by racing multiple operations or waiting for all parallel tasks to complete.
- Thread-Safe State Synchronization - Uses synchronization primitives to maintain data consistency when updating task results across concurrent execution threads.
- Type-Safe Container Wrapping - Wraps asynchronous values in generic containers to maintain strict compile-time type checking throughout the pipeline.
