Enum poi::Expr

pub enum Expr {
    Sym(Symbol),
    Ret(Value),
    EOp(Op, Box<Expr>, Box<Expr>),
    Tup(Vec<Expr>),
    List(Vec<Expr>),
}

Function expression.

Variants

Sym(Symbol)

A symbol that is used together with symbolic knowledge.

Ret(Value)

Some function that returns a value, ignoring the argument.

This can also be used to store values, since zero arguments is a value.

EOp(Op, Box<Expr>, Box<Expr>)

A binary operation on functions.

Tup(Vec<Expr>)

A tuple for more than one argument.

List(Vec<Expr>)

A list.

Implementations

impl Expr

pub fn display( &self, w: &mut Formatter<'_>, parens: bool, rule: bool ) -> Result<(), Error>

Used to display format with additional options.

pub fn needs_parens(&self, parent_op: &Symbol, left: bool) -> bool

Returns true if the expression needs parentheses, given parent operation and side.

impl Expr

pub fn arity(&self) -> Option<usize>

Returns the arity of an expression.

Unfinished: This function requires analysis and unit testing.

impl Expr

pub fn equivalences(&self, knowledge: &[Knowledge]) -> Vec<(Expr, usize)>

Returns available equivalences of the expression, using a knowledge base.

pub fn contains_nan(&self) -> bool

Returns true if expressions contains NaN (not a number).

pub fn eval(&self, knowledge: &[Knowledge]) -> Result<Expr, Error>

Evaluate an expression using a knowledge base.

This combines reductions and inlining of all symbols.

pub fn reduce_all(&self, knowledge: &[Knowledge]) -> Expr

Reduces an expression using a knowledge base, until it can not be reduces further.

pub fn reduce_eval_all(&self, knowledge: &[Knowledge], eval: bool) -> Expr

Reduces an expression using a knowledge base, until it can not be reduces further.

pub fn reduce(&self, knowledge: &[Knowledge]) -> Result<(Expr, usize), Error>

Reduces expression one step using a knowledge base.

pub fn reduce_eval( &self, knowledge: &[Knowledge], eval: bool ) -> Result<(Expr, usize), Error>

Reduces expression one step using a knowledge base.

When eval is set to true, the EqvEval variants are reduced.

pub fn inline_all(&self, knowledge: &[Knowledge]) -> Result<Expr, Error>

Inlines all symbols using a knowledge base.

Ignores missing definitions in domain constraints.

pub fn inline( &self, sym: &Symbol, knowledge: &[Knowledge] ) -> Result<Expr, Error>

Inline a symbol using a knowledge base.

pub fn has_constraint(&self, arity_args: usize) -> bool

Returns true if a function has any constraints, false if there are none constraints.

This is used in the following rules in the standard library, using no_constr:

• ∀(f:!{}) => \true
• f:!{}([x..]) => f{(: vec)}(x)
• f:!{}(a)(a) <=> f{eq}(a)(a)

For example, to detect whether it is safe to insert a new constraint. This check is important because a constraint refers to one or more arguments. By introducing a new constraint that refers incorrectly to its argument, it leads to unsoundness.

A function has none constraints if it is applied enough times to cover existing constraints. This means the total arity of constraints is less or equal than the total arity of arguments.

To avoid unsoundness under uncertain edge cases, this function should return true. This is because the no_constr check fails to pattern match, which is safe, since inactive rules do not introduce unsoundness.

Unfinished: This function requires analysis and unit testing.

pub fn is_substitution(&self) -> bool

Returns true if expression is substitution.

pub fn has_non_constant_type_judgement(&self) -> bool

Returns true if expression has non-constant type judgement.

Trait Implementations

impl Add for Expr

type Output = Expr

The resulting type after applying the + operator.

fn add(self, other: Expr) -> Expr

Performs the + operation.

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy 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 Display for Expr

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

Formats the value using the given formatter.

impl Into<Expr> for &'static str

fn into(self) -> Expr

Converts this type into the (usually inferred) input type.

impl<T, U> Into<Expr> for (T, U)where T: Into<Expr>, U: Into<Expr>,

fn into(self) -> Expr

Converts this type into the (usually inferred) input type.

impl<T0, T1, T2> Into<Expr> for (T0, T1, T2)where T0: Into<Expr>, T1: Into<Expr>, T2: Into<Expr>,

fn into(self) -> Expr

Converts this type into the (usually inferred) input type.

impl Into<Expr> for Symbol

fn into(self) -> Expr

Converts this type into the (usually inferred) input type.

impl Into<Expr> for bool

fn into(self) -> Expr

Converts this type into the (usually inferred) input type.

impl Into<Expr> for f64

fn into(self) -> Expr

Converts this type into the (usually inferred) input type.

impl Mul for Expr

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, other: Expr) -> Expr

Performs the * operation.

impl PartialEq for Expr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Expr

fn partial_cmp(&self, other: &Expr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub for Expr

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, other: Expr) -> Expr

Performs the - operation.

impl StructuralPartialEq for Expr