From 160b64427d79290a59ac48c9babca064232d8dfd Mon Sep 17 00:00:00 2001
From: Tolmachev Igor <me@igorek.dev>
Date: Sat, 9 May 2026 20:47:04 +0300
Subject: Make project structure more consistent

---
 compiler/src/lexer/mod.rs | 172 ----------------------------------------------
 1 file changed, 172 deletions(-)
 delete mode 100644 compiler/src/lexer/mod.rs

(limited to 'compiler/src/lexer/mod.rs')

diff --git a/compiler/src/lexer/mod.rs b/compiler/src/lexer/mod.rs
deleted file mode 100644
index f3c8b76..0000000
--- a/compiler/src/lexer/mod.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-use crate::span::{Pos, Span, Spanned};
-
-#[cfg(test)]
-mod tests;
-
-fn is_terminator(ch: char) -> bool {
-    ch.is_whitespace() || matches!(ch, '(' | ')' | '\'' | '"' | ';')
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Token<'a> {
-    LeftPar,
-    RightPar,
-    Quote,
-    Number(&'a str),
-    String(&'a str),
-    UnclosedString(&'a str),
-    Symbol(&'a str),
-}
-
-pub struct Lexer<'a> {
-    input: &'a str,
-    cursor: usize,
-
-    line: usize,
-    column: usize,
-}
-
-impl<'a> Lexer<'a> {
-    pub fn new(input: &'a str) -> Self {
-        Self {
-            input,
-            cursor: 0,
-
-            line: 1,
-            column: 0,
-        }
-    }
-
-    fn rest(&self) -> &str {
-        &self.input[self.cursor..]
-    }
-
-    fn peek(&self) -> Option<char> {
-        self.rest().chars().next()
-    }
-
-    fn peek_nth(&self, n: usize) -> Option<char> {
-        self.rest().chars().nth(n)
-    }
-
-    fn consume(&mut self) -> Option<char> {
-        let ch = self.peek()?;
-
-        self.cursor += ch.len_utf8();
-        if ch == '\n' {
-            self.line += 1;
-            self.column = 0;
-        } else {
-            self.column += 1;
-        }
-
-        Some(ch)
-    }
-
-    fn next_while(&mut self, mut predicate: impl FnMut(char) -> bool) -> &'a str {
-        let start = self.cursor;
-
-        while let Some(ch) = self.peek() {
-            if !predicate(ch) {
-                break;
-            }
-            self.consume();
-        }
-
-        &self.input[start..self.cursor]
-    }
-
-    fn next_atom(&mut self) -> &'a str {
-        self.next_while(|ch| !is_terminator(ch))
-    }
-
-    fn next_string(&mut self) -> Result<&'a str, &'a str> {
-        debug_assert_eq!(self.peek(), Some('"'));
-        self.consume();
-
-        let start = self.cursor;
-
-        while let Some(ch) = self.peek() {
-            match ch {
-                '"' => {
-                    let string = &self.input[start..self.cursor];
-                    self.consume();
-                    return Ok(string);
-                }
-                '\n' => {
-                    let string = &self.input[start..self.cursor];
-                    self.consume();
-                    return Err(string);
-                }
-                '\\' => {
-                    self.consume();
-                    self.consume();
-                }
-                _ => {
-                    self.consume();
-                }
-            }
-        }
-
-        Err(&self.input[start..self.cursor])
-    }
-}
-
-impl<'a> Iterator for Lexer<'a> {
-    type Item = Spanned<Token<'a>>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            match self.peek()? {
-                ch if ch.is_whitespace() => {
-                    self.next_while(char::is_whitespace);
-                }
-                ';' => {
-                    self.next_while(|ch| ch != '\n');
-                }
-                _ => break,
-            }
-        }
-
-        let start = Pos::new(self.line, self.column, self.cursor);
-
-        let token = match self.peek()? {
-            '(' => {
-                self.consume();
-                Token::LeftPar
-            }
-            ')' => {
-                self.consume();
-                Token::RightPar
-            }
-            '\'' => {
-                self.consume();
-                Token::Quote
-            }
-
-            // Number
-            ch if ch.is_ascii_digit()
-                || ch == '.' && self.peek_nth(1).is_some_and(|ch| ch.is_ascii_digit())
-                || matches!(ch, '+' | '-')
-                    && self.peek_nth(1).is_some_and(|ch| ch.is_ascii_digit())
-                || matches!(ch, '+' | '-')
-                    && self.peek_nth(1).is_some_and(|ch| ch == '.')
-                    && self.peek_nth(2).is_some_and(|ch| ch.is_ascii_digit()) =>
-            {
-                Token::Number(self.next_atom())
-            }
-
-            // String
-            '"' => match self.next_string() {
-                Ok(string) => Token::String(string),
-                Err(string) => Token::UnclosedString(string),
-            },
-
-            // Symbol
-            _ => Token::Symbol(self.next_atom()),
-        };
-
-        let end = Pos::new(self.line, self.column, self.cursor);
-        Some(Spanned::new(token, Span::new(start, end)))
-    }
-}
-- 
cgit v1.3