Struct ExprVariant 

pub struct ExprVariant {
    pub base: Box<Expr>,
    pub variant: VariantId,
}

Selects a variant of an embedded enum value.

Evaluates to the payload of base when it holds variant: the record of the variant’s fields, in declaration order, without the discriminant. Projections applied to it index that record with the variant’s local field positions, so project(variant(owner, Human), [1]) is the second field of Owner::Human, whatever the enum’s storage layout.

The selection carries no check of its own. A predicate over a selection must also require the variant; statement normalization in the engine conjoins an is_variant check for every selection a predicate’s operands reach. Lowering resolves the selection to the variant’s column expressions and the guard to a discriminant comparison; the node never reaches a driver.

Examples

variant(owner, Owner::Human)               // the Human payload
project(variant(owner, Owner::Human), [0]) // its first field

Fields

base: Box<Expr>

Expression evaluating to an enum value.

variant: VariantId

The variant whose payload is selected.

Trait Implementations

impl Clone for ExprVariant

fn clone(&self) -> ExprVariant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprVariant

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

Formats the value using the given formatter.

impl From<ExprVariant> for Expr

fn from(value: ExprVariant) -> Self

Converts to this type from the input type.

impl PartialEq for ExprVariant

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ExprVariant