ModelingEvolution.PropertyKinds

A closed, code-defined catalogue of typed property value kinds — and the search operators each one supports.

A typed property value is the pair (PropertyValueKind kind, string canonical). The set of kinds is code; the registry of properties that use them is data, and lives wherever the consuming application keeps it. Nothing in this package knows what a product, a price or an offer is.

var catalog = PropertyKindCatalog.Default;

var mass = catalog.For(PropertyValueKind.Mass);
mass.Canonicalize("500 g", null);          // "500 g"      — the vendor's unit is preserved
mass.Format("≈40 kg", null, null);         // "≈40 kg"     — and so is the vendor's hedge

Mass.Parse("500 g").Kilograms;             // 0.5m         — but the magnitude is normalised
Mass.Parse("500 g") < Mass.Parse("1 kg");  // true

Why it exists

Because a typed value that crosses a boundary as text has to be recovered from prose on the far side, and decimal.TryParse("380 A") is false. A regular expression over 30 – 380 A is not a query; it is a bug waiting for a value with a space in it.

var tested  = catalog.Facet(PropertyValueKind.Range, "30 – 380 A", null, null);
var welded  = catalog.Facet(PropertyValueKind.Range, "30 – 500 A", null, null);

tested.Supports(SearchOperator.Within);                 // true — an interval knows what it admits
tested.TryMatch(SearchOperator.Within, welded, out var inside);  // true, inside == true

The kinds

The ordinals are the wire format and are frozen forever. Adding a kind is additive on both sides; reordering one silently re-types every value already stored. The package's major version bumps only if an ordinal moves, which it never does.

The operator model

Five shapes, because five is all the data has.

TryMatch is total: it returns false when the question cannot be answered — an unsupported operator, the wrong operand shape, two values in incompatible units, or a tolerance compared against a magnitude — and never guesses. ±0.03 mm of repeatability is not 0.03 mm of reach, and 100 EUR does not order against 100 PLN in a package that has no exchange rate.

This is not a search engine, an index or a query language. It is the statement of which comparisons a kind admits, so that a later feature can build one.

Reading a value a newer producer wrote

A producer and a consumer deploy independently, so there is a window where the producer emits a kind the consumer does not know. Deserialising straight into the CLR enum turns that window into a parse failure, and a parse failure on a read path takes the page down.

var kind = PropertyKindRef.Read(yaml.Kind);   // never throws
kind.IsKnown;                                 // false for "Torque"
kind.Token;                                   // "Torque" — nameable in a log
kind.Display;                                 // "Torque"; "Unknown" when the token was blank
kind.ToString();                              // the serialised form, verbatim — round-trips exactly

catalog.Facet(kind, canonical, unit, choices) // PropertyFacet.None — refuses, never guesses

The row still renders: the producer emitted its own display string for the value, and that is what a reader sees. What an unknown kind cannot do is participate in a facet or a comparison.

Localised kind labels

PropertyKindDisplay.For(PropertyValueKind.Range, "pl");   // "Zakres"
PropertyKindDisplay.For(PropertyValueKind.Size3D, "pl");  // "Wymiary"

These label the kind, for a search UI's operator picker. They are not specification-table headings. A heading names a property — "Enclosure length" — and a property is a data row somebody can rename without recompiling anything. An attribute cannot label a type that did not exist when the assembly was built, which is why this package ships no language-keyed attribute for property names or enum choice labels at all: absent, so it cannot be reached for.

License

MIT.