Struct Relation

pub struct Relation {
    pub expression: Expression,
    pub operator: Operator,
    pub range_list: RangeList,
}

An incomplete AST representation of a plural rule. Comprises an Expression, an Operator, and a RangeList.

🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways, including in SemVer minor releases. In particular, the `DataProvider` implementations are only guaranteed to match with this version's `*_unstable` providers. Use with caution.

Examples

All AST nodes can be built explicitly, as seen in the example. However, due to its complexity, it is preferred to build the AST using the parse() function.

"i = 3"

Can be represented by the AST:

use icu::plurals::provider::rules::reference::ast::*;

Relation {
    expression: Expression {
        operand: Operand::I,
        modulus: None,
    },
    operator: Operator::Eq,
    range_list: RangeList(vec![RangeListItem::Value(Value(3))]),
};

Fields

expression: Expression

The plural operand variable that optionally includes an application of modulo arithmetic.

operator: Operator

The operator (equals, not equals) indicating whether the resolved expression value at runtime should match the set of possible values in range_list. Note: Operator::Eq effectively means “is contained within the set of”.

range_list: RangeList

A sequence of RangeListItem, each of which represents a scalar number or a numerical range, that creates the interval set within which expression’s resolved value should exist.

Trait Implementations

impl Clone for Relation

fn clone(&self) -> Relation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Relation

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

Formats the value using the given formatter.

impl PartialEq for Relation

fn eq(&self, other: &Relation) -> 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 Relation