Enum Expr 

pub enum Expr<A: AstTypes = DefaultTypes> {
    Omitted,
    Id(A::Path),
    MetId(A::MacroId),
    Lit(A::Literal),
    Use(Use<A>),
    Bind(Box<Bind<A>>),
    Make(Box<Make<A>>),
    Match(Box<Match<A>>),
    Op(Op, Vec<At<Self, A>>),
}

Expressions: The beating heart of Conlang.

A program in Conlang is a single expression which, at compile time, sets up the state in which a program will run. This expression binds types, functions, and values to names which are exposed at runtime.

Whereas in the body of a function, do sequences are ordered, in the global scope (or subsequent module scopes, which are children of the global module,) do sequences are considered unordered, and subexpressions may be reordered in whichever way the compiler sees fit. This is especially important when performing import resolution, as imports typically depend on the order in which names are bound.

Variants

Omitted

Omitted by semicolon insertion-elision rules

Id(A::Path)

An identifier

MetId(A::MacroId)

An escaped token for macro binding

Lit(A::Literal)

A literal bool, string, char, or int

Use(Use<A>)

use Use

Bind(Box<Bind<A>>)

let Pat::NoTopAlt (= expr (else expr)?)? | (fn | mod | impl) Pat::Fn Expr

Make(Box<Make<A>>)

Expr { (Ident (: Expr)?),* }

Match(Box<Match<A>>)

match Expr { (Pat => Expr),* }

Op(Op, Vec<At<Self, A>>)

Op Expr | Expr Op | Expr (Op Expr)+ | Op Expr Expr else Expr

Implementations

impl<A: AstTypes> Expr<A>

pub const fn at(self, annotation: A::Annotation) -> At<Expr<A>, A>

Attaches this Expr to an At node with the provided Annotation.

pub fn and_do(self, annotation: A::Annotation, other: At<Expr<A>, A>) -> Self

Attaches another expression to this one, continuing a do chain if possible.

pub fn to_tuple(self, annotation: A::Annotation) -> Self

Turns this expression into a tuple if it isn’t already one.

pub const fn is_place(&self) -> bool

Returns whether self is a “place projection” expression (identifier, index, dot, or deref)

pub const fn is_value(&self) -> bool

Returns whether self is NOT a “place projection” expression

pub const fn as_slice(&self) -> Option<(Op, &[At<Expr<A>, A>])>

If self is an Expr::Op, returns the Op and a slice of its arguments.

Trait Implementations

impl<A: Clone + AstTypes> Clone for Expr<A>

where A::Path: Clone, A::MacroId: Clone, A::Literal: Clone,

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 + AstTypes> Debug for Expr<A>

where A::Path: Debug, A::MacroId: Debug, A::Literal: Debug,

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

Formats the value using the given formatter.

impl<A: AstTypes> Display for Expr<A>

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

Formats the value using the given formatter.

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for Expr<A>

type Out = Expr<B>

The return type of the associated Fold function

fn fold_in<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Calls Self’s appropriate Folder function(s)

fn children<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Destructures self, calling Foldable::fold_in on all foldable members, and rebuilds a Self out of the results.

impl<A: Hash + AstTypes> Hash for Expr<A>

where A::Path: Hash, A::MacroId: Hash, A::Literal: Hash,

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: AstTypes> Match<A> for Expr<A>

fn recurse(sub: &mut Subst<A>, pat: &Self, expr: &Self) -> bool

Implements recursive Subst-building for Self

fn apply(&mut self, sub: &Subst<A>)

With self as the pattern, recursively applies the Subst

fn apply_rule(&mut self, pat: &Self, template: &Self) -> bool

where Self: Sized + Clone,

Applies a substitution rule from pat to template on self

fn match_with(&self, pat: &Self) -> Option<Subst<A>>

Matches self against the provided pattern

impl<A: PartialEq + AstTypes> PartialEq for Expr<A>

where A::Path: PartialEq, A::MacroId: PartialEq, A::Literal: PartialEq,

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, A: AstTypes> Walk<'a, A> for Expr<A>

fn children<V: Visit<'a, A> + ?Sized>( &'a self, v: &mut V, ) -> Result<(), V::Error>

fn visit_in<V: Visit<'a, A> + ?Sized>( &'a self, v: &mut V, ) -> Result<(), V::Error>

impl<A: Eq + AstTypes> Eq for Expr<A>

where A::Path: Eq, A::MacroId: Eq, A::Literal: Eq,

impl<A: AstTypes> StructuralPartialEq for Expr<A>