Enum Expr 

pub enum Expr {
    Num(f64, Option<Span>),
    Str(String, Option<Span>),
    Sym(String, Option<Span>),
    Proc(Proc, Option<Span>),
    List(List, Option<Span>),
    Foreign(Foreign),
    TailCall {
        proc: Proc,
        args: List,
        context: EvalContext,
    },
}

The enum that represents all expression variants in the Rusche language.

Variants

Num(f64, Option<Span>)

A 64-bit floating number value.

Str(String, Option<Span>)

A string value.

Sym(String, Option<Span>)

A symbol value.

Proc(Proc, Option<Span>)

A procedure value. There are 3 types of procedures in Rusche:

• Proc::Native: implemented in Rust
• Proc::Closure: user-defined via lambda form
• Proc::Macro: user-defined via defmacro form

List(List, Option<Span>)

A list value. It can be either a cons cell or an empty list.

Foreign(Foreign)

A foreign object value. This is used to store Rust objects in the interpreter.

TailCall

A special case for tail-call optimization. Internal use only.

Fields

proc: Proc

args: List

context: EvalContext

Implementations

impl Expr

pub fn is_atom(&self) -> bool

Returns true if the expression is an atom. Every expresssion that is not a cons cell list is an atom.

pub fn is_nil(&self) -> bool

Return true if the expression is an empty list.

pub fn is_truthy(&self) -> bool

Returns true if the expression can be considered to be truthy. In Rusche, only the empty list (List::Nil) is considered to be falsy.

pub fn span(&self) -> Option<Span>

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate 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, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&str> for Expr

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<List> for Expr

fn from(val: List) -> Self

Converts to this type from the input type.

impl<'a> From<ListIter<'a>> for Expr

fn from(value: ListIter<'_>) -> Self

Converts to this type from the input type.

impl From<String> for Expr

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<Vec<Expr>> for Expr

fn from(value: Vec<Expr>) -> Self

Converts to this type from the input type.

impl From<bool> for Expr

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<f64> for Expr

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i32> for Expr

fn from(value: i32) -> Self

Converts to this type from the input type.

impl PartialEq for Expr

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.