1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
//! The value types a declaration names as a field type, each carrying an INVARIANT its Rust
//! representation cannot state on its own.
//!
//! [`Confidence`] is the first, and it is here rather than in the crate that asked for it because a
//! confidence belongs to no one analyzer: a sound-event detection, a face detection, a speaker
//! cluster and a zero-shot tag each produce one, and a bare float says nothing about the interval
//! they all promise. [`Score`] is the `f32` one, under the name the crate spent on it while `f32`
//! was the only width there was.
//!
//! The WIDTH became a parameter when a fourth kind of caller arrived measuring in something else,
//! and the vocabulary it opened onto is closed at four ([`ConfidenceCarrier`]) — the invariant is
//! one sentence at every width, and admitting a width is a measurement rather than a bound.
//!
//! [`Timestamp`] is the second, and it arrived the way the sentence below says one does — the
//! FRAMEWORK asked, having a record of its own to stamp. Its invariant is a range and a precision:
//! `jiff::Timestamp` states both already, and what the newtype adds is the right to give them a wire
//! face, a filter and a storage shape, which the orphan rule reserves to the crate that owns the
//! type.
//!
//! [`Count`] is the third, and it arrived the same way the second did — the FRAMEWORK asked, having
//! a FOLD of its own to answer. Its invariant is the one a `u64` cannot state: *a cardinality counts
//! rows that EXIST*, so it is bounded by the physical store, and its dialect crossings are allowed
//! to spend that bound where a bare `u64`'s must not. That is what buys a `counting` measure a
//! column on SQLite and PostgreSQL, neither of which has an unsigned 64-bit type.
//!
//! No general `UnitInterval` or `Ratio` stands beside them, and none is waiting to. A second name
//! arrives when a second caller does — the rule the crate as a whole is grown by, applied to the
//! types it owns rather than only to the ones it takes from elsewhere. The width parameter is that
//! rule kept rather than bent: what arrived is a second CARRIER for the name already here, not a
//! second name. [`Count`] is that rule KEPT: the aggregate's counting citizen is the caller, and it
//! asked.
//!
//! [`lang`] is the fourth, and it is the first entry here that is a FAMILY rather than a name — five
//! types, one grammar. It is the rule above read at family scale rather than an exception to it: the
//! invariant is a STANDARD, BCP 47 and the three ISO registries under it, and a standard does not
//! arrive one type at a time. See that module's own note, which opens on exactly this.
//!
//! It is also the one house here with NO UPSTREAM TYPE TO WRAP. The three names above each put a
//! face on a value that already exists — a float, a `jiff::Timestamp`, a `u64`. A language is a
//! published text file, and what [`lang`] does is turn one into types.
//!
//! [`TimeRange`] and [`TimeRanged<T>`](TimeRanged) are the fifth, and they arrive as a PAIR for a
//! reason the rule above already admits: the invariant is one sentence — `start <= end` — and the
//! second name is that sentence HELD rather than a second invariant, a timed payload being a range
//! and a payload. What they wrap is nothing new either; the component is [`Timestamp`], and every
//! face they own composes its face rather than spelling a second instant.
//!
//! They are the first entry here whose second name is GENERIC over what a declaration puts in it,
//! which is [`Confidence`]'s parameter with the seal taken off: a width is admitted by a
//! MEASUREMENT and the vocabulary is closed, where a payload is whatever a declaration holds and the
//! vocabulary cannot be.
//!
//! [`mediatime`] is the sixth, the SECOND family here, and the first entry that is a second reading
//! of a name already above it. Its `MediaTimestamp` and `MediaTimeRange` are a position and an
//! extent exactly as [`Timestamp`] and [`TimeRange`] are — the same half-open algebra, the same
//! three interval words, the same two-shape `contains` operand — measured against a stream's own
//! `Timebase` rather than against the UTC timeline.
//!
//! That is not the one-name-per-invariant law bent. The invariant differs: an instant is absolute
//! and a tick count means nothing without the rational beside it, so the pair is the value and the
//! unit rides in the type. The names say which is which, and the module note there walks why the
//! qualifier landed on this side.
//!
//! It is also the first entry gated on a VOCABULARY rather than on a tier — `mediatime`, the door
//! named for the crate whose four types it wraps.
//!
//! [`geometry`] is the seventh, the THIRD family, and the first entry here that is DOMAIN-NEUTRAL by
//! construction: a point, a rectangle and a quadrilateral are one geometry read at three arities,
//! and nothing in the house knows what a box is a box OF. It is also the first family whose members
//! are GENERIC over what a caller measures in, with [`NormCoord`] the one instantiation this crate
//! names.
//!
//! [`detect`] is the eighth and the FOURTH family, and it is the first entry that COMPOSES another
//! one: a [`LocatedDetection<T>`](LocatedDetection) is a classification and a
//! [`BoundingBox<T>`](BoundingBox), so the geometry house's parameter reaches through it unchanged.
//!
//! It arrives as a family for the rule this module is grown by rather than despite it. The invariant
//! is [`Label`]'s alone — a word that is not nothing — and the two composites add none; what makes
//! them three names rather than one is that *a classification with a place* and *a classification
//! without one* are two shapes, and the second name is the first one's `Option` REFUSED. See that
//! module's note, where the refusal is the whole subject.
//!
//! [`mediaframe`] is the ninth and the FIFTH family, and it is the second entry here gated on a
//! VOCABULARY — the door named for the crate whose words it wraps, as [`mediatime`] is. Its
//! [`codec`](mediaframe::codec) house is the first vocabulary here that is OPEN: the three types
//! are roster enums with a lossless escape arm, so every text names a value and the door that reads
//! one cannot fail.
//!
//! That openness is what picks its storage road and it is worth naming here rather than only there:
//! a word with an escape has no discriminant to be, so it stores as its canonical TEXT — the road
//! [`lang`]'s subtags take, and the one a closed published ontology's numeric code does not.
//!
//! It is also the first entry admitted as a WAVE rather than whole. Its crate carries other
//! families this module has record-station pull for, and exactly one is here; the module note
//! carries the census that admitted this one and the named refusal that kept a second BCP 47
//! citizen out from beside [`lang`].
// The detect family rides NO word either, on the geometry house's precedent one line down and for
// the same two halves of its reason: it admits no dependency — a label is this crate's text carrier
// and a confidence is this crate's own type — and it needs no declaration tier, `#[ingraph(composed)]`
// taking a CONCRETE struct where this house's located filter is generic over its component's. See
// the family note, where declaring one of the two filters and hand-writing the other is measured and
// declined.
// The geometry family rides NO word at all, and that is the dependency law read where it runs out:
// the house has no dependency to name a door for, and the declaration tier it might otherwise have
// wanted is one the `#[ingraph(composed)]` derive could not serve anyway — that word takes a
// CONCRETE struct, and all three of this family's filters are generic over their component's. So
// they are hand-written on `TimeRangedFilter`'s road, and the module sits beside `time_range` with
// the same gate that house has: none. See the family note, where the measurement is.
// The lang family rides `derive` because two of its five types are DECLARED rather than written: the
// two composed filters wear `#[derive(ingraph::Filter)] #[ingraph(composed)]`, which is the door a
// downstream declares its own filters through and which this crate reaches through
// `extern crate self as ingraph` (see `lib.rs`). Keeping the declaration is what keeps the family
// the framework's own worked example of the word; the cost is that a build declining the
// declaration tier declines the family with it.
// The media-time family rides `mediatime`, the VOCABULARY door — one word rather than the `all(…)` a
// reader might expect, because the feature IMPLIES `derive` in the manifest. It has to: five of this
// family's filters are DECLARED rather than written, through the same `#[derive(ingraph::Filter)]
// #[ingraph(composed)]` the lang house one line up rides `derive` for. The difference between the two
// houses is that this one has a WORD, and a word a build can write and get nothing for is a promise
// the feature table does not keep — so the implication is where that is paid rather than here. See
// the manifest row, which carries the argument and the cost.
// The stream-descriptor family rides `mediaframe`, the SECOND vocabulary door and the second word
// here named for the DEPENDENCY it admits rather than for a family — the *按依赖分门* reading, one
// word per crate and the houses beneath it as modules. Unlike `mediatime` one line up it implies
// NOTHING: no filter beneath it is declared, a codec being one word in one column whose filter is
// the framework's own `ScalarFilter`, so the word buys the whole house rather than a fraction of
// one. That is the condition the row above states for when an implication is owed, met from the
// other side. See the manifest entry, and the family note for the ONE family admitted so far.
pub
pub use ;
pub use ;
pub use ;
pub use ;
pub use ;
pub use ;
pub use ;
pub use ;
pub use ;
pub use ;
// The WALL-CLOCK citizen, behind the two words its faces need — see the module that declares it.
pub use SqlLocalTimestampComparison;
pub use ;