Struct Intent 

pub struct Intent {
    pub nix: Option<NixIntent>,
    pub flux: Option<FluxIntent>,
    pub lisp: Option<LispIntent>,
    pub container: Option<ContainerIntent>,
    pub aplicacao: Option<AplicacaoIntent>,
    pub guest: Option<GuestIntent>,
}

Intent — exactly one variant should be populated.

Fields

nix: Option<NixIntent>

flux: Option<FluxIntent>

lisp: Option<LispIntent>

container: Option<ContainerIntent>

aplicacao: Option<AplicacaoIntent>

guest: Option<GuestIntent>

Implementations

impl Intent

pub fn variant(&self) -> Result<IntentVariant<'_>, IntentError>

Resolve to exactly one variant. Errors on zero or many.

One-line inherent forwarder that delegates the sweep body to the substrate primitive crate::tagged_union::TaggedUnion::variant — every production .variant() site on ProcessSpec dispatches through this ONE default body so the resolve-sweep pattern lives at ONE substrate site. The inherent surface stays load-bearing so consumer callsites don’t need use TaggedUnion.

pub fn has(&self, kind: IntentKind) -> bool

Presence probe — does this tagged union carry a populated slot addressed by the given closed-set discriminator?

One-line inherent forwarder that delegates to the substrate primitive crate::tagged_union::TaggedUnion::has — every closed-set-driven presence check on ProcessSpec dispatches through this ONE default body so the per-slot spec.<field>.is_some() pattern lives at ONE substrate site. The inherent surface stays load-bearing so consumer callsites don’t need use TaggedUnion.

pub fn find(&self, kind: IntentKind) -> Option<IntentVariant<'_>>

Widened peer of Self::has — returns the borrowed variant view addressed by kind, or None when the matching slot is empty.

One-line inherent forwarder that delegates to the substrate primitive crate::tagged_union::TaggedUnion::find, whose default body is kind.select(self). Every closed-set-driven kind.select(&parent) callsite that pre-lift required use VariantSelector at the caller now reads parent.find(kind) through the inherent surface, byte-for-byte symmetrical with parent.has(kind). The composition law parent.has(kind) == parent.find(kind).is_some() is pinned as a first-class typed invariant by the trait’s own has default body (self.find(kind).is_some()), swept substrate-wide by crate::tagged_union::assert_find_agrees_with_has.

pub fn populated_kinds(&self) -> Vec<IntentKind>

Closed-set-inversion peer of Self::has / Self::find — returns the canonical-ordered Vec of populated ClosedSet::ALL discriminators.

One-line inherent forwarder that delegates to the substrate primitive crate::tagged_union::TaggedUnion::populated_kinds, whose default body is <Kind as ClosedSet>::ALL.iter().copied().filter(|k| self.has(*k)).collect(). Every consumer that needs to enumerate which slots on a tagged-union parent are populated (an operator-facing “Ambiguous named [Nix, Container]” diagnostic composed on the malformed arm; a closed-set audit dispatcher; a populated-kind-count-<n> require-tag classifier prefix) reads parent.populated_kinds() through the inherent surface, byte-for-byte symmetrical with parent.has(kind) / parent.find(kind). The composition law parent.populated_kinds().contains(&k) == parent.has(k) is pinned as a first-class typed invariant by the trait’s own default body and swept substrate-wide by crate::tagged_union::assert_populated_kinds_matches_has.

pub fn populated_kind_count(&self) -> usize

Scalar cardinality peer of Self::populated_kinds — the number of populated slots on this tagged union.

One-line inherent forwarder that delegates to the substrate primitive crate::tagged_union::TaggedUnion::populated_kind_count, whose default body is <Kind as ClosedSet>::ALL.iter().copied().filter(|k| self.has(*k)).count(). Every consumer that needs the cardinality of the populated-slot set as a scalar (a populated-kind-count-<n> require-tag classifier prefix; a fast-path branch on the Ambiguous-arm side that discriminates “well-formed” from “malformed with N slots”; a coherence check that verifies “every well-formed parent has exactly one populated slot”) reads parent.populated_kind_count() through the inherent surface, byte-for-byte symmetrical with parent.has(kind) / parent.find(kind) / parent.populated_kinds(). The composition law parent.populated_kind_count() == parent.populated_kinds().len() is pinned as a first-class typed invariant by the trait’s own default body and swept substrate-wide by crate::tagged_union::assert_populated_kind_count_matches_populated_kinds.

