ingraph 0.1.0

A declaration-driven indexing framework: records and nodes are written as Rust types, and the storage rows, the dataflow between them and the GraphQL query surface are emitted from the declaration.
Documentation
//! 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`].

mod confidence;
mod count;
// 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.
pub mod detect;
// 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.
pub mod geometry;
// 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.
#[cfg(feature = "derive")]
pub mod lang;
// 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.
#[cfg(feature = "mediatime")]
pub mod mediatime;
// 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.
#[cfg(feature = "mediaframe")]
pub mod mediaframe;
mod time_range;
pub(crate) mod timestamp;

pub use confidence::{Confidence, ConfidenceCarrier, Score};
pub use count::{Count, NegativeCount};
pub use detect::{
  BarcodeDetection, BarcodeDetectionFilter, BarcodeDetectionLeaf, BarcodePayloadKind, Detection,
  DetectionFilter, DocumentSegment, DocumentSegmentFilter, EmptyLabel, Label, LabelWire,
  LocatedDetection, LocatedDetectionFilter, LocatedDetectionLeaf, Symbology, TextDetection,
  TextDetectionFilter, TextDetectionLeaf,
};
#[cfg(feature = "sqlx")]
pub use detect::{
  SqlBarcodeDetectionComparison, SqlDetectionComparison, SqlDocumentSegmentComparison,
  SqlLocatedDetectionComparison, SqlTextDetectionComparison,
};
pub use geometry::{
  BoundingBox, BoundingBoxFilter, BoundingBoxLeaf, NormCoord, OutsideTheUnitInterval, Point2,
  Point2Filter, Quad, QuadFilter, RadianMath, Radians, RefusedBox,
};
#[cfg(feature = "sqlx")]
pub use geometry::{SqlBoundingBoxComparison, SqlPoint2Comparison, SqlQuadComparison};
pub use time_range::{
  Contained, ContainedOperand, InvertedTimeRange, ParseTimeRangeError, PayloadFilter, TimeRange,
  TimeRangeFilter, TimeRangeOperand, TimeRanged, TimeRangedFilter,
};
#[cfg(feature = "mongo")]
pub use time_range::{MongoTimeRangeComparison, MongoTimeRangedComparison};
#[cfg(feature = "sqlx")]
pub use time_range::{SqlTimeRangeComparison, SqlTimeRangedComparison};
pub use timestamp::{Timestamp, TimestampPartsError};
// The WALL-CLOCK citizen, behind the two words its faces need — see the module that declares it.
#[cfg(all(feature = "time", feature = "derive", feature = "sqlx"))]
pub use timestamp::SqlLocalTimestampComparison;
#[cfg(all(feature = "time", feature = "derive"))]
pub use timestamp::{
  LocalTimestamp, LocalTimestampFilter, LocalTimestampLeaf, LocalTimestampOperand,
  LocalTimestampPartsError, NoUtcPosition,
};