Enum SExp 

pub enum SExp {
    Null,
    Atom(Primitive),
    Pair {
        head: Box<SExp>,
        tail: Box<SExp>,
    },
}

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

Examples

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

use parsley::SExp;
let parsed = "\"abcdefg\"".parse::<SExp>().unwrap();
assert_eq!(parsed, SExp::from("abcdefg"));

Variants

Null

Atom(Primitive)

Pair

Fields

head: Box<SExp>

tail: Box<SExp>

Implementations

impl SExp

pub fn iter(&self) -> SExpRefIterator<'_>

Iterate over an S-Expression, by reference.

Example

use parsley::prelude::*;
assert_eq!(
    sexp![()].iter().next().unwrap(),
    &SExp::Null
);

pub fn is_empty(&self) -> bool

Easy way to check for Null if you’re planning on iterating

pub fn len(&self) -> usize

Get the length of an S-Expression (vector or list)

Example

use parsley::prelude::*;
assert_eq!(
    sexp!['a', "bee", SExp::sym("sea")].len(),
    3
);

impl SExp

pub fn cons(self, exp: Self) -> Self

The natural way to build up a list - from the end to the beginning.

Example

use parsley::prelude::*;
use parsley::SExp::Null;

let macro_list = sexp![SExp::sym("quote"), ()];
let cons_list = Null.cons(Null).cons(SExp::sym("quote"));

assert_eq!(macro_list, cons_list);

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

Convenience method to build a symbolic atom.

Example

use parsley::prelude::*;
let mut ctx = Context::base();

// A null list is an empty application
assert!(ctx.eval(SExp::Null).is_err());

// The symbol `null` (defined in `Context::base`) creates a null when evaluated
let result = ctx.run("null").unwrap();
assert_eq!(result, SExp::Null);

pub fn type_of(&self) -> &str

Printable type for an expression.

Example

use parsley::SExp;

assert_eq!(SExp::Null.type_of(), "null");
assert_eq!(SExp::from(3).type_of(), "number");
assert_eq!(SExp::from(true).type_of(), "bool");
assert_eq!(SExp::from((5,)).type_of(), "list");

Trait Implementations

impl Clone for SExp

fn clone(&self) -> SExp

Returns a duplicate 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<T> From<&[T]> for SExp

where T: Into<SExp> + Clone,

fn from(ary: &[T]) -> Self

Converts to this type from the input type.

impl From<()> for SExp

fn from(_: ()) -> Self

Converts to this type from the input type.

impl<T> From<(T,)> for SExp

where SExp: From<T>,

fn from((v): (T,)) -> Self

Converts to this type from the input type.

impl<T, U> From<(T, U)> for SExp

where T: Into<SExp>, U: Into<SExp>,

fn from((v1, v2): (T, U)) -> Self

Converts to this type from the input type.

impl<T> From<T> for SExp

where Primitive: From<T>,

fn from(val: T) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for SExp

where T: Into<SExp>,

fn from(ary: Vec<T>) -> Self

Converts to this type from the input type.

impl FromIterator<SExp> for SExp

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = SExp>,

Creates a value from an iterator.

impl FromStr for SExp

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result

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

impl Index<usize> for SExp

type Output = SExp

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IntoIterator for SExp

type Item = SExp

The type of the elements being iterated over.

type IntoIter = SExpIterator

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for SExp

fn eq(&self, other: &SExp) -> 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 StructuralPartialEq for SExp