Struct Stop 

pub struct Stop {
    pub commit: String,
    pub short: String,
    pub subject: String,
    pub parents: Vec<String>,
    pub verdict: Option<Verdict>,
    pub decided: Option<Course>,
    pub doubted: bool,
    pub trials: Tally,
    pub pruned: bool,
    pub context: bool,
    pub when: u64,
}

One commit of a line, with everything known about it that is not a step.

Fields

commit: String

short: String

Twelve characters, which is what a person reads.

subject: String

parents: Vec<String>

Who it comes from. The edges of the DAG: a range flattens two branches into an order, and drawing that order would be drawing a lie.

verdict: Option<Verdict>

Whether somebody found something wrong with this commit itself.

decided: Option<Course>

What the reasoning decided about the line this commit is on, if anything. Derived — from a decision’s scope, down through the moves it covers, out to the commits those cite — so abandoning a question’s line reaches an attempt hung under it tomorrow with nobody writing anything down. It deliberately does not reach a fork off an abandoned attempt: that is a sibling and starts clean, because trying something else is the move you make because it was a dead end.

doubted: bool

Whether something above it is Verdict::Invalid. Worked out from git rather than stored, so a commit made after the verdict is marked the moment it exists.

trials: Tally

What was run with this version: how many trials and how they are going.

A commit is the version and does not change; trials grow and are associated with it, not versioned. From the same scan as everything else, because soma put the state and the score in the record — counting forty versions is one walk and only the curve is paid for apart.

pruned: bool

Whether it folds when drawn: it is on a line somebody decided to abandon or call superseded, and nobody found anything wrong with it.

Pruning is not drawing, never deleting. The stop still comes back whole; all this says is that a tree of forty variants does not read, and whoever draws may fold this one. Computed here and not by whoever draws, or the rule would live in two languages and the terminal and the view would fold different things, both looking right.

context: bool

Whether it is only here so the one above it has something to be compared against. A range says which commits to show.

when: u64

When it was made. Which of three variants was tried first is a question about this and not about the order a walk arrived in.

Trait Implementations

impl Debug for Stop

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

Formats the value using the given formatter.

impl Serialize for Stop

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

where __S: Serializer,

Serialize this value into the given Serde serializer.