mrt-lang 0.1.4__py3-none-any.whl

mrt_lang-0.1.4.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MRT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mrt_lang-0.1.4.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.1
+Name: mrt-lang
+Version: 0.1.4
+Summary: MRT Programming Language - A modern, expressive programming language
+Home-page: https://github.com/rithymeth/MRT
+Author: MRT Team
+Author-email: rithy1337@gmail.com
+Keywords: programming language interpreter compiler
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# MRT Programming Language
+
+MRT is a modern, expressive programming language designed for simplicity and readability. It combines intuitive syntax with powerful features for both beginners and experienced programmers.
+
+## Features
+
+- Simple and expressive syntax
+- Dynamic typing with type inference
+- First-class functions
+- Rich built-in functions
+- Comprehensive array operations
+- Powerful string manipulation
+- Modern module system
+
+## Installation
+
+You can install MRT using pip:
+
+```bash
+pip install mrt-lang
+```
+
+After installation, you can run MRT programs using the `mrt` command:
+```bash
+mrt your_program.mrt
+```
+
+## Quick Start
+
+1. Create a file `hello.mrt`:
+```mrt
+func main() {
+    print("Hello, World!")
+}
+```
+
+2. Run the program:
+```bash
+mrt hello.mrt
+```
+
+## Language Examples
+
+### Variables and Basic Types
+```mrt
+func variables_demo() {
+    var name = "Alice"
+    var age = 25
+    var height = 1.75
+    var isStudent = true
+    
+    print("Name: " + name)
+}
+```
+
+### Arrays
+```mrt
+func array_demo() {
+    var numbers = [1, 2, 3, 4, 5]
+    push(numbers, 6)
+    print("Length:", len(numbers))
+    print("First element:", numbers[0])
+}
+```
+
+### String Operations
+```mrt
+func string_demo() {
+    var text = "  Hello, World!  "
+    print("Trimmed:", trim(text))
+    print("Uppercase:", toUpper(text))
+    print("Contains 'World':", contains(text, "World"))
+}
+```
+
+## Built-in Functions
+
+### Array Operations
+- `len(array)`: Returns array length
+- `push(array, element)`: Adds element to end
+- `pop(array)`: Removes and returns last element
+- `slice(array, start, end)`: Returns array subset
+- `join(array, separator)`: Joins elements into string
+- `indexOf(array, element)`: Finds element index
+
+### String Operations
+- `split(str, separator)`: Splits string into array
+- `substring(str, start, end)`: Extracts string portion
+- `toUpper(str)`: Converts to uppercase
+- `toLower(str)`: Converts to lowercase
+- `trim(str)`: Removes whitespace
+- `replace(str, old, new)`: Replaces text
+- `startsWith(str, prefix)`: Checks string start
+- `endsWith(str, suffix)`: Checks string end
+- `contains(str, substr)`: Checks for substring
+
+## Project Structure
+
+- `src/`: Source code for the MRT interpreter
+  - `lexer.py`: Tokenizes source code
+  - `parser.py`: Parses tokens into AST
+  - `interpreter.py`: Executes MRT programs
+  - `ast.py`: Abstract Syntax Tree definitions
+- `docs/`: Comprehensive documentation
+  - `language_guide.md`: Complete language reference
+  - `examples.md`: Example programs and tutorials
+  - `getting_started.md`: Installation and quick start
+- `examples/`: Example MRT programs
+- `tests/`: Test suite
+
+## Documentation
+
+For more detailed information, check out:
+- [Language Guide](docs/language_guide.md): Complete language reference
+- [Examples](docs/examples.md): Example programs and tutorials
+- [Getting Started](docs/getting_started.md): Installation and quick start
+
+## Development
+
+To set up the development environment:
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd mrt
+```
+
+2. Install in development mode:
+```bash
+pip install -e .
+```
+
+3. Install development dependencies:
+```bash
+pip install -r requirements-dev.txt
+```
+
+## Contributing
+
+We welcome contributions! Whether it's:
+- Bug reports
+- Feature requests
+- Documentation improvements
+- Code contributions
+
+Please feel free to open issues and pull requests.
+
+## License
+
+MIT License - see [LICENSE.txt](LICENSE.txt) for details.

mrt_lang-0.1.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+src/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+src/__main__.py,sha256=Rlx96UbCsW4PcnwUBSnQzbLIRIf5sF_DKZjfgRqEW4I,719
+src/ast.py,sha256=Iu-pj2c6q3iRRH9z-mbTkZEI9ZGinWyPF68jQDZ8Ws4,1533
+src/interpreter.py,sha256=7PvKcJf61D2ogOFBx8EYPdZDB_QvOBtELrgFHrEMtsY,16222
+src/lexer.py,sha256=Y46xheBhAGlWikG3jijrSgiP7Ddm8ALcu2i5qUQnJQo,7716
+src/parser.py,sha256=MJmzfu_EudLZz2MIoqT52fLWxdJp2NERyjQ6zEYaw3I,11350
+mrt_lang-0.1.4.dist-info/LICENSE.txt,sha256=E__hQj7AfnoRYefz32Q0YRjCmqCNiseVw0DbWeylc6k,1079
+mrt_lang-0.1.4.dist-info/METADATA,sha256=CWa5tR76eMWjNWdCCA6OurFClRVNBahWwtzOfbYEvHM,4278
+mrt_lang-0.1.4.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+mrt_lang-0.1.4.dist-info/entry_points.txt,sha256=W9v9wmK8xQ_y1asNJw0JNTrRr728mft4o7rhfdatgMw,42
+mrt_lang-0.1.4.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+mrt_lang-0.1.4.dist-info/RECORD,,

mrt_lang-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mrt_lang-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mrt = src.__main__:main

mrt_lang-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/__init__.py

@@ -0,0 +1 @@
+

src/__main__.py

@@ -0,0 +1,32 @@
+import sys
+from .lexer import Lexer
+from .parser import Parser
+from .interpreter import Interpreter
+
+def run_file(path: str):
+    with open(path, 'r') as file:
+        source = file.read()
+        run(source)
+
+def run(source: str):
+    # Create lexer and generate tokens
+    lexer = Lexer(source)
+    tokens = lexer.scan_tokens()
+
+    # Parse tokens into AST
+    parser = Parser(tokens)
+    statements = parser.parse()
+
+    # Interpret the AST
+    interpreter = Interpreter()
+    interpreter.interpret(statements)
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python -m mrt <script>")
+        sys.exit(1)
+
+    run_file(sys.argv[1])
+
+if __name__ == "__main__":
+    main()

src/ast.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+from typing import List, Any, Optional
+
+# Base class for all AST nodes
+class Expr:
+    pass
+
+class Stmt:
+    pass
+
+@dataclass
+class Binary(Expr):
+    left: Expr
+    operator: 'Token'
+    right: Expr
+
+@dataclass
+class Grouping(Expr):
+    expression: Expr
+
+@dataclass
+class Literal(Expr):
+    value: Any
+
+@dataclass
+class Unary(Expr):
+    operator: 'Token'
+    right: Expr
+
+@dataclass
+class Variable(Expr):
+    name: 'Token'
+
+@dataclass
+class Assign(Expr):
+    name: 'Token'
+    value: Expr
+
+@dataclass
+class Call(Expr):
+    callee: Expr
+    paren: 'Token'
+    arguments: List[Expr]
+
+@dataclass
+class Array(Expr):
+    elements: List[Expr]
+
+@dataclass
+class ArrayAccess(Expr):
+    array: Expr
+    index: Expr
+
+@dataclass
+class ArrayAssign(Expr):
+    array: Expr
+    index: Expr
+    value: Expr
+
+# Statement nodes
+@dataclass
+class Expression(Stmt):
+    expression: Expr
+
+@dataclass
+class Function(Stmt):
+    name: 'Token'
+    params: List['Token']
+    body: List[Stmt]
+
+@dataclass
+class If(Stmt):
+    condition: Expr
+    then_branch: Stmt
+    else_branch: Optional[Stmt]
+
+@dataclass
+class Return(Stmt):
+    keyword: 'Token'
+    value: Optional[Expr]
+
+@dataclass
+class While(Stmt):
+    condition: Expr
+    body: Stmt
+
+@dataclass
+class Block(Stmt):
+    statements: List[Stmt]
+
+@dataclass
+class Print(Stmt):
+    expression: Expr
+
+@dataclass
+class Var(Stmt):
+    name: 'Token'
+    initializer: Optional[Expr]

src/interpreter.py

@@ -0,0 +1,413 @@
+from typing import Any, Dict, List, Optional
+from .ast import *
+from .lexer import Token, TokenType
+import sys
+
+class MRTFunction:
+    def __init__(self, declaration: Function, closure: 'Environment'):
+        self.declaration = declaration
+        self.closure = closure
+
+    def call(self, interpreter: 'Interpreter', arguments: List[Any]) -> Any:
+        environment = Environment(self.closure)
+        for param, arg in zip(self.declaration.params, arguments):
+            environment.define(param.lexeme, arg)
+
+        try:
+            interpreter.execute_block(self.declaration.body, environment)
+            return None
+        except Return as return_value:
+            return return_value.value
+
+    def __str__(self):
+        return f"<function {self.declaration.name.lexeme}>"
+
+class Return(Exception):
+    def __init__(self, value: Any):
+        self.value = value
+        super().__init__()
+
+class Environment:
+    def __init__(self, enclosing: Optional['Environment'] = None):
+        self.values: Dict[str, Any] = {}
+        self.enclosing = enclosing
+
+    def define(self, name: str, value: Any):
+        self.values[name] = value
+
+    def get(self, name: Token) -> Any:
+        if name.lexeme in self.values:
+            return self.values[name.lexeme]
+
+        if self.enclosing:
+            return self.enclosing.get(name)
+
+        raise RuntimeError(f"Undefined variable '{name.lexeme}'.")
+
+    def assign(self, name: Token, value: Any):
+        if name.lexeme in self.values:
+            self.values[name.lexeme] = value
+            return
+
+        if self.enclosing:
+            self.enclosing.assign(name, value)
+            return
+
+        raise RuntimeError(f"Undefined variable '{name.lexeme}'.")
+
+class MRTBuiltin:
+    @staticmethod
+    def len(*args):
+        if len(args) != 1:
+            raise RuntimeError("len() takes exactly one argument.")
+        if not isinstance(args[0], list):
+            raise RuntimeError("len() argument must be an array.")
+        return float(len(args[0]))
+
+    @staticmethod
+    def push(*args):
+        if len(args) != 2:
+            raise RuntimeError("push() takes exactly two arguments.")
+        if not isinstance(args[0], list):
+            raise RuntimeError("First argument to push() must be an array.")
+        args[0].append(args[1])
+        return args[1]
+
+    @staticmethod
+    def pop(*args):
+        if len(args) != 1:
+            raise RuntimeError("pop() takes exactly one argument.")
+        if not isinstance(args[0], list):
+            raise RuntimeError("pop() argument must be an array.")
+        if not args[0]:
+            raise RuntimeError("Cannot pop from empty array.")
+        return args[0].pop()
+
+    @staticmethod
+    def slice(*args):
+        if len(args) not in [2, 3]:
+            raise RuntimeError("slice() takes 2 or 3 arguments.")
+        if not isinstance(args[0], list):
+            raise RuntimeError("First argument to slice() must be an array.")
+        
+        arr = args[0]
+        start = int(args[1]) if isinstance(args[1], (int, float)) else 0
+        end = int(args[2]) if len(args) > 2 and isinstance(args[2], (int, float)) else len(arr)
+        
+        if start < 0:
+            start = len(arr) + start
+        if end < 0:
+            end = len(arr) + end
+            
+        return arr[start:end]
+
+    @staticmethod
+    def join(*args):
+        if len(args) not in [1, 2]:
+            raise RuntimeError("join() takes 1 or 2 arguments.")
+        if not isinstance(args[0], list):
+            raise RuntimeError("First argument to join() must be an array.")
+            
+        separator = str(args[1]) if len(args) > 1 else ""
+        return separator.join(str(x) for x in args[0])
+
+    @staticmethod
+    def indexOf(*args):
+        if len(args) != 2:
+            raise RuntimeError("indexOf() takes exactly 2 arguments.")
+        if not isinstance(args[0], list):
+            raise RuntimeError("First argument to indexOf() must be an array.")
+            
+        try:
+            return float(args[0].index(args[1]))
+        except ValueError:
+            return -1.0
+
+    @staticmethod
+    def split(*args):
+        if len(args) not in [1, 2]:
+            raise RuntimeError("split() takes 1 or 2 arguments.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("First argument to split() must be a string.")
+        
+        separator = str(args[1]) if len(args) > 1 else " "
+        return args[0].split(separator)
+
+    @staticmethod
+    def substring(*args):
+        if len(args) not in [2, 3]:
+            raise RuntimeError("substring() takes 2 or 3 arguments.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("First argument to substring() must be a string.")
+        
+        text = args[0]
+        start = int(args[1]) if isinstance(args[1], (int, float)) else 0
+        end = int(args[2]) if len(args) > 2 and isinstance(args[2], (int, float)) else len(text)
+        
+        if start < 0:
+            start = len(text) + start
+        if end < 0:
+            end = len(text) + end
+            
+        return text[start:end]
+
+    @staticmethod
+    def toUpper(*args):
+        if len(args) != 1:
+            raise RuntimeError("toUpper() takes exactly one argument.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("toUpper() argument must be a string.")
+        return args[0].upper()
+
+    @staticmethod
+    def toLower(*args):
+        if len(args) != 1:
+            raise RuntimeError("toLower() takes exactly one argument.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("toLower() argument must be a string.")
+        return args[0].lower()
+
+    @staticmethod
+    def trim(*args):
+        if len(args) != 1:
+            raise RuntimeError("trim() takes exactly one argument.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("trim() argument must be a string.")
+        return args[0].strip()
+
+    @staticmethod
+    def replace(*args):
+        if len(args) != 3:
+            raise RuntimeError("replace() takes exactly 3 arguments.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("First argument to replace() must be a string.")
+        return str(args[0]).replace(str(args[1]), str(args[2]))
+
+    @staticmethod
+    def startsWith(*args):
+        if len(args) != 2:
+            raise RuntimeError("startsWith() takes exactly 2 arguments.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("First argument to startsWith() must be a string.")
+        return args[0].startswith(str(args[1]))
+
+    @staticmethod
+    def endsWith(*args):
+        if len(args) != 2:
+            raise RuntimeError("endsWith() takes exactly 2 arguments.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("First argument to endsWith() must be a string.")
+        return args[0].endswith(str(args[1]))
+
+    @staticmethod
+    def contains(*args):
+        if len(args) != 2:
+            raise RuntimeError("contains() takes exactly 2 arguments.")
+        if not isinstance(args[0], str):
+            raise RuntimeError("First argument to contains() must be a string.")
+        return str(args[1]) in args[0]
+
+class Interpreter:
+    def __init__(self):
+        self.globals = Environment()
+        self.environment = self.globals
+        self.output = []  # Capture output for web playground
+        
+        # Add built-in functions
+        self.globals.define("print", self.print_function)
+        self.globals.define("len", MRTBuiltin.len)
+        self.globals.define("push", MRTBuiltin.push)
+        self.globals.define("pop", MRTBuiltin.pop)
+        self.globals.define("slice", MRTBuiltin.slice)
+        self.globals.define("join", MRTBuiltin.join)
+        self.globals.define("indexOf", MRTBuiltin.indexOf)
+        # Add string functions
+        self.globals.define("split", MRTBuiltin.split)
+        self.globals.define("substring", MRTBuiltin.substring)
+        self.globals.define("toUpper", MRTBuiltin.toUpper)
+        self.globals.define("toLower", MRTBuiltin.toLower)
+        self.globals.define("trim", MRTBuiltin.trim)
+        self.globals.define("replace", MRTBuiltin.replace)
+        self.globals.define("startsWith", MRTBuiltin.startsWith)
+        self.globals.define("endsWith", MRTBuiltin.endsWith)
+        self.globals.define("contains", MRTBuiltin.contains)
+
+    def print_function(self, *args):
+        """Custom print function that captures output"""
+        output_str = " ".join(str(arg) for arg in args)
+        self.output.append(output_str)
+        print(output_str)  # Also print to console for local execution
+        sys.stdout.flush()
+
+    def get_output(self):
+        """Get captured output for web playground"""
+        return "\n".join(self.output)
+
+    def clear_output(self):
+        """Clear captured output"""
+        self.output = []
+
+    def interpret(self, statements: List[Stmt]):
+        try:
+            self.clear_output()
+            # First pass: define all functions
+            for statement in statements:
+                if isinstance(statement, Function):
+                    self.execute(statement)
+            
+            # Second pass: look for and execute main function
+            main_func = None
+            try:
+                main_token = Token(TokenType.IDENTIFIER, "main", None, 1)
+                main_func = self.environment.get(main_token)
+            except RuntimeError:
+                pass
+            
+            if main_func and isinstance(main_func, MRTFunction):
+                main_func.call(self, [])
+            else:
+                # If no main function, execute all non-function statements
+                for statement in statements:
+                    if not isinstance(statement, Function):
+                        self.execute(statement)
+                        
+        except Exception as e:
+            error_msg = f"Runtime Error: {str(e)}"
+            self.output.append(error_msg)
+            print(error_msg)
+
+    def execute(self, stmt: Stmt):
+        match stmt:
+            case Block():
+                self.execute_block(stmt.statements, Environment(self.environment))
+            case Expression():
+                self.evaluate(stmt.expression)
+            case Function():
+                function = MRTFunction(stmt, self.environment)
+                self.environment.define(stmt.name.lexeme, function)
+            case If():
+                if self.is_truthy(self.evaluate(stmt.condition)):
+                    self.execute(stmt.then_branch)
+                elif stmt.else_branch:
+                    self.execute(stmt.else_branch)
+            case Print():
+                value = self.evaluate(stmt.expression)
+                self.print_function(value)
+            case Return():
+                value = None
+                if stmt.value:
+                    value = self.evaluate(stmt.value)
+                raise Return(value)
+            case Var():
+                value = None
+                if stmt.initializer:
+                    value = self.evaluate(stmt.initializer)
+                self.environment.define(stmt.name.lexeme, value)
+            case While():
+                while self.is_truthy(self.evaluate(stmt.condition)):
+                    self.execute(stmt.body)
+
+    def execute_block(self, statements: List[Stmt], environment: Environment):
+        previous = self.environment
+        try:
+            self.environment = environment
+            for statement in statements:
+                self.execute(statement)
+        finally:
+            self.environment = previous
+
+    def evaluate(self, expr: Expr) -> Any:
+        match expr:
+            case Array():
+                return [self.evaluate(element) for element in expr.elements]
+            case ArrayAccess():
+                array = self.evaluate(expr.array)
+                index = self.evaluate(expr.index)
+                if not isinstance(array, list):
+                    raise RuntimeError("Can only index into arrays.")
+                if not isinstance(index, (int, float)):
+                    raise RuntimeError("Array index must be a number.")
+                index = int(index)
+                if index < 0 or index >= len(array):
+                    raise RuntimeError("Array index out of bounds.")
+                return array[index]
+            case ArrayAssign():
+                array = self.evaluate(expr.array)
+                index = self.evaluate(expr.index)
+                if not isinstance(array, list):
+                    raise RuntimeError("Can only index into arrays.")
+                if not isinstance(index, (int, float)):
+                    raise RuntimeError("Array index must be a number.")
+                index = int(index)
+                if index < 0 or index >= len(array):
+                    raise RuntimeError("Array index out of bounds.")
+                value = self.evaluate(expr.value)
+                array[index] = value
+                return value
+            case Assign():
+                value = self.evaluate(expr.value)
+                self.environment.assign(expr.name, value)
+                return value
+            case Binary():
+                left = self.evaluate(expr.left)
+                right = self.evaluate(expr.right)
+
+                match expr.operator.type:
+                    case TokenType.PLUS:
+                        # Handle string concatenation
+                        if isinstance(left, str) or isinstance(right, str):
+                            return str(left) + str(right)
+                        return float(left) + float(right)
+                    case TokenType.MINUS:
+                        return float(left) - float(right)
+                    case TokenType.MULTIPLY:
+                        return float(left) * float(right)
+                    case TokenType.DIVIDE:
+                        if float(right) == 0:
+                            raise RuntimeError("Division by zero.")
+                        return float(left) / float(right)
+                    case TokenType.EQUALS:
+                        return self.is_equal(left, right)
+                    case TokenType.GREATER:
+                        return float(left) > float(right)
+                    case TokenType.LESS:
+                        return float(left) < float(right)
+            case Call():
+                callee = self.evaluate(expr.callee)
+                arguments = [self.evaluate(arg) for arg in expr.arguments]
+                
+                if isinstance(callee, MRTFunction):
+                    if len(arguments) != len(callee.declaration.params):
+                        raise RuntimeError(f"Expected {len(callee.declaration.params)} arguments but got {len(arguments)}.")
+                    return callee.call(self, arguments)
+                
+                if callable(callee):
+                    return callee(*arguments)
+                    
+                raise RuntimeError("Can only call functions.")
+            case Grouping():
+                return self.evaluate(expr.expression)
+            case Literal():
+                return expr.value
+            case Unary():
+                right = self.evaluate(expr.right)
+                
+                if expr.operator.type == TokenType.MINUS:
+                    return -float(right)
+            case Variable():
+                return self.environment.get(expr.name)
+
+    def is_equal(self, a: Any, b: Any) -> bool:
+        """Check equality between two values"""
+        if a is None and b is None:
+            return True
+        if a is None:
+            return False
+        return a == b
+
+    def is_truthy(self, obj: Any) -> bool:
+        if obj is None:
+            return False
+        if isinstance(obj, bool):
+            return obj
+        return True

src/lexer.py

@@ -0,0 +1,238 @@
+from enum import Enum, auto
+from dataclasses import dataclass
+from typing import Optional, List
+
+class TokenType(Enum):
+    # Keywords
+    FUNC = auto()
+    RETURN = auto()
+    IF = auto()
+    ELSE = auto()
+    WHILE = auto()
+    FOR = auto()
+    PRINT = auto()
+    VAR = auto()
+    TRUE = auto()
+    FALSE = auto()
+    
+    # Literals
+    IDENTIFIER = auto()
+    NUMBER = auto()
+    STRING = auto()
+    
+    # Operators
+    PLUS = auto()
+    MINUS = auto()
+    MULTIPLY = auto()
+    DIVIDE = auto()
+    ASSIGN = auto()
+    EQUALS = auto()
+    NOT_EQUALS = auto()
+    GREATER = auto()
+    GREATER_EQUAL = auto()
+    LESS = auto()
+    LESS_EQUAL = auto()
+    
+    # Delimiters
+    LPAREN = auto()
+    RPAREN = auto()
+    LBRACE = auto()
+    RBRACE = auto()
+    LBRACKET = auto()
+    RBRACKET = auto()
+    COMMA = auto()
+    SEMICOLON = auto()
+    
+    # Special
+    EOF = auto()
+
+@dataclass
+class Token:
+    type: TokenType
+    lexeme: str
+    literal: Optional[object]
+    line: int
+
+class Lexer:
+    def __init__(self, source: str):
+        self.source = source
+        self.tokens: List[Token] = []
+        self.start = 0
+        self.current = 0
+        self.line = 1
+        
+        self.keywords = {
+            "func": TokenType.FUNC,
+            "return": TokenType.RETURN,
+            "if": TokenType.IF,
+            "else": TokenType.ELSE,
+            "while": TokenType.WHILE,
+            "for": TokenType.FOR,
+            "print": TokenType.PRINT,
+            "var": TokenType.VAR,
+            "true": TokenType.TRUE,
+            "false": TokenType.FALSE,
+        }
+    
+    def scan_tokens(self) -> List[Token]:
+        while not self.is_at_end():
+            self.start = self.current
+            self.scan_token()
+            
+        self.tokens.append(Token(TokenType.EOF, "", None, self.line))
+        return self.tokens
+    
+    def scan_token(self):
+        c = self.advance()
+        match c:
+            case '(': self.add_token(TokenType.LPAREN)
+            case ')': self.add_token(TokenType.RPAREN)
+            case '{': self.add_token(TokenType.LBRACE)
+            case '}': self.add_token(TokenType.RBRACE)
+            case '[': self.add_token(TokenType.LBRACKET)
+            case ']': self.add_token(TokenType.RBRACKET)
+            case ',': self.add_token(TokenType.COMMA)
+            case ';': self.add_token(TokenType.SEMICOLON)
+            case '+': self.add_token(TokenType.PLUS)
+            case '-': self.add_token(TokenType.MINUS)
+            case '*': self.add_token(TokenType.MULTIPLY)
+            case '/':
+                if self.match('/'):
+                    # Comment goes until end of line
+                    while self.peek() != '\n' and not self.is_at_end():
+                        self.advance()
+                elif self.match('*'):
+                    # Multi-line comment
+                    self.block_comment()
+                else:
+                    self.add_token(TokenType.DIVIDE)
+            case ' ' | '\r' | '\t': pass  # Ignore whitespace
+            case '\n': self.line += 1
+            case '"': self.string()
+            case '>': 
+                if self.match('='):
+                    self.add_token(TokenType.GREATER_EQUAL)
+                else:
+                    self.add_token(TokenType.GREATER)
+            case '<':
+                if self.match('='):
+                    self.add_token(TokenType.LESS_EQUAL)
+                else:
+                    self.add_token(TokenType.LESS)
+            case '=':
+                if self.match('='):
+                    self.add_token(TokenType.EQUALS)
+                else:
+                    self.add_token(TokenType.ASSIGN)
+            case '!':
+                if self.match('='):
+                    self.add_token(TokenType.NOT_EQUALS)
+                else:
+                    raise Exception(f"Unexpected character '!' at line {self.line}")
+            case _:
+                if self.is_digit(c):
+                    self.number()
+                elif self.is_alpha(c):
+                    self.identifier()
+                else:
+                    raise Exception(f"Unexpected character '{c}' at line {self.line}")
+    
+    def block_comment(self):
+        """Handle multi-line comments /* ... */"""
+        while not self.is_at_end():
+            if self.peek() == '*' and self.peek_next() == '/':
+                # Consume the closing */
+                self.advance()  # consume *
+                self.advance()  # consume /
+                return
+            if self.peek() == '\n':
+                self.line += 1
+            self.advance()
+        
+        # If we reach here, the comment was not closed
+        raise Exception(f"Unterminated comment starting at line {self.line}")
+    
+    def identifier(self):
+        while self.is_alphanumeric(self.peek()):
+            self.advance()
+            
+        text = self.source[self.start:self.current]
+        token_type = self.keywords.get(text, TokenType.IDENTIFIER)
+        
+        # Handle boolean literals
+        if token_type == TokenType.TRUE:
+            self.add_token(token_type, True)
+        elif token_type == TokenType.FALSE:
+            self.add_token(token_type, False)
+        else:
+            self.add_token(token_type)
+    
+    def number(self):
+        while self.is_digit(self.peek()):
+            self.advance()
+            
+        # Look for decimal point
+        if self.peek() == '.' and self.is_digit(self.peek_next()):
+            self.advance()  # Consume the "."
+            while self.is_digit(self.peek()):
+                self.advance()
+                
+        value = float(self.source[self.start:self.current])
+        self.add_token(TokenType.NUMBER, value)
+    
+    def string(self):
+        # Find the closing quote
+        start_line = self.line
+        while self.peek() != '"' and not self.is_at_end():
+            if self.peek() == '\n':
+                self.line += 1
+            self.advance()
+        
+        if self.is_at_end():
+            raise Exception(f"Unterminated string starting at line {start_line}")
+        
+        # Skip the closing quote
+        self.advance()
+        
+        # Get the string value (without quotes)
+        value = self.source[self.start + 1:self.current - 1]
+        self.add_token(TokenType.STRING, value)
+    
+    def match(self, expected: str) -> bool:
+        if self.is_at_end():
+            return False
+        if self.source[self.current] != expected:
+            return False
+            
+        self.current += 1
+        return True
+    
+    def peek(self) -> str:
+        if self.is_at_end():
+            return '\0'
+        return self.source[self.current]
+    
+    def peek_next(self) -> str:
+        if self.current + 1 >= len(self.source):
+            return '\0'
+        return self.source[self.current + 1]
+    
+    def is_alpha(self, c: str) -> bool:
+        return ('a' <= c <= 'z') or ('A' <= c <= 'Z') or c == '_'
+    
+    def is_digit(self, c: str) -> bool:
+        return '0' <= c <= '9'
+    
+    def is_alphanumeric(self, c: str) -> bool:
+        return self.is_alpha(c) or self.is_digit(c)
+    
+    def is_at_end(self) -> bool:
+        return self.current >= len(self.source)
+    
+    def advance(self) -> str:
+        self.current += 1
+        return self.source[self.current - 1]
+    
+    def add_token(self, type: TokenType, literal: Optional[object] = None):
+        text = self.source[self.start:self.current]
+        self.tokens.append(Token(type, text, literal, self.line))

src/parser.py

@@ -0,0 +1,340 @@
+from typing import List, Optional
+from .lexer import Token, TokenType
+from .ast import *
+
+class Parser:
+    def __init__(self, tokens: List[Token]):
+        self.tokens = tokens
+        self.current = 0
+
+    def parse(self) -> List[Stmt]:
+        statements = []
+        while not self.is_at_end():
+            stmt = self.declaration()
+            if stmt:
+                statements.append(stmt)
+        return statements
+
+    def declaration(self) -> Optional[Stmt]:
+        try:
+            if self.match(TokenType.FUNC):
+                return self.function("function")
+            if self.match(TokenType.VAR):
+                return self.var_declaration()
+            return self.statement()
+        except ParseError:
+            self.synchronize()
+            return None
+
+    def function(self, kind: str) -> Function:
+        name = self.consume(TokenType.IDENTIFIER, f"Expect {kind} name.")
+        
+        self.consume(TokenType.LPAREN, f"Expect '(' after {kind} name.")
+        parameters = []
+        if not self.check(TokenType.RPAREN):
+            while True:
+                if len(parameters) >= 255:
+                    self.error(self.peek(), "Can't have more than 255 parameters.")
+                parameters.append(
+                    self.consume(TokenType.IDENTIFIER, "Expect parameter name."))
+                if not self.match(TokenType.COMMA):
+                    break
+        self.consume(TokenType.RPAREN, "Expect ')' after parameters.")
+
+        self.consume(TokenType.LBRACE, f"Expect '{{' before {kind} body.")
+        body = self.block()
+        return Function(name, parameters, body)
+
+    def statement(self) -> Stmt:
+        if self.match(TokenType.FOR):
+            return self.for_statement()
+        if self.match(TokenType.IF):
+            return self.if_statement()
+        if self.match(TokenType.RETURN):
+            return self.return_statement()
+        if self.match(TokenType.WHILE):
+            return self.while_statement()
+        if self.match(TokenType.LBRACE):
+            return Block(self.block())
+        if self.match(TokenType.PRINT):
+            return self.print_statement()
+        return self.expression_statement()
+
+    def for_statement(self) -> Stmt:
+        self.consume(TokenType.LPAREN, "Expect '(' after 'for'.")
+        
+        # Initializer
+        initializer = None
+        if self.match(TokenType.SEMICOLON):
+            initializer = None
+        elif self.match(TokenType.VAR):
+            initializer = self.var_declaration()
+        else:
+            initializer = self.expression_statement()
+        
+        # Condition
+        condition = None
+        if not self.check(TokenType.SEMICOLON):
+            condition = self.expression()
+        self.consume(TokenType.SEMICOLON, "Expect ';' after loop condition.")
+        
+        # Increment
+        increment = None
+        if not self.check(TokenType.RPAREN):
+            increment = self.expression()
+        self.consume(TokenType.RPAREN, "Expect ')' after for clauses.")
+        
+        body = self.statement()
+        
+        # Desugar for loop into while loop
+        if increment:
+            body = Block([body, Expression(increment)])
+        
+        if not condition:
+            condition = Literal(True)
+        body = While(condition, body)
+        
+        if initializer:
+            body = Block([initializer, body])
+        
+        return body
+
+    def if_statement(self) -> If:
+        self.consume(TokenType.LPAREN, "Expect '(' after 'if'.")
+        condition = self.expression()
+        self.consume(TokenType.RPAREN, "Expect ')' after if condition.")
+
+        then_branch = self.statement()
+        else_branch = None
+        if self.match(TokenType.ELSE):
+            else_branch = self.statement()
+
+        return If(condition, then_branch, else_branch)
+
+    def return_statement(self) -> Return:
+        keyword = self.previous()
+        value = None
+        if not self.check(TokenType.SEMICOLON):
+            value = self.expression()
+
+        self.consume(TokenType.SEMICOLON, "Expect ';' after return value.")
+        return Return(keyword, value)
+
+    def while_statement(self) -> While:
+        self.consume(TokenType.LPAREN, "Expect '(' after 'while'.")
+        condition = self.expression()
+        self.consume(TokenType.RPAREN, "Expect ')' after condition.")
+        body = self.statement()
+
+        return While(condition, body)
+
+    def block(self) -> List[Stmt]:
+        statements = []
+        while not self.check(TokenType.RBRACE) and not self.is_at_end():
+            stmt = self.declaration()
+            if stmt:
+                statements.append(stmt)
+
+        self.consume(TokenType.RBRACE, "Expect '}' after block.")
+        return statements
+
+    def expression_statement(self) -> Stmt:
+        expr = self.expression()
+        self.consume(TokenType.SEMICOLON, "Expect ';' after expression.")
+        return Expression(expr)
+
+    def print_statement(self) -> Print:
+        value = self.expression()
+        self.consume(TokenType.SEMICOLON, "Expect ';' after value.")
+        return Print(value)
+
+    def expression(self) -> Expr:
+        return self.assignment()
+
+    def assignment(self) -> Expr:
+        expr = self.or_expression()
+
+        if self.match(TokenType.ASSIGN):
+            equals = self.previous()
+            value = self.assignment()
+
+            if isinstance(expr, Variable):
+                name = expr.name
+                return Assign(name, value)
+            elif isinstance(expr, ArrayAccess):
+                return ArrayAssign(expr.array, expr.index, value)
+
+            self.error(equals, "Invalid assignment target.")
+
+        return expr
+
+    def or_expression(self) -> Expr:
+        return self.and_expression()
+
+    def and_expression(self) -> Expr:
+        return self.equality()
+
+    def equality(self) -> Expr:
+        expr = self.comparison()
+
+        while self.match(TokenType.NOT_EQUALS, TokenType.EQUALS):
+            operator = self.previous()
+            right = self.comparison()
+            expr = Binary(expr, operator, right)
+
+        return expr
+
+    def comparison(self) -> Expr:
+        expr = self.term()
+
+        while self.match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL):
+            operator = self.previous()
+            right = self.term()
+            expr = Binary(expr, operator, right)
+
+        return expr
+
+    def term(self) -> Expr:
+        expr = self.factor()
+
+        while self.match(TokenType.PLUS, TokenType.MINUS):
+            operator = self.previous()
+            right = self.factor()
+            expr = Binary(expr, operator, right)
+
+        return expr
+
+    def factor(self) -> Expr:
+        expr = self.unary()
+
+        while self.match(TokenType.MULTIPLY, TokenType.DIVIDE):
+            operator = self.previous()
+            right = self.unary()
+            expr = Binary(expr, operator, right)
+
+        return expr
+
+    def unary(self) -> Expr:
+        if self.match(TokenType.MINUS):
+            operator = self.previous()
+            right = self.unary()
+            return Unary(operator, right)
+
+        return self.call()
+
+    def call(self) -> Expr:
+        expr = self.primary()
+
+        while True:
+            if self.match(TokenType.LPAREN):
+                expr = self.finish_call(expr)
+            elif self.match(TokenType.LBRACKET):
+                expr = self.array_access(expr)
+            else:
+                break
+
+        return expr
+
+    def finish_call(self, callee: Expr) -> Expr:
+        arguments = []
+        if not self.check(TokenType.RPAREN):
+            while True:
+                if len(arguments) >= 255:
+                    self.error(self.peek(), "Can't have more than 255 arguments.")
+                arguments.append(self.expression())
+                if not self.match(TokenType.COMMA):
+                    break
+
+        paren = self.consume(TokenType.RPAREN, "Expect ')' after arguments.")
+        return Call(callee, paren, arguments)
+
+    def array_access(self, expr: Expr) -> Expr:
+        index = self.expression()
+        self.consume(TokenType.RBRACKET, "Expect ']' after array index.")
+        return ArrayAccess(expr, index)
+
+    def primary(self) -> Expr:
+        if self.match(TokenType.TRUE):
+            return Literal(True)
+        if self.match(TokenType.FALSE):
+            return Literal(False)
+        if self.match(TokenType.NUMBER, TokenType.STRING):
+            return Literal(self.previous().literal)
+        if self.match(TokenType.IDENTIFIER):
+            return Variable(self.previous())
+        if self.match(TokenType.LPAREN):
+            expr = self.expression()
+            self.consume(TokenType.RPAREN, "Expect ')' after expression.")
+            return Grouping(expr)
+        if self.match(TokenType.LBRACKET):
+            elements = []
+            if not self.check(TokenType.RBRACKET):
+                while True:
+                    elements.append(self.expression())
+                    if not self.match(TokenType.COMMA):
+                        break
+            self.consume(TokenType.RBRACKET, "Expect ']' after array elements.")
+            return Array(elements)
+
+        raise self.error(self.peek(), "Expect expression.")
+
+    def var_declaration(self) -> Var:
+        name = self.consume(TokenType.IDENTIFIER, "Expect variable name.")
+
+        initializer = None
+        if self.match(TokenType.ASSIGN):
+            initializer = self.expression()
+
+        self.consume(TokenType.SEMICOLON, "Expect ';' after variable declaration.")
+        return Var(name, initializer)
+
+    def match(self, *types: TokenType) -> bool:
+        for type in types:
+            if self.check(type):
+                self.advance()
+                return True
+        return False
+
+    def check(self, type: TokenType) -> bool:
+        if self.is_at_end():
+            return False
+        return self.peek().type == type
+
+    def advance(self) -> Token:
+        if not self.is_at_end():
+            self.current += 1
+        return self.previous()
+
+    def is_at_end(self) -> bool:
+        return self.peek().type == TokenType.EOF
+
+    def peek(self) -> Token:
+        return self.tokens[self.current]
+
+    def previous(self) -> Token:
+        return self.tokens[self.current - 1]
+
+    def consume(self, type: TokenType, message: str) -> Token:
+        if self.check(type):
+            return self.advance()
+        raise self.error(self.peek(), message)
+
+    def error(self, token: Token, message: str):
+        # TODO: Implement proper error handling
+        raise ParseError(f"Error at {token.lexeme}: {message}")
+
+    def synchronize(self):
+        self.advance()
+
+        while not self.is_at_end():
+            if self.previous().type == TokenType.SEMICOLON:
+                return
+
+            match self.peek().type:
+                case TokenType.FUNC | TokenType.IF | TokenType.RETURN | TokenType.WHILE | TokenType.VAR | TokenType.FOR:
+                    return
+
+            self.advance()
+
+class ParseError(Exception):
+    pass