Enum Divergence 

#[non_exhaustive]
pub enum Divergence {
    CaseSelection {
        shadow: Vec<CaseKey>,
        authoritative: Vec<CaseKey>,
    },
    ActsExtracted {
        shadow: Vec<ActSummary>,
        authoritative: Vec<ActSummary>,
    },
    Mutations {
        shadow: Vec<MutationSummary>,
        authoritative: Vec<MutationSummary>,
    },
    ClarificationVersusAction {
        asked: Side,
        clarifications: Vec<ClarificationSummary>,
        mutations: Vec<MutationSummary>,
    },
    ClaimWithoutEvent {
        claimant: Side,
        class: ClaimClass,
    },
    RefusedUnresolvedTargetThatRan {
        performed: MutationSummary,
        reason: RefusalReason,
    },
}

One way two paths disagreed about the same turn.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

CaseSelection

The two sides addressed different records.

Fields

shadow: Vec<CaseKey>

What this library selected.

authoritative: Vec<CaseKey>

What the existing path selected.

ActsExtracted

The two sides read different acts out of the same turn.

Fields

shadow: Vec<ActSummary>

What this library extracted.

authoritative: Vec<ActSummary>

What the existing path extracted.

Mutations

The two sides would run different mutations, for a reason the comparison cannot attribute on its own.

Fields

shadow: Vec<MutationSummary>

What this library would run.

authoritative: Vec<MutationSummary>

What the existing path would run.

ClarificationVersusAction

One side asked the user something while the other acted.

Fields

asked: Side

The side that asked.

clarifications: Vec<ClarificationSummary>

What it asked.

mutations: Vec<MutationSummary>

What the other side did instead.

ClaimWithoutEvent

One side stated an outcome that no committed event, on either side, backs.

Evidence from either side counts, because in a shadow stage only one side executes anything: a claim the authoritative path committed an event for is a backed claim, whoever else also made it. Only classes an event can back are checked — “you can see the card below” is backed by a persisted card and “I will notify you” by nothing at all, so neither is judged here.

Fields

claimant: Side

The side that stated it.

class: ClaimClass

What it stated.

RefusedUnresolvedTargetThatRan

This library refused a mutation because it could not tell which record was meant, and the existing path performed it anyway.

This is the asymmetry this module exists to carry, and it is a finding against the existing path: it chose one of several records the user might have meant.

Fields

performed: MutationSummary

The mutation the existing path performed.

reason: RefusalReason

Why this library would not.

Implementations

impl Divergence

pub const fn kind(&self) -> &'static str

A stable lower-case name of the kind, for a metric label or a column.

Trait Implementations

impl Clone for Divergence

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Divergence

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

Formats the value using the given formatter.

impl Eq for Divergence

impl PartialEq for Divergence

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Divergence