pub mod step;
pub mod util;
pub mod subst;
pub mod display;

/// A leaf node for S-Expressions.
///
/// May represent built-in operators,
/// variables, functions (to be added) or values.
#[derive(Debug)]
#[derive(PartialEq)]
#[derive(Clone)]
pub enum SLeaf {

    Add,
    Sub,
    Mul,
    Div,
    Eq,
    Neq,
    Gt,
    Lt,
    Ge,
    Le,
    And,
    Or,
    Not,
    Xor,

    Quote,
    Vector,

    Let,

    Int(i32),
    True,
    False,

    Var(String),

    Nil,
}

/// An S-Expression; the defining structure of the language.
///
/// This structure is not intended to correspond with
/// IETF-standardized s-expressions; they are only inspiration.
#[derive(Debug)]
#[derive(PartialEq)]
#[derive(Clone)]
pub enum SExp {
    SCons(Box<SExp>, Box<SExp>),
    Atom(SLeaf),
}

use SExp::*;
use SLeaf::*;


impl SExp {
    /// Quick test that lets are values
    /// ```rust
    /// use myslip::sexp::{SExp::*, SLeaf::*, util::*};
    /// assert!(scons(Let, scons(var("a"), scons(5, Nil))).is_value())
    /// ```
    pub fn is_value(&self) -> bool {
        match self {
            SCons(a, b) =>
                SCons(a.clone(), b.clone()).check_let().is_some() ||
                (
                    (**a == Atom(Quote) || **a == Atom(Vector))
                    && b.consists_of_values()
                ),
            Atom(Var(_)) => false,
            Atom(_) => true,
        }
    }

    pub fn consists_of_values(&self) -> bool {
        self.is_value() || match self {
            SCons(a, b) if (*a).is_value() => b.consists_of_values(),
            _ => false
        }
    }
}