Struct Gesture 

pub struct Gesture {
    ops: CommitBuilder,
    label: Label,
    staged: Option<Staged>,
    ids: Allocator,
    writability: Writability,
}

The ops a gesture has authored, and the document they imply.

The prediction is why this is a type rather than a bare CommitBuilder. The repo’s document only advances at submit, so a gesture reading it would not see its own writes: a block placed and immediately renamed would read as absent. Gesture::author is the only way in, and it folds what the gesture has said so far onto the base — so the next read, in this same frame, sees it.

Fields

ops: CommitBuilder

label: Label

What this gesture is called before it has authored anything — finished at the seal, where the ops say what it acted on.

staged: Option<Staged>

The base with Self::ops folded on. None while the gesture has authored nothing, because then the base already is the prediction — an idle frame pays neither the fold nor the index rebuild.

ids: Allocator

The ids this gesture has handed out, beside the document’s own marks. A mint that never becomes a Create still raises this, so two mints of one kind cannot collide inside a gesture; an abandoned gesture takes its marks with it, which costs nothing because it created nothing.

writability: Writability

Whether the session behind this sink may write at all. Carried here because this is the write door: a read-only session’s gesture declines in Self::author, and the tools read the same answer through Drawing::authoring to decide what to offer in the first place.

Implementations

impl Gesture

pub fn open(label: Label, writability: Writability) -> Self

Open a gesture under its semantic label.

pub fn idle() -> Self

A gesture between gestures, and the sink a read pass is handed. Nothing writes into it — every write opens its own labelled one — so neither this label nor its writability reaches a commit.

pub fn writability(&self) -> Writability

pub fn ops(&self) -> &[OpCodes]

pub fn ids(&self, base: &Document) -> Allocator

The allocator an emitter whose id count is data-dependent (paste) mints from: this gesture’s marks raised to the prediction’s, so nothing it has authored can be minted twice.

pub fn mint<K: IdKind>(&mut self, base: &Document) -> Id<K>

A fresh id for a setter that mints one.

fn prediction<'v>(&'v self, base: &'v Document) -> &'v Document

The document as this gesture has left it: the base until it writes.

pub fn view<'v>(&'v self, base: IndexedDocument<'v>) -> IndexedDocument<'v>

The document this gesture reads: base with its own writes folded on. Identical to base until it writes.

pub(crate) fn author( &mut self, base: IndexedDocument<'_>, what: &'static str, emit: impl FnOnce(&IndexedDocument<'_>, &mut CommitBuilder), )

The one write door. emit is handed the document as this gesture has left it and the sink to author into; whatever it pushes advances the prediction before the call returns, so no caller can read a document that predates its own edit.

what names the edit for the mutation log (RUST_LOG=edit=debug), which narrates here rather than at each setter: authoring without narrating would mean calling this without an argument.

Crate-private on purpose: a gesture is authored into through a Drawing method, never by the tool holding it.

fn restage(&mut self, base: &Document)

Re-fold the whole gesture onto base. Whole, not incremental: op order within a commit is free for references (a pin may precede its owner’s create), so a half-gesture can fail a validation the finished one passes.

pub fn seal(&mut self, label: String) -> Option<Commit>

Seal the gesture under label and leave a fresh idle one in its place. None when nothing was authored, which is what makes an abandoned drag a non-event.