Enum ExprNode 

pub enum ExprNode {
    Distribution {
        variables: VarSetId,
        conditioned_on: VarSetId,
        intervention: InterventionSetId,
        domain: DomainRef,
    },
    Product(ExprListId),
    SumOut {
        variables: VarSetId,
        expr: ExprId,
    },
    IntegralOut {
        variables: VarSetId,
        expr: ExprId,
    },
    Ratio {
        numerator: ExprId,
        denominator: ExprId,
    },
    Expectation {
        function: OutcomeExprId,
        distribution: ExprId,
    },
    Contrast {
        left: ExprId,
        right: ExprId,
        op: ContrastOp,
    },
}

Semantic expression node (no derivation metadata).

Variants

Distribution

Joint / conditional distribution factor.

Fields

variables: VarSetId

Variables in the factor.

conditioned_on: VarSetId

Conditioning set.

intervention: InterventionSetId

Intervention set (empty for observational).

domain: DomainRef

Domain.

Product(ExprListId)

Product of factors.

SumOut

Discrete marginalization.

Fields

variables: VarSetId

Variables summed out.

expr: ExprId

Body.

IntegralOut

Continuous marginalization.

Fields

variables: VarSetId

Variables integrated out.

expr: ExprId

Body.

Ratio

Ratio of expressions.

Fields

numerator: ExprId

Numerator.

denominator: ExprId

Denominator.

Expectation

Expectation of an outcome under a distribution.

Fields

function: OutcomeExprId

Outcome function.

distribution: ExprId

Distribution expression.

Contrast

Contrast of two expectations / functionals.

Fields

left: ExprId

Left side.

right: ExprId

Right side.

op: ContrastOp

Operator.

Trait Implementations

impl Clone for ExprNode

fn clone(&self) -> ExprNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprNode

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

Formats the value using the given formatter.

impl Eq for ExprNode

impl Hash for ExprNode

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 ExprNode

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ExprNode