ruschm 0.2.0

Scheme(R7RS-small) interpretor/compiler rust implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use crate::error::*;
use either::Either;
use itertools::Itertools;
use std::fmt::Display;

use super::{
    error::SyntaxError,
    pair::{GenericPair, Pairable},
};

#[derive(PartialEq, Debug, Clone)]
pub enum Primitive {
    String(String),
    Character(char),
    Boolean(bool),
    Integer(i32),
    Rational(i32, u32),
    Real(String),
}

impl Display for Primitive {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Primitive::String(inner) => write!(f, "{}", inner),
            Primitive::Character(inner) => write!(f, "{}", inner),
            Primitive::Boolean(inner) => write!(f, "{}", if *inner { "#t" } else { "#f" }),
            Primitive::Integer(inner) => write!(f, "{}", inner),
            Primitive::Rational(a, b) => write!(f, "{}/{}", a, b),
            Primitive::Real(inner) => write!(f, "{}", inner),
        }
    }
}

pub type DatumList = GenericPair<Datum>;

#[derive(PartialEq, Debug, Clone)]
pub enum DatumBody {
    Primitive(Primitive),
    Symbol(String),
    Pair(Box<DatumList>),
    Vector(Vec<Datum>),
}

impl Pairable for Datum {
    impl_located_pairable!(DatumBody);
}

impl Display for DatumBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            DatumBody::Primitive(inner) => write!(f, "{}", inner),
            DatumBody::Symbol(inner) => write!(f, "{}", inner),
            DatumBody::Pair(inner) => write!(f, "{}", inner),
            DatumBody::Vector(inner) => {
                write!(f, "#({})", inner.iter().join(" "))
            }
        }
    }
}

impl Datum {
    pub fn expect_list(self) -> Result<DatumList, SchemeError> {
        match self.data {
            DatumBody::Pair(inner) => Ok(*inner),
            _ => {
                return error!(SyntaxError::ExpectSomething(
                    "list/pair".to_string(),
                    self.to_string()
                ))
            }
        }
    }

    pub fn expect_symbol(&self) -> Result<String, SchemeError> {
        match &self.data {
            DatumBody::Symbol(symbol) => Ok(symbol.clone()),
            _ => {
                return error!(SyntaxError::ExpectSomething(
                    "symbol".to_string(),
                    self.to_string()
                ))
            }
        }
    }
}

impl From<DatumList> for Datum {
    fn from(pair: DatumList) -> Self {
        Datum {
            data: DatumBody::Pair(Box::new(pair)),
            location: None, // TODO
        }
    }
}

pub type Datum = Located<DatumBody>;

impl ToLocated for DatumBody {}