Struct Recorder 

pub struct Recorder { /* private fields */ }

Writes down what happened, one record per forward. It owns its store where a Cache borrows one: a cache is made for one forward and a recorder counts them.

Implementations

impl Recorder

pub fn over(store: Arc<dyn Store>) -> Self

A recorder over this store, under a name of its own — made here and readable with run, because a forward in a notebook has no reason to invent one and still has to be findable.

pub fn named(store: Arc<dyn Store>, run: impl Into<String>) -> Self

The same, under a name you chose: a training run that wants to be found again by the name it already has.

pub fn summarising( self, kinds: impl IntoIterator<Item = impl Into<String>>, ) -> Self

The same recorder, with these kinds of fact carried in the record and not only in the blob, as <kind>.<field>.

Ten thousand losses read one blob at a time is ten thousand round trips and the number wanted from each is one. Which kinds those are is the caller’s, so this crate does not learn what a loss is. The last fact of each kind in a forward is the one carried.

pub fn run(&self) -> &str

What this run is called, which is the first half of every name it writes.

pub fn said(&self, kind: &str, fields: Vec<(String, String)>)

One fact from a vocabulary that is not the engine’s. It lands in the forward in flight, or — the normal case for a loss — in the one that ended last, whose record is rewritten. The fields are text to text because that is what a record is; the vocabulary is the caller’s.

Trait Implementations

impl Watcher for Recorder

fn saw(&self, fact: &Fact)

One fact. Whatever this does, it does not fail: there is no useful answer to “the log could not be written” in the middle of a run, and a Result here would make every emit site a decision about somebody else’s storage.