Concepts

Here is a list of all documented concepts with brief descriptions:

Nmorph
Nforms
REmptyCapableField	Concept: a field type with an internal empty state (Quantity, Choice, Timestamp, or any user type exposing hasValue())
REngageableField	Broader than EmptyCapableField: also covers a plain std::optional<T> member (e.g. std::optional<std::string> email), which does not satisfy EmptyCapableField — it exposes has_value(), not hasValue() (see forms.md's allRequiredEngaged "two exclusions" note). The cross-field rule vocabulary's engagement checks (engaged, notEngaged, requiredWhen, and the membership rules exactlyOneOf/atLeastOneOf/mutuallyExclusive) accept either kind of field, since docs/spec/forms/forms.md's worked example ranges an exactlyOneOf over two plain std::optional<std::string> fields
RCondition	Concept: Cond may be used as a nested condition — inside an andOf/orOf/notOf tree, or as the when clause of a requiredWhen / visibleWhen / readonlyWhen rule
RRuleLiteral	Constraint: literal types equals(...) accepts — the closed, JSON-representable scalar set a field can hold. Restricting the literal type keeps equals losslessly serialisable into x-rules's value key (see forms.md): a numeric literal is always the exact math::Rational, never a double
RComparableAgainstLiteral	Constraint: a field of type V can be compared against a literal of type L at all
RHasFormRules	Concept: action A declares a static constexpr formRules member (a RuleList<...>). Mirrors detail::HasOptionalFields
RHasExplicitSubmit	Concept: action A declares a static constexpr bool explicitSubmit, opting its form out of auto-submit-on-validity
Nmodel
RHasPayloadShapeInner	Satisfied when T's tag also names an inner type to render inside it (a transparent wrapper)
RHasPayloadShapeTag	Satisfied when T declares a stable shape tag
RKeyedModel	Satisfied by model types that have a primary key, however it was named
RModelKey	Key types a model may declare as its PrimaryKey
RRawModelKey	Key types that are themselves a wire-encodable scalar
RWrappedModelKey	Key types that wrap a RawModelKey — the ladder's strong ids
Nreactive
RExhaustiveUpdate	An update that handles every message: Update& is invocable as (ViewState&, Alt const&) for each alternative Alt of the std::variant Msg. Any Msg that is not a std::variant is never satisfied
Ntable
Ndetail
RMemberWrapper	A type glaze writes as one of its own members, as morph's Ranged, Choice, Multiline and Tagged are: its glz::meta value is a member pointer
Nui
Nauthor
Ndetail
RScalarLiteral	Satisfied by a C++ scalar a builder writes as a document constant
RLiteral	Satisfied by a C++ value a builder writes as a document constant: a scalar, a list of scalars, or a ui::Value
ROperand	Satisfied by an operand of an expression operator: a handle or a constant
RHandleOperands	Satisfied when two operands are operands and at least one is a handle, so the builders' operators never apply to two plain C++ values
RRuns	Satisfied when Model runs Action: the model has an execute that takes it
RViewDescriptor	A view descriptor: a views:: kind and the registered query action it lists
RWizardDescriptor	A flows::Wizard: a title and its steps
Ndetail
RConstantConvertible	Whether From may become a constant Prop<To>: an implicit conversion that does not silently change the kind of value
Nunits
RUnitEnum	Concept: an enum with a UnitTraits specialisation (template param E)
RHasUnitRelations	Concept: UnitTraits<E> also declares within-dimension relations (template param E)
RHasUnitBounds	Concept: UnitTraits<E> declares an optional static constexpr QuantityBounds bounds(E) — the pre-decode validation seam a field's unit opts into. A unit enum with no bounds() simply has none: every value its precision allows is accepted, unchanged from before this feature existed. E is the application's unit enum type
RRatioConvertible	Concept: the auto-generated ratio convert applies to From → To (template params From, To)
RHasUserConvert	Concept: the application supplied a UnitTraits<E>::convert static for this pair (a non-ratio override, e.g. °C → °F) (template params From, To)
RConvertible	Concept: From → To is convertible — a user override takes precedence over an auto-generated ratio path (template params From, To)