pub struct RecordHost {
pub databases: Vec<BuiltFor>,
pub write: Option<Path>,
pub read: Option<Path>,
}Expand description
The RECORD-HOST activation: record, and the dialects the declaration named inside it.
§The container declares the capability set, which is the family’s inversion law
A record’s head names the databases its rows land in and a bare field is a column in every one
of them; a fragment says the same thing one namespace in, and its fields narrow the same way.
The list here is that head’s, read at the tier that is HELD rather than stored — so it claims no
table and mints no row: what it names is which dialects this fragment was BUILT for, and
therefore which per-dialect faces have a declaration to be emitted from. There is exactly one
such face — the comparison pair a wire-faced holder asks for — and it is written at each named
dialect’s concrete backend; see FieldsModel::pair.
It is the position crossing(<db>, …) was heading for and never reached. That word claimed no
storage either and said so in its own note; what the namespace adds is the one thing that made
it ambiguous — a dialect written bare on a fragment used to be a store claim at one seat and a
crossing target at another, and inside record(…) there is only one reading.
Fields§
§databases: Vec<BuiltFor>The dialects this fragment is built for, in the order the declaration named them.
EMPTY is the bare record word and is not a defect: the storage faces below are dialect-
GENERIC — one Carrier<DB>, one Assemble, one SEGMENTS — so a fragment that names no
dialect is held by a record storing rows in any of them, and gets no pair, which is what every
declaration written before the model existed does.
What a named dialect buys is the COMPARISON PAIR, minted per entry at that entry’s concrete
backend. It buys nothing at the layout: those three faces carry no dialect and cannot be split
per dialect — the read least of all, two Assemble impls constrained to different
Row::Databases being E0119 — so a per-FIELD claim about a dialect is refused at the front
end with that measurement, and a layout that varies per database is the HOLDER’s to write.
It is also where a MOUNTED LOWERING hangs, which is the second thing a named dialect buys —
see BuiltFor::comparison.
write: Option<Path>record(write = "…") — the WHOLE VALUE’s way across the storage boundary, or None where
the declaration wrote none.
§The field seat cannot spell it, and that is the whole reason this one exists
FragmentField::write is a fn(&T) -> T over ONE field’s type. A canonical form that reads
SEVERAL fields at once has no such function: reducing a rational divides both halves by their
common factor, so the numerator’s new value is not a function of the numerator. The seat here
is fn(&Self) -> Self — the whole value in, the whole value out — which is exactly the shape
the hand households already have, Rate::reduced() and Timebase::reduced() being methods on
the value rather than on either half.
§What it is spent at, and why that is TWO sites rather than one
Every place this emission carries the whole value ACROSS the storage boundary, which the census
of 2026-08-24 enumerated: the BIND (carrier) and the CURSOR’s write
(keyset). Both must spend it or the pair disagrees — a keyset boundary
written from the declared spelling resumes against columns holding the canonical one, which is
the paging twin of the eq miss the field seat exists to kill.
The CROSSING is not a third site, and the reason is measured rather than deferred: the emitted
composite predicate is one Option<component filter> per COLUMN
(crate::unit::filter), so try_from_filter never holds a whole Self for a
fn(&Self) -> Self to touch — and a whole-value transform has no per-column action to push
down, num = 2 having no image under a reduction that divides by a factor of the PAIR. See
FieldsModel::head_write for the whole ruling.
A syn::Path for BuiltFor::comparison’s reason: the path is EMITTED, so one naming
nothing is E0433 at the string the author wrote and one whose signature disagrees is E0308
there.
read: Option<Path>record(read = "…") — the mirror, or None for the identity.
The raise side is SYMMETRIC, which is what admits the word at all: FieldsModel::assemble
builds a whole Self out of the fetched columns and FieldsModel::keyset’s read builds one
out of the cursor’s bytes, so a fn(&Self) -> Self has the same two sites in this direction
that write has in the other.
ABSENT is the IDENTITY, for the field seat’s reason: a canonicalisation’s stored form IS a
domain form — a reduced rational is a rational — so the common case writes write alone.