Future
A future is an abstraction representing an asynchronous computation or its result, which may not be complete or available yet.
C++ Concurrency in Action, Second Edition
An object representing a value that may become available later, often as the result of asynchronous work.
- How it is used
- Synchronizes one-off events and transfers results between concurrent operations without requiring callers to manage result transfer through std::thread.
- How deep it goes
- Works through waiting, result retrieval, producers, exceptions, and continuations; does not specify which thread runs a continuation.
- Examples
- Uses a background calculation, network packet completion, parallel Quicksort, and an asynchronous login workflow.
- What you can do after
- Apply it via std::async or std::promise to retrieve results and exceptions, or via Concurrency TS continuations to chain operations.
Read how C++ Concurrency in Action, Second Edition explains future →
Rust Servers, Services, and Apps
The Rust Future trait defines the interface for an asynchronous computation that can be polled toward completion.
- How it is used
- Connects deferred computations to concurrent task scheduling in Rust web services.
- How deep it goes
- Works through the trait signature, polling, waking, and a custom timer, while leaving Pin’s deeper mechanics aside.
- Examples
- Uses concurrent file-read simulations and a custom expiration timer to show pending and ready results.
- What you can do after
- Build it from scratch: implement a timer future that returns pending, wakes its task, and eventually returns a value.
Python Concurrency with asyncio
A future is an object representing the eventual result or exception of an asynchronous operation that may not yet be complete.
- How it is used
- Coordinates deferred results in asyncio and exposes completion to await expressions and APIs that return futures.
- How deep it goes
- Defines states, result handling, awaiting, inheritance, and custom __await__ mechanics, but does not develop custom awaitables beyond a basic implementation.
- Examples
- Uses direct result assignment, delayed web-request simulation, a responsive URL stress tester, and a custom future driven by an event loop.
- What you can do after
- Apply it via asyncio by awaiting results, setting completion values or exceptions, and tracking thread-safe coroutine submissions.
Code Like a Pro in Rust
Future is a Rust trait representing a computation that may complete later and eventually produce an output or remain pending.
- How it is used
- Represents deferred async results and provides the return type used when adapting trait methods to asynchronous work.
- How deep it goes
- Explains lazy execution and polling, then works through pinned, boxed futures for an async observer; it does not implement an executor.
- Examples
- Contrasts awaited, discarded, and spawned async blocks; builds a pinned future-returning observer trait and tests its update.
- What you can do after
- Apply it via Tokio to await or spawn work, return pinned futures from trait methods, and isolate blocking calls.
Grokking Concurrency
A future is a concurrency abstraction and placeholder representing the result of an asynchronous computation that will become available later.
- How it is used
- Supports asynchronous communication by letting callers continue after starting work and later receive its result.
- How deep it goes
- Defines futures as placeholders and synchronization mechanisms, then traces their role in cooperative event-loop and socket operations.
- Examples
- Uses burger ordering, socket send and receive operations, and a pizza server with background cooking.
- What you can do after
- Build it from scratch as a simple Future-backed cooperative server component for deferred I/O or background results.
Learn Rust in a Month of Lunches
A Future is a Rust abstraction representing an asynchronous computation whose result may become available later and which can be polled for readiness.
- How it is used
- Represents an async computation whose output can be awaited rather than returned immediately.
- How deep it goes
- Explains readiness, polling, awaiting, and the Future trait’s Output type, while deferring a deep understanding of Pin.
- Examples
- Uses an async function returning a u8, compiler errors around await, and timed Futures combined with Tokio macros.
- What you can do after
- Apply it via Tokio to await a Future and choose between sequential waits, join!, and select! for multiple Futures.
Functional Programming in Scala, Second Edition
Future is a Java concurrency interface representing the result of an asynchronous computation and supporting result retrieval and cancellation.
- How it is used
- Represents asynchronous results and composes parallel work or non-blocking I/O through callbacks.
- How deep it goes
- Defines callback encoding, executor scheduling, parallel combination, and a blocking run bridge.
- Examples
- Uses parallel square-root mapping, callback-based byte reads, and console programs compiled into Par.
- What you can do after
- Build it from scratch as a callback-based result type and adapt asynchronous sources into composable Par actions.
Read how Functional Programming in Scala, Second Edition explains future →
Kotlin in Action, 2E
A future is an abstraction representing a result that may become available after an asynchronous computation finishes.
- How it is used
- Coordinates independent asynchronous computations whose results are awaited later.
- How deep it goes
- Defines Deferred, demonstrates async and await timing, and explains cancellation and exception-consumption responsibilities.
- Examples
- Uses concurrent delayed addition, chained login and user-data loading, cancellation, and an exception thrown beneath async.
- What you can do after
- Apply it via Kotlin async and await to run independent tasks concurrently and consume their values or failures.
Related concepts
- taskused by · A task is a defined unit of work, computation, or action directed toward a result or objective.
- asyncproduced by · async is a Kotlin coroutine builder that starts an asynchronous computation and returns a Deferred representing its result.
- threaduses · A thread is an independently schedulable sequence or context of execution within a program or process.
- asyncio.gatherimplemented by · asyncio.gather is a Python asyncio function that runs multiple awaitable objects concurrently, waits for them to complete, and collects their results.
- std::shared_futurecontrasts with · A C++ standard library class template that allows multiple objects to access the same asynchronous result.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.