pub fn missing_kinds(&self) -> Vec<IntentKind>

Closed-set-COMPLEMENT peer of Self::populated_kinds — returns the canonical-ordered Vec of EMPTY ClosedSet::ALL discriminators.

One-line inherent forwarder that delegates to the substrate primitive crate::tagged_union::TaggedUnion::missing_kinds, whose default body is <Kind as ClosedSet>::ALL.iter().copied().filter(|k| !self.has(*k)).collect(). Every consumer that needs to enumerate which slots on a tagged-union parent are ABSENT (an operator-facing “still missing [Nix, Container]” diagnostic on the partially-populated arm; a coherence check verifying “every process boundary carries every intent slot”; a missing-<kind> require-tag classifier arm) reads parent.missing_kinds() through the inherent surface, byte-for-byte symmetrical with parent.populated_kinds(). The partition law parent.populated_kinds() ∪ parent.missing_kinds() == ClosedSet::ALL (with the two sets disjoint) is pinned as a first-class typed invariant by the trait’s own default body and swept substrate-wide by crate::tagged_union::assert_missing_kinds_matches_has.

pub fn missing_kind_count(&self) -> usize

Scalar cardinality peer of Self::missing_kinds — the number of EMPTY slots on this tagged union.

One-line inherent forwarder that delegates to the substrate primitive crate::tagged_union::TaggedUnion::missing_kind_count, whose default body is <Kind as ClosedSet>::ALL.iter().copied().filter(|k| !self.has(*k)).count(). Every consumer that needs the cardinality of the missing-slot set as a scalar (a missing-kind-count-<n> require-tag classifier prefix; a fast-path branch that discriminates “well-formed” from “N missing slots”; a coherence check that verifies “every well-formed parent has exactly ALL.len() - 1 missing slots”) reads parent.missing_kind_count() through the inherent surface, byte-for-byte symmetrical with parent.populated_kind_count(). The scalar partition law parent.populated_kind_count() + parent.missing_kind_count() == <Kind as ClosedSet>::ALL.len() is pinned by the trait’s own default body and swept substrate-wide by crate::tagged_union::assert_missing_kind_count_matches_missing_kinds.

pub fn first_populated_kind(&self) -> Option<IntentKind>

Short-circuiting Option<$kind> peer of Self::populated_kinds — the FIRST populated kind on this tagged union in canonical ClosedSet::ALL order, or None when no slot is populated.

One-line inherent forwarder that delegates to the substrate primitive crate::tagged_union::TaggedUnion::first_populated_kind, whose default body is <Kind as ClosedSet>::ALL.iter().copied().find(|k| self.has(*k)). Every consumer that needs the earliest populated slot on a tagged-union parent as an Option<Kind> (an operator-facing “Ambiguous, starting at Nix” diagnostic on the malformed arm; a first-populated-<kind> require-tag classifier arm; a fast-path branch that discriminates “empty” from “any populated”) reads parent.first_populated_kind() through the inherent surface, byte-for-byte symmetrical with parent.populated_kinds() / parent.has(kind). The composition law parent.first_populated_kind() == parent.populated_kinds().first().copied() is pinned as a first-class typed invariant by the trait’s own default body and swept substrate-wide by crate::tagged_union::assert_first_populated_kind_matches_populated_kinds.

pub fn first_missing_kind(&self) -> Option<IntentKind>

Short-circuiting Option<$kind> peer of Self::missing_kinds — the FIRST missing kind on this tagged union in canonical ClosedSet::ALL order, or None when EVERY slot is populated.

One-line inherent forwarder that delegates to the substrate primitive crate::tagged_union::TaggedUnion::first_missing_kind, whose default body is <Kind as ClosedSet>::ALL.iter().copied().find(|k| !self.has(*k)). Byte-for-byte symmetrical with parent.first_populated_kind() under a negated predicate; the two primitives PARTITION ClosedSet::ALL’s earliest-element projection on the (populated, missing) split. The composition law parent.first_missing_kind() == parent.missing_kinds().first().copied() is pinned as a first-class typed invariant by the trait’s own default body and swept substrate-wide by crate::tagged_union::assert_first_missing_kind_matches_missing_kinds.

impl Intent

pub fn has_workload_kind(&self, kind: WorkloadKind) -> bool

