Struct Stepper 

pub struct Stepper<P, S, So> { /* private fields */ }

Drive a solver one iteration at a time.

Owns the problem, state, solver and termination criteria, runs solver.init exactly once on construction, and exposes step / run_to_end so callers can interleave their own work between iterations — recording trajectories, animating from a UI, pausing on a button press, evaluating a custom budget, etc.

Executor::run is self.into_stepper().run_to_end(); the stepper is the building block, the executor is the convenience wrapper.

Example

let mut stepper = Executor::new(problem, solver, state)
    .max_iter(100)
    .terminate_on(GradientTolerance(1e-6))
    .into_stepper();

let reason = loop {
    match stepper.step() {
        StepOutcome::Continue => { /* observe `stepper.state()` */ }
        StepOutcome::Stopped(reason) => break reason,
    }
};

Implementations

impl<P, S, So> Stepper<P, S, So>

where S: State + CountsMirror, So: Solver<P, S>,

pub fn state(&self) -> &S

Read-only access to the current state, between steps.

pub fn counts(&self) -> &EvalCounts

Wrapper-side evaluation counters. These are authoritative — solvers can only call into the user’s problem through the wrapper, so every cost / gradient / residual / Jacobian / Hessian call is reflected here. The state mirror under state is refreshed after every successful Solver::init / Solver::next_iter; on the typed-Err path the state slot is dropped (see step) but counts is still readable here for diagnostics.

pub fn finished(&self) -> Option<&TerminationReason>

Termination reason if the stepper has stopped, else None.

pub fn iter(&self) -> u64

Total iterations that have completed so far. Convenience read equivalent to self.state().iter().

pub fn step(&mut self) -> Result<StepOutcome, So::Error>

Advance one iteration. Once a Stopped outcome has been returned the stepper is sticky: subsequent calls keep returning the same Stopped(reason) without touching the state or solver.

Registered observers fire here: observe_iter on StepOutcome::Continue, gated by each observer’s ObserverMode; observe_final once when this call first returns StepOutcome::Stopped. See the observer module for the lifecycle.

Returns Err when the underlying problem returns Err from any cost / gradient / residual / Jacobian / Hessian call during the step. The stepper is not made sticky on Err — the typical downstream pattern is to surface the error and drop the stepper, but callers may inspect state and try again. Observers do not fire on the Err path (the state has been consumed by the failing call).

pub fn run_to_end(self) -> Result<OptimizationResult<S>, So::Error>

Drive step to completion and return an OptimizationResult.

pub fn into_state(self) -> S

Consume the stepper and return the final state.