schemat 0.5.1

A code formatter for Scheme, Lisp, and any S-expressions
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

use crate::position::Position;
use allocator_api2::{alloc::Allocator, boxed::Box, vec::Vec};

#[derive(Debug)]
pub enum Expression<'a, A: Allocator> {
    List(&'a str, &'a str, Vec<Self, A>, Position),
    Quote(&'a str, Box<Self, A>, Position),
    QuotedSymbol(&'a str, Position),
    String(&'a str, Position),
    Symbol(&'a str, Position),
}

impl<A: Allocator> Expression<'_, A> {
    pub const fn position(&self) -> &Position {
        match self {
            Self::List(_, _, _, position) => position,
            Self::Quote(_, _, position) => position,
            Self::QuotedSymbol(_, position) => position,
            Self::String(_, position) => position,
            Self::Symbol(_, position) => position,
        }
    }
}

// TODO Why do we need to do this manually?
impl<A: Allocator> PartialEq for Expression<'_, A> {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (
                Self::List(left, right, one, position),
                Self::List(other_left, other_right, other, other_position),
            ) => {
                left == other_left
                    && right == other_right
                    && one == other
                    && position == other_position
            }
            (Self::Quote(sign, one, position), Self::Quote(other_sign, other, other_position)) => {
                sign == other_sign && one == other && position == other_position
            }
            (Self::QuotedSymbol(one, position), Self::QuotedSymbol(other, other_position)) => {
                one == other && position == other_position
            }
            (Self::String(one, position), Self::String(other, other_position)) => {
                one == other && position == other_position
            }
            (Self::Symbol(one, position), Self::Symbol(other, other_position)) => {
                one == other && position == other_position
            }
            _ => false,
        }
    }
}

impl<A: Allocator> Eq for Expression<'_, A> {}

#[cfg(test)]
mod tests {
    use super::*;
    use allocator_api2::alloc::Global;

    #[test]
    fn equal() {
        assert_eq!(
            Expression::<Global>::Symbol("foo", Position::new(0, 0)),
            Expression::<Global>::Symbol("foo", Position::new(0, 0))
        );
    }
}