Enum Expression 

pub enum Expression<'a> {
    Number(f64),
    Bool(bool),
    Str(&'a str),
    Symbol(&'a str),
    List(Vec<Expression<'a>>),
    Null,
}

Represents an S-expression as a borrowed data structure.

This enum provides zero-copy access to parsed S-expressions by borrowing string slices from the original source. This is ideal for compiler use cases where you need to parse expressions without taking ownership of the data.

Examples

use sexpression::Expression;
 
// Numbers
let num = Expression::Number(42.0);
 
// Symbols
let sym = Expression::Symbol("define");
 
// Lists
let list = Expression::List(vec![
    Expression::Symbol("+"),
    Expression::Number(1.0),
    Expression::Number(2.0)
]);

Variants

Number(f64)

A numeric literal (f64)

Bool(bool)

A boolean literal

Str(&'a str)

A string literal (borrowed from source)

Symbol(&'a str)

A symbol/identifier (borrowed from source)

List(Vec<Expression<'a>>)

A list of expressions

Null

A null value

Implementations

impl<'a> Expression<'a>

pub fn to_owned(&self) -> OwnedExpression

Convert a borrowed expression to an owned expression.

This method allocates new strings for all string and symbol data, allowing the resulting expression to outlive the original source.

Examples

use sexpression::Expression;
 
let borrowed = Expression::Symbol("hello");
let owned = borrowed.to_owned();
assert_eq!(owned, sexpression::OwnedExpression::Symbol("hello".to_string()));

Trait Implementations

impl<'a> Debug for Expression<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Expression<'a>

fn eq(&self, other: &Expression<'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> StructuralPartialEq for Expression<'a>