Enum UniversalAnswer 

pub enum UniversalAnswer {
    Kind {
        name: &'static str,
    },
    Owner {
        owner: OwnerFact,
    },
    CausingDeclarations {
        commitment: Identity<CapturedDeclaration>,
        dependencies: Bounded<Identity<CapturedDeclaration>, DEPENDENCY_LIMIT>,
    },
    Profile {
        profile: Profile,
    },
    OutputAndDigest {
        outputs: Bounded<AnsweredOutput, MEMBERSHIP_LIMIT>,
    },
    Assumptions {
        assumptions: Bounded<OwnerFact, ASSUMPTION_LIMIT>,
    },
    Invalidators {
        triggers: InvalidationSet,
    },
    RelatedDispositions {
        related: Bounded<RelatedDisposition, RELATED_KIND_LIMIT>,
    },
    Repairs {
        repairs: Bounded<Repair, REPAIR_LIMIT>,
    },
}

One typed answer to a universal question.

Every arm carries the exact values that answer its row — identities, typed rosters, typed dispositions — and never a sentence standing in for a fact.

Variants

Kind

The kind this output is.

Fields

name: &'static str

The kind’s declared name.

Owner

The owner fact that required it.

Fields

owner: OwnerFact

The requiring fact.

CausingDeclarations

The declarations it was derived from.

Fields

commitment: Identity<CapturedDeclaration>

The content commitment the request walked in with.

dependencies: Bounded<Identity<CapturedDeclaration>, DEPENDENCY_LIMIT>

The captures that content declares it stands on.

Profile

The profile it was decided under.

Fields

profile: Profile

The profile, at the version it was decided at.

OutputAndDigest

Every member it is, and the digest proved over each one’s rendered bytes.

The complete set in roster order, never a chosen row: a kind’s roster may fill several seats, and an answer naming one of them would be coverage-complete syntax over a flattened denominator — the second output’s identity and digest simply absent from a view that claims the whole expansion. Each row is two values because they come from two places: the member is what the plan declared, and the digest is what the closure proved.

Fields

outputs: Bounded<AnsweredOutput, MEMBERSHIP_LIMIT>

One row per rendered seat, in roster order; never empty in a lawful expansion, because a rendering is structurally non-empty — and completion refuses a set that does not restate the proof’s own roster, so a shortened or reordered answer cannot ride a coverage-complete view.

Assumptions

The owner facts it rests on.

Fields

assumptions: Bounded<OwnerFact, ASSUMPTION_LIMIT>

The assumed facts.

Invalidators

The triggers whose change makes it stale.

Fields

triggers: InvalidationSet

The watch set.

RelatedDispositions

What happened to every kind it is related to.

Fields

related: Bounded<RelatedDisposition, RELATED_KIND_LIMIT>

The accounted kinds.

Repairs

The owner-declared repairs that apply.

Fields

repairs: Bounded<Repair, REPAIR_LIMIT>

The declared repairs.

Implementations

impl UniversalAnswer

pub const fn slot(&self) -> u8

This answer’s position in the declared roster, written ahead of its own material.

Not the question’s position stated twice: the question is what was ASKED and this is which answer SHAPE was given. They agree today because the table above is one-to-one, and a roster that ever admitted two shapes for one question would separate them here rather than deriving one preimage for both. A position is appended and never renumbered.

Trait Implementations

impl Answer for UniversalAnswer

type Question = UniversalQuestion

The roster this answer belongs to.

fn question(&self) -> UniversalQuestion

The question this answer answers.

fn encode_into(&self, into: &mut Vec<u8>)

Append this answer’s canonical bytes.

fn human(&self) -> String

This answer rendered for a person.

impl Clone for UniversalAnswer

fn clone(&self) -> UniversalAnswer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UniversalAnswer

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

Formats the value using the given formatter.

impl Eq for UniversalAnswer

impl Hash for UniversalAnswer

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for UniversalAnswer

fn eq(&self, other: &UniversalAnswer) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for UniversalAnswer