Presence probe over the container-intent workload-kind axis — true iff the IntentKind::Container slot is populated AND its ContainerIntent::workload_kind equals kind.

Peer to Intent::has on a different composition axis

Intent::has (macro-generated via crate::declare_tagged_union_impls!) addresses the outer closed set IntentKind — “which of the six tagged-union slots is populated”. This method addresses a nested closed set WorkloadKind living on the required ContainerIntent::workload_kind field inside the optional Intent::container slot — “given that the intent IS a container, which K8s workload kind (Deployment / StatefulSet / DaemonSet / Job / CronJob) does it render into”. The two axes are orthogonal: an operator can ask both intent-container (this intent variant is a container) AND workload-kind-Job (specifically a Job-shaped container) against the SAME [ProcessSpec], and each answers independently. Every non-Container intent variant returns false for every WorkloadKind here — the Option-hop through self.container gates the inner scalar comparison so a Nix / Flux / Lisp / Aplicacao / Guest intent has no workload-kind axis to inhabit.

Fresh (Required-parent × Option-variant-inner × required-scalar-child) corner

The presence-probe algebra the workspace publishes across tatara-process spans a (parent-shape × child-shape) taxonomy. Prior probes cover:

• Required-parent × tagged-union-child (Intent::has, crate::lifetime::Lifetime::has) — the outer variant is the discriminator.
• Required-parent × required-struct × tagged-union-child (crate::boundary::Boundary::has_condition_kind) — a slice-level walk over required-parent’s inner slice.
• Required-parent × nested-struct-scalar-child (crate::classification::Classification::has_horizon_kind, crate::classification::Classification::has_optimization_direction).
• Option-parent × slice-child (spec.lifetime.resolved_ephemeral() .is_some_and(|e| e.exports.has_when(kind)) on the four export-facing axes).
• Option-parent × defaulted-scalar-child (crate::lifetime::EphemeralLifetime::has_teardown_policy, crate::routing::RoutingSpec::has_form).
• Option-parent × required-struct × tagged-union-child (crate::encapsulates::EncapsulatesSpec::has_mode + the spec.encapsulates.as_ref().is_some_and(|e| e.kind.has(kind)) walk).

This probe opens a FRESH corner: (Required-parent × Option-variant-inner × required-scalar-child). The parent Intent is required on crate::crd::ProcessSpec; the Intent::container slot is an Option<ContainerIntent>; the ContainerIntent::workload_kind field is a required scalar. No prior family reaches THROUGH one specific slot of a required-parent tagged-union to a scalar field on that slot’s payload; every other tagged-union walk addresses the variant itself. A future co-tenant on the same corner — a hypothetical spec.intent.aplicacao_profile_family() probing AplicacaoIntent::profile’s canonicalized family, a spec.intent.lisp_dialect() probing LispIntent::reader against a closed set of registered dialects — lands as one more inherent method here with the same self.<variant>.as_ref().is_some_and(|v| v.<field> == kind) three-step shape.

Compounding

The workload-kind-<kind> require-tag prefix family in tatara-reconciler::bin::tatara-check::evaluate_point_require_tag composes this primitive with the closed-set WorkloadKind’s autoderived FromStr through the strip_and_classify_prefixed_kind substrate to publish the TWENTY-FIRST closed-set-driven prefix family byte-for-byte symmetrical with the twenty peer families rooted at their own has_<field> primitives.

A future sixth WorkloadKind variant added to ALL (a hypothetical ReplicaSet for pre-Deployment replica-set direct emission, or a Pod for singleton naked-pod containers) reaches this probe through ONE ALL entry + one as_str arm + one api_version arm + one is_batch arm with no per-caller edit at the require-tag classifier and no per-consumer restatement of the self.container.as_ref().is_some_and(|c| c.workload_kind == kind) closure body.

Theory

THEORY.md §II.1 invariant 5 — composition preserves proofs; the per-container workload_kind comparison lives at ONE substrate site so every downstream (require-tag classifier, coherence check, editor completion, future workload-kind- driven audit dispatcher) binds through the SAME has_workload_kind(kind) shape rather than restating the spec.intent.container.as_ref().is_some_and(...) closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future WorkloadKind variant lands at ONE ALL entry + one as_str arm on the closed set and the presence probe picks it up mechanically without further per-consumer edits.

Trait Implementations

