Struct Let 

pub struct Let {
    pub span: SourceSpan,
    pub name: Identifier,
    pub value: Expr,
    pub body: Vec<Statement>,
}

A let statement binds name to the value of expr in body.

Fields

span: SourceSpan

name: Identifier

The identifier to be bound

value: Expr

The expression to bind

body: Vec<Statement>

The statements for which this binding will be visible.

For example, given the following:

integrity_constraints {
    let x = 2
    let y = x^2
    enf clk = x
    enf clk' = clk + y
}

When parsed, the syntax tree for the integrity_constraints block would have a single Statement, the Let corresponding to let x = 2. The body of that let would also contain a single Statement, another Let corresponding to let y = x^2, which in turn would contain the two constraint statements in its body.

In other words, when present, a Let introduces a new block/lexical scope, and all subsequent statements are included in that block. The body of a Let is that block. A Let will always be the final statement in its containing block, e.g. integrity_constraints, but may be preceded by any number of non-Let statements.

Implementations

impl Let

pub fn new( span: SourceSpan, name: Identifier, value: Expr, body: Vec<Statement>, ) -> Self

pub fn ty(&self) -> Option<Type>

Return the type of the overall let expression.

A let with an empty body, or with a body that terminates with a non-expression statement has no type (or rather, one could consider the type it returns to be of “void” or “unit” type).

For let statements with a non-empty body that terminates with an expression, the let can be used in expression position, producing the value of the terminating expression in its body, and having the same type as that value.

Trait Implementations

impl Clone for Let

fn clone(&self) -> Let

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Let

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

Formats the value using the given formatter.

impl PartialEq for Let

fn eq(&self, other: &Self) -> 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 Spanned for Let

fn span(&self) -> SourceSpan

impl TryFrom<Let> for Expr

type Error = InvalidExprError

The type returned in the event of a conversion error.

fn try_from(expr: Let) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Let