Enum Expr 

pub enum Expr<'a> {
    Quantifier {
        quantifier: Quantifier,
        var_type: ActorOrEvent,
        restrictor: ExprRef,
        subformula: ExprRef,
    },
    Variable(Variable),
    Actor(Actor<'a>),
    Event(Event),
    Binary(BinOp, ExprRef, ExprRef),
    Unary(MonOp<'a>, ExprRef),
    Constant(Constant<'a>),
}

The basic expression type of the language of thought. Note that it does not include free variables or any of the machinery of the lambda calculus which is handled elsewhere.

Variants

Quantifier

A quantified expression. Variables are implemented with DeBruijn indices.

Fields

quantifier: Quantifier

What kind of quantifier

var_type: ActorOrEvent

The type of bound variable

restrictor: ExprRef

An expression defining the restrictor of the quantifier.

subformula: ExprRef

An expression defining the subformula of the quantifier.

Variable(Variable)

See Variable

Actor(Actor<'a>)

See Actor. Written a_NAME

Event(Event)

See Event. Written e_N where N is an integer.

Binary(BinOp, ExprRef, ExprRef)

Any binary function.

Unary(MonOp<'a>, ExprRef)

Any unary function.

Constant(Constant<'a>)

All constants.

Trait Implementations

impl<'a> Clone for Expr<'a>

fn clone(&self) -> Expr<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Expr<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for Expr<'a>

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 HashLambda for Expr<'_>

fn hash_expr<H: Hasher>(&self, state: &mut H)

Hash the expression (without paying attention to subtrees which should be handled RootedLambdaPool’s hash implementation)

impl<'a> LambdaLanguageOfThought for Expr<'a>

type Pool = LanguageExpression<'a>

The type of the executable syntax tree

type ConversionError = LambdaConversionError

Error for converting from RootedLambdaPool<T> to LambdaLanguageOfThought::Pool

fn n_children(&self) -> usize

Get the number of children of an expression.

fn inc_depth(&self) -> bool

Returns true if this is somewhere that can bind variables (e.g. should we increment debruijn indices

fn var_type(&self) -> Option<&LambdaType>

Returns the type of the bound variable at an instruction

fn get_children(&self) -> impl Iterator<Item = LambdaExprRef>

Given an expression, get an iterator of its children

fn change_children(&mut self, new_children: impl Iterator<Item = LambdaExprRef>)

Given a list of new references for all children of an expr, change its children.

fn remap_refs(&mut self, remap: &[usize])

Update the references such that LambdaExprRef(0) is remapped to LambdaExprRef(remap[0]). (Used in garbage collection).

fn get_type(&self) -> &LambdaType

Get the return type of an expression.

fn same_expr(&self, other: &Self) -> bool

Checks if two expressions are the same, ignoring their subtrees (so different children shouldn’t matter)

fn to_pool( pool: RootedLambdaPool<'_, Self>, ) -> Result<Self::Pool, Self::ConversionError>

Convert from a RootedLambdaPool<T> to LambdaLanguageOfThought::Pool. May return an error if there are any lambda terms left in the RootedLambdaPool<T> (e.g. not fully reduced).

fn get_arguments(&self) -> impl Iterator<Item = LambdaType>

Get the type of all children in order.

fn commutative(&self) -> bool

Checks whether an expression is commutative

impl<'a> Ord for Expr<'a>

fn cmp(&self, other: &Expr<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Expr<'a>

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

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> Copy for Expr<'a>

impl<'a> Eq for Expr<'a>

impl<'a> StructuralPartialEq for Expr<'a>