Enum parsley::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

NullAtom(Primitive)Pair

Fields of Pair

head: Box<SExp>tail: Box<SExp>

Methods

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 copy of the value.

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

Performs copy-assignment from source.

impl IntoIterator for SExp

type Item = Self

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<T> From<T> for SExp where     Primitive: From<T>,

fn from(val: T) -> Self

Performs the conversion.

impl From<()> for SExp

fn from(_: ()) -> Self

Performs the conversion.

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

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

Performs the conversion.

impl<T, U> From<(T, U)> for SExp where     SExp: From<T> + From<U>,

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

Performs the conversion.

impl<T, '_> From<&'_ [T]> for SExp where     T: Into<SExp> + Clone,

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

Performs the conversion.

impl<T> From<Vec<T>> for SExp where     T: Into<SExp>,

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

Performs the conversion.

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: &SExp) -> bool

This method tests for !=.

impl Display for SExp

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

Formats the value using the given formatter.

impl Debug for SExp

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

Formats the value using the given formatter.

impl Index<usize> for SExp

type Output = Self

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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.