rusty-lisp 0.61.0

A modern Lisp interpreter in Rust with TCO, macros, JIT, verification checkers, and AI agent capabilities
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

// Copyright (c) 2026 Nicholas Vermeulen
// SPDX-License-Identifier: AGPL-3.0-or-later

#[derive(Debug, Clone, PartialEq)]
pub enum Token {
    LParen,
    RParen,
    Quote,           // '
    Quasiquote,      // `
    Unquote,         // ,
    UnquoteSplice,   // ,@
    Number(f64),
    Bool(bool),
    String(String),
    Symbol(String),
    EOF,
}

pub struct Lexer {
    input: Vec<char>,
    pos:   usize,
}

impl Lexer {
    pub fn new(input: &str) -> Self {
        Lexer { input: input.chars().collect(), pos: 0 }
    }

    fn peek(&self)  -> Option<char> { self.input.get(self.pos).copied() }
    fn peek2(&self) -> Option<char> { self.input.get(self.pos + 1).copied() }

    fn advance(&mut self) -> Option<char> {
        let ch = self.input.get(self.pos).copied();
        self.pos += 1;
        ch
    }

    pub fn tokenize(&mut self) -> Vec<Token> {
        let mut tokens = Vec::new();
        loop {
            while matches!(self.peek(), Some(' ' | '\n' | '\t' | '\r')) { self.advance(); }
            match self.peek() {
                None      => break,
                Some(';') => { while !matches!(self.peek(), None | Some('\n')) { self.advance(); } }
                Some('(') => { self.advance(); tokens.push(Token::LParen); }
                Some(')') => { self.advance(); tokens.push(Token::RParen); }
                Some('\'')=> { self.advance(); tokens.push(Token::Quote); }
                Some('`') => { self.advance(); tokens.push(Token::Quasiquote); }
                Some(',') => {
                    self.advance();
                    if self.peek() == Some('@') { self.advance(); tokens.push(Token::UnquoteSplice); }
                    else { tokens.push(Token::Unquote); }
                }
                Some('"') => {
                    self.advance();
                    let mut s = String::new();
                    loop {
                        match self.advance() {
                            None | Some('"') => break,
                            Some('\\') => match self.advance() {
                                Some('n') => s.push('\n'),
                                Some('t') => s.push('\t'),
                                Some('r') => s.push('\r'),
                                Some(c)   => s.push(c),
                                None      => break,
                            },
                            Some(c) => s.push(c),
                        }
                    }
                    tokens.push(Token::String(s));
                }
                Some('#') => {
                    self.advance();
                    match self.peek() {
                        Some('t') => { self.advance(); tokens.push(Token::Bool(true)); }
                        Some('f') => { self.advance(); tokens.push(Token::Bool(false)); }
                        _         => tokens.push(Token::Symbol("#".to_string())),
                    }
                }
                Some(c) => {
                    let is_num = c.is_ascii_digit()
                        || (c == '-' && matches!(self.peek2(), Some(d) if d.is_ascii_digit()));
                    if is_num {
                        let start = self.pos;
                        if c == '-' { self.advance(); }
                        while matches!(self.peek(), Some(d) if d.is_ascii_digit() || d == '.') {
                            self.advance();
                        }
                        // Scientific notation: 1e-20, 2.5E+3, 7e9 — an
                        // e/E directly followed by [+-]?digits is part of
                        // the number, not the start of a symbol.
                        if matches!(self.peek(), Some('e') | Some('E')) {
                            let mark = self.pos;
                            self.advance(); // e/E
                            if matches!(self.peek(), Some('+') | Some('-')) { self.advance(); }
                            if matches!(self.peek(), Some(d) if d.is_ascii_digit()) {
                                while matches!(self.peek(), Some(d) if d.is_ascii_digit()) {
                                    self.advance();
                                }
                            } else {
                                self.pos = mark; // not an exponent (e.g. `2elephants`)
                            }
                        }
                        let s: String = self.input[start..self.pos].iter().collect();
                        tokens.push(s.parse::<f64>().map(Token::Number)
                            .unwrap_or_else(|_| Token::Symbol(s)));
                    } else {
                        let start = self.pos;
                        while let Some(sc) = self.peek() {
                            if sc.is_whitespace() || matches!(sc, '('|')'|'\''|'"'|'`'|',') { break; }
                            self.advance();
                        }
                        let sym: String = self.input[start..self.pos].iter().collect();
                        if !sym.is_empty() { tokens.push(Token::Symbol(sym)); }
                    }
                }
            }
        }
        tokens.push(Token::EOF);
        tokens
    }
}