Struct OrderedRun 

pub struct OrderedRun<'run, T, R> {
    pub items: &'run [T],
    pub lanes: &'run [Vec<usize>],
    pub workers: usize,
    pub work: &'run (dyn Fn(usize, &T, &mut dyn FnMut(&str)) -> R + Sync),
    pub on_event: &'run mut dyn FnMut(Event<'_, R>),
}

What: Everything one ordered run needs. Why: One value names the inputs, so the call reads as a list of facts.

In TS you’d write (pseudocode):

type OrderedRun<T, R> = { items: T[]; lanes: number[][]; workers: number; work: (index, item, say) => R; onEvent: (event) => void };

Fields

items: &'run [T]

The items, in the order their output is reported.

lanes: &'run [Vec<usize>]

The indices of the items, grouped: the items of a lane run one after another on one worker, lanes run side by side. Every index appears in exactly one lane. Items that must not overlap (the same worktree named twice) share a lane.

workers: usize

The most threads that run at once; at least one, and never more than there are lanes.

work: &'run (dyn Fn(usize, &T, &mut dyn FnMut(&str)) -> R + Sync)

What one item does, given its index, itself and a function that says one line.

on_event: &'run mut dyn FnMut(Event<'_, R>)

The consumer, called on the calling thread only.