Enum Step 

#[non_exhaustive]
pub enum Step {
    Reading {
        words: usize,
    },
    Segmented {
        analysis: String,
        units: Vec<UnitSummary>,
    },
    Covered {
        added: Vec<UnitSummary>,
    },
    CrossChecked {
        round: u8,
        findings: usize,
    },
    CrossCheckSkipped {
        round: u8,
        code: String,
    },
    Routed {
        unit: UnitId,
        to: Routing,
    },
    Located {
        act: ActId,
        record: Located,
    },
    Extracted {
        act: ActId,
        given: Vec<(String, String)>,
        not_given: Vec<String>,
    },
    Verified {
        act: ActId,
        confirmed: bool,
        reason: String,
        at_fault: Vec<String>,
    },
    Repairing {
        act: ActId,
        because: String,
    },
    Checked {
        act: ActId,
        refused: Option<(String, String)>,
    },
    NotUnderstood {
        unit: UnitId,
        reason: NotUnderstoodReason,
    },
    Assembled {
        ready: Vec<ActId>,
        asking: Vec<ActId>,
        held: Vec<ActId>,
        questions: usize,
    },
}

One thing the understanding decided.

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.

Reading

The message is being read.

Fields

words: usize

How many words it has.

Segmented

The message was split into units.

Fields

analysis: String

The model’s one-line reading of the message.

units: Vec<UnitSummary>

Each unit: its id, kind and words.

Covered

The coverage check added units the segmentation missed.

Fields

added: Vec<UnitSummary>

The units added.

CrossChecked

A round of the whole-turn check answered.

Fields

round: u8

The round, from 1.

findings: usize

What it found.

CrossCheckSkipped

A round of the whole-turn check did not run, or gave no answer to use.

Fields

round: u8

The round, from 1.

code: String

Why, as a failure code.

Routed

A unit was routed.

Fields

unit: UnitId

The unit.

to: Routing

Where it went.

Located

An act’s record was decided.

Fields

act: ActId

The act.

record: Located

Its record.

Extracted

An act’s arguments were read.

Fields

act: ActId

The act.

given: Vec<(String, String)>

Each argument given, as a person reads it.

not_given: Vec<String>

The arguments the user did not give.

Verified

An act was verified against the user’s words.

Fields

act: ActId

The act.

confirmed: bool

Whether everything checked out.

reason: String

The verifier’s reason.

at_fault: Vec<String>

The arguments found wanting.

Repairing

An act’s values are being read again, with feedback.

Fields

act: ActId

The act.

because: String

Why.

Checked

The domain checked an act.

Fields

act: ActId

The act.

refused: Option<(String, String)>

The argument it refused, and why, when it refused one.

NotUnderstood

A unit produced nothing to act on.

Fields

unit: UnitId

The unit.

reason: NotUnderstoodReason

Why.

Assembled

The understanding is assembled.

Fields

ready: Vec<ActId>

Acts ready for the reducer.

asking: Vec<ActId>

Acts that will ask for a value.

held: Vec<ActId>

Acts held back.

questions: usize

Questions found.

Implementations

impl Step

pub fn describe(&self) -> String

One plain line saying what was decided.

Trait Implementations

impl Clone for Step

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 Step

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Step

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Step

impl PartialEq for Step

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Step

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 Step