Enum parsley::SExp

pub enum SExp {
    Atom(Primitive),
    List(Vec<SExp>),
}

An S-Expression. Can be parsed from a string via FromStr, or constructed programmatically.

Examples

use parsley::{NULL, SExp};
let null = "()".parse::<SExp>().unwrap();
assert_eq!(null, NULL);

use parsley::{NULL, SExp};
let null = SExp::List(Vec::new());
assert_eq!(null, NULL);

Variants

Atom(Primitive)

List(Vec<SExp>)

Implementations

impl SExp

pub fn eval(self, ctx: &mut Context) -> LispResult

Evaluate an S-Expression in a context.

The context will retain any definitions bound during evaluation (e.g. define, set!).

Examples

use parsley::{AsAtom, Context};
use parsley::SExp::{self, List};

let exp = List(vec![SExp::make_symbol("eq?"), 0.0.as_atom(), 1.0.as_atom()]);
let mut ctx = Context::base();
let result = exp.eval(&mut ctx);
assert_eq!(result.unwrap(), false.as_atom());

use parsley::{AsAtom, Context};
use parsley::SExp::{self, List};

let exp1 = List(vec![
    SExp::make_symbol("define"),
    SExp::make_symbol("x"),
    10.0.as_atom()
]);
let exp2 = SExp::make_symbol("x");

let mut ctx = Context::base();
exp1.eval(&mut ctx);
let result = exp2.eval(&mut ctx);
assert_eq!(result.unwrap(), 10.0.as_atom());

pub fn make_symbol(sym: &str) -> Self

Convenience method to build a symbolic atom.

Example

use parsley::{Context, NULL, SExp};
let mut ctx = Context::base();

// A null list is an empty application
assert!(NULL.eval(&mut ctx).is_err());

// The symbol `null` (defined in `Context::base`) creates a null list
let result = SExp::make_symbol("null").eval(&mut ctx);
assert!(result.is_ok());
assert_eq!(result.unwrap(), NULL);

Trait Implementations

impl Clone for SExp

fn clone(&self) -> SExp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SExp

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

Formats the value using the given formatter.

impl Display for SExp

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

Formats the value using the given formatter.

impl FromStr for SExp

type Err = LispError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> LispResult

Parses a string s to return a value of this type.

impl PartialEq<SExp> for SExp

fn eq(&self, other: &SExp) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SExp