Struct ChildBatch 

pub struct ChildBatch<F> { /* private fields */ }

A non-Clone owner of concrete, pinned, admitted child futures.

Async execution polls all admitted children and awaits every result before collecting in original order. Sync execution polls sequentially and stops on the first error. Before its first poll a custom executor can transfer the exact pins with Self::into_tasks. No child future needs Send or Unpin.

See the complete child executor workflow.

Implementations

impl<F> ChildBatch<F>

pub fn mode(&self) -> ActionMode

Returns the actual synchronous or asynchronous execution mode.

This never returns the declaration-only ActionMode::Both value.

See the complete child executor workflow.

pub fn len(&self) -> usize

Returns the number of child tasks or completed results still owned here.

After the Future returns its results or an error, the batch owns none.

See the complete child executor workflow.

pub fn is_empty(&self) -> bool

Reports whether this batch still owns any child task or result.

See the complete child executor workflow.

pub fn into_tasks(self) -> Result<Vec<Pin<Box<F>>>, AppError>

Transfers the exact pinned child futures before this batch is polled.

Once polling begins, returns Conflict and drops the consumed batch, including its remaining futures and retained completion evidence. This never moves a child out of its pin or creates a second execution owner.

Errors

Returns AppError::Conflict once any batch polling has begun, even if no child has completed. The consumed batch is dropped on error, preserving pin safety and preventing duplicate completion ownership.

Example

use app_kit::{AppError, workflow::{ChildBatch, ChildCompletion, ChildExecutor}};
use futures_util::FutureExt;
use std::{future::Future, pin::Pin};
struct InspectChildren;
impl InspectChildren {
    fn collect(results: Vec<Result<ChildCompletion, AppError>>) -> Result<Vec<ChildCompletion>, AppError> {
        results.into_iter().collect()
    }
}
impl ChildExecutor for InspectChildren {
    type Execution<'a, F> = futures_util::future::Map<futures_util::future::JoinAll<Pin<Box<F>>>,
        fn(Vec<Result<ChildCompletion, AppError>>) -> Result<Vec<ChildCompletion>, AppError>>
    where Self: 'a, F: Future<Output = Result<ChildCompletion, AppError>> + 'a;
    fn execute<'a, F>(&'a self, batch: ChildBatch<F>) -> Self::Execution<'a, F>
    where F: Future<Output = Result<ChildCompletion, AppError>> + 'a {
        // App delivers an unpolled batch. Keep each concrete future in its original pin.
        let tasks = batch.into_tasks().expect("batch has not been polled");
        futures_util::future::join_all(tasks).map(Self::collect as fn(_) -> _)
    }
}
    let terminal = run.execution(ExecutionOptions::default()).await?.finish().await?;
    assert_eq!(terminal.state.values()["sum"], 5);

Trait Implementations

impl<F: Future<Output = Result<ChildCompletion, AppError>>> Future for ChildBatch<F>

type Output = Result<Vec<ChildCompletion>, AppError>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.