Struct DiffResult 

pub struct DiffResult {
    pub runs: RunPair,
    pub alignment: Vec<Move>,
    pub fork: Option<Fork>,
    pub field_diffs: Vec<FieldDiff>,
    pub attribution: Option<Attribution>,
    pub warnings: Vec<Warning>,
    pub meta: Meta,
}

The complete result of diffing two runs — the frozen output contract.

Fields

runs: RunPair

alignment: Vec<Move>

The full move-typed alignment, in order.

fork: Option<Fork>

The divergence point, or None on a converged diff.

field_diffs: Vec<FieldDiff>

Field-level differences within aligned pairs.

attribution: Option<Attribution>

Regression attribution, if computed.

warnings: Vec<Warning>

Non-fatal diagnostics.

meta: Meta

Implementations

impl DiffResult

pub fn fork_step_observed(&self) -> Option<usize>

The observed-run (side b) step the fork points at, or None on a converged diff.

A fork whose move touches the observed run names its step directly (Fork::b_step). A model-only fork — the observed run is missing steps the reference has — has no b side; the nearest observed step is the first one not yet consumed when the gap opens (the count of b-consuming moves before the fork), clamped to the last real step. Every consumer answering “where did MY run go wrong” (bench scoring, the parity test) reads this one rule instead of re-deriving it.

Trait Implementations

impl Clone for DiffResult

fn clone(&self) -> DiffResult

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DiffResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DiffResult

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DiffResult

fn eq(&self, other: &DiffResult) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for DiffResult

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DiffResult