Enum Expr

#[non_exhaustive]
pub enum Expr {
    Num(i32),
    Dice(Dice),
    Neg(Box<Self>),
    Add(Box<Self>, Box<Self>),
    Sub(Box<Self>, Box<Self>),
    Mul(Box<Self>, Box<Self>),
    DivDown(Box<Self>, Box<Self>),
    DivUp(Box<Self>, Box<Self>),
}

Tree structure of individual elements of a full mathematical dice expression

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Num(i32)

Standalone integer

Dice(Dice)

Dice literal

Neg(Box<Self>)

Negation of an expression (makes the result of it negative)

Add(Box<Self>, Box<Self>)

Sum of two expressions

Sub(Box<Self>, Box<Self>)

Difference of two expressions

Mul(Box<Self>, Box<Self>)

Product of two expressions

DivDown(Box<Self>, Box<Self>)

Integer quotient of two expressions (rounded down)

DivUp(Box<Self>, Box<Self>)

Integer quotient of two expressions (rounded up)

Implementations

impl Expr

pub fn eval(&self, rng: &mut impl Roller) -> Result<Evaled<'_>, EvalError>

Evaluates the expression. For most types of expressions, this will directly result in a 1:1 equivalent Evaled, with the notable exception of Expr::Dice. For dice expressions, the dice they contain are rolled, resulting in an Evaled::Dice with the Rolled set of dice.

Errors

If there is an integer overflow or division error encountered during any operations, or if an error occurs during dice rolling, an error variant will be returned.

pub fn is_deterministic(&self) -> bool

Checks whether the expression is deterministic (will always yield the same value with every evaluation). A Self::Num will always return true, a Self::Dice will always return false unless the dice they contain only have one side, and all unary and binary expressions forward the check to their children.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Describe for Expr

fn describe(&self, _list_limit: Option<usize>) -> String

Builds a full usable expression string from the expressions. Operations are grouped with parentheses whenever the order of operations could be considered ambiguous, such as when mixing addition and multiplication together. All strings output from this should result in the exact same expression tree when re-parsing them.

list_limit does not affect the output of this implementation in any way since there are no possible lists of elements included, so it is always safe to pass None.

impl Display for Expr

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

Formats the value using the given formatter.

The output of this implementation is equivalent to Self::describe(None).

impl FromStr for Expr

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl GenParser<Expr> for Expr

fn parser<'src>() -> impl Parser<'src, &'src str, Self, Err<Rich<'src, char>>> + Clone

Generates a parser for this type that expects end of input. Requires the parse feature (enabled by default).

fn part_parser<'src>() -> impl Parser<'src, &'src str, Self, Err<Rich<'src, char>>> + Clone

Generates a parser for this type that parses up to the end of valid input. Requires the parse feature (enabled by default).

impl HasOpType for Expr

fn op_type(&self) -> OpType

Gets the type of this expression.

fn is_value(&self) -> bool

Checks whether this expression is a single value.

fn is_unary(&self) -> bool

Checks whether this expression is a unary operation.

fn is_additive(&self) -> bool

Checks whether this expression is an additive operation.

fn is_multiplicative(&self) -> bool

Checks whether this expression is a multiplicative operation.

fn is_binary(&self) -> bool

Checks whether this expression is a binary (additive or multiplicative) operation.

impl PartialEq for Expr

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

impl StructuralPartialEq for Expr