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<'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 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.

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> Copy for Expr<'a>

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

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