impl Clone for Intent

fn clone(&self) -> Intent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Intent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Intent

fn default() -> Intent

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Intent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Intent

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Serialize for Intent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TaggedUnion for Intent

const KIND_LIST: &'static str = INTENT_KIND_LIST

Slash-joined operator diagnostic literal — the payload of TaggedUnionError::empty when no slot is populated on this tagged union. Pinned against <Self::Kind as tatara_closed_set::ClosedSet>::labels_joined("/") by assert_kind_list_matches_closed_set so a variant added to Self::Kind without updating this constant (or a renamed variant) fails-loudly at the testkit boundary.

type Kind = IntentKind

The closed-set discriminator over this tagged-union’s variants. Bound to tatara_closed_set::ClosedSet so the generic diagnostic-stability testkit (assert_kind_list_matches_closed_set) can project <Self::Kind as ClosedSet>::labels_joined("/") against Self::KIND_LIST byte-identically. Additionally bound to VariantSelector<Self> so Self::variant’s default body can dispatch k.select(self) at each [ClosedSet::ALL] entry generically.

type Error = IntentError

The typed error carrier returned by the parent’s inherent .variant() method — projects onto the shared TaggedUnionError contract so resolve_or_err’s two-arm dispatch reaches every implementor uniformly.

fn variant( &self, ) -> Result<<Self::Kind as VariantSelector<Self>>::Variant<'_>, Self::Error>

Sweep over every Self::Kind discriminator in ClosedSet::ALL order, projecting each into the parent’s borrowed variant view via VariantSelector::select, and resolve to exactly one populated variant through resolve_or_err. Errors on zero (with Self::KIND_LIST carried on the TaggedUnionError::empty arm) or many.

fn find( &self, kind: Self::Kind, ) -> Option<<Self::Kind as VariantSelector<Self>>::Variant<'_>>

Widened peer of Self::has — projects a &'a Self borrow into the optional borrowed-variant view addressed by kind, or None when the matching slot on Self is empty.

fn has(&self, kind: Self::Kind) -> bool

Presence probe — does this tagged union carry a populated slot addressed by the given closed-set discriminator?

fn populated_kinds(&self) -> Vec<Self::Kind>

Closed-set-inversion refinement — enumerate the set of Self::Kind discriminators whose corresponding slot on self is populated, in canonical ClosedSet::ALL order.

fn populated_kind_count(&self) -> usize

Scalar cardinality refinement on the closed-set-inversion axis — the number of Self::Kind discriminators whose corresponding slot on self is populated.

fn missing_kinds(&self) -> Vec<Self::Kind>

Closed-set-COMPLEMENT refinement — enumerate the set of Self::Kind discriminators whose corresponding slot on self is EMPTY, in canonical ClosedSet::ALL order.

fn missing_kind_count(&self) -> usize

Scalar cardinality refinement on the closed-set-complement axis — the number of Self::Kind discriminators whose corresponding slot on self is EMPTY.

fn first_populated_kind(&self) -> Option<Self::Kind>

Short-circuiting Option<Self::Kind> peer of Self::populated_kinds — the FIRST populated kind on this tagged union in canonical ClosedSet::ALL order, or None when no slot is populated.

fn first_missing_kind(&self) -> Option<Self::Kind>

Short-circuiting Option<Self::Kind> peer of Self::missing_kinds — the FIRST missing kind on this tagged union in canonical ClosedSet::ALL order, or None when EVERY slot is populated.

impl VariantSelector<Intent> for IntentKind

type Variant<'a> = IntentVariant<'a>

The borrowed-view enum returned by the parent’s inherent .variant() method — one arm per closed-set variant, each arm carrying a &'a reference into the parent’s populated slot. Bound generically here so TaggedUnion::variant’s default body can name the return type without restating it per parent. Additionally bound to VariantKind<Self> so the reverse projection Variant<'a> → Self is closed at the trait boundary — every implementor’s borrowed view knows its addressing Kind through ONE typed contract, and the substrate testkit assert_variant_round_trip composes select (forward) with variant_kind (reverse) generically.

fn select<'a>(self, parent: &'a Intent) -> Option<IntentVariant<'a>>

where Self: 'a,

Project a &'a P borrow into the optional typed variant view for self (the addressed discriminator). Returns None iff the matching slot on P is None. Composes the closed-set sweep TaggedUnion::variant loops over.