tengwar 0.3.1__py3-none-any.whl

tengwar/repl.py

@@ -0,0 +1,152 @@
+"""
+TENGWAR REPL
+
+Interactive Read-Eval-Print Loop for TENGWAR.
+Designed for AI interaction but functional for any user.
+"""
+import sys
+import os
+from .lexer import tokenize
+from .parser import parse
+from .interpreter import Interpreter
+from .errors import TengwarError
+
+
+BANNER = """
+╔═══════════════════════════════════════════════════╗
+║   ▄▀▄ ▀▄▀ █ █▀█ █▄ █                             ║
+║   █▀█ █ █ █ █▄█ █ ▀█                             ║
+║                                                   ║
+║   The AI-Native Programming Language  v0.1.0      ║
+║   tengwarlang.dev                                   ║
+║                                                   ║
+║   Type expressions to evaluate. :q to quit.       ║
+║   :h for help.                                    ║
+╚═══════════════════════════════════════════════════╝
+"""
+
+HELP = """
+TENGWAR REPL Commands:
+  :q, :quit     Exit the REPL
+  :h, :help     Show this help
+  :env          Show current bindings
+  :trace        Toggle execution trace
+  :reset        Reset environment
+  :load <file>  Load and execute a .tw file
+
+Syntax Quick Reference:
+  (λ x y (+ x y))           Lambda / function
+  expr → name                Bind result to name
+  (? cond then else)         Conditional
+  (~ val pat1 res1 ...)      Pattern match
+  (>> e1 e2 ...)             Sequence
+  (∥ e1 e2 ...)              Parallel
+  (:= name value)            Define
+  (↺ f (λ n ...))            Recursion
+  ⟨a b c⟩                    Tuple
+  ⟦a b c⟧                    Vector
+  (⊢ assertion)              Proof check
+
+ASCII alternatives:
+  \\ = λ    -> = →    || = ∥    <| |> = ⟨⟩    [| |] = ⟦⟧
+  := = :=   |- = ⊢    +> = ⊕
+"""
+
+
+def repl(interpreter: Interpreter = None):
+    """Start the TENGWAR REPL"""
+    if interpreter is None:
+        interpreter = Interpreter()
+
+    print(BANNER)
+
+    buffer = ""
+    prompt = "λ> "
+
+    while True:
+        try:
+            line = input(prompt)
+        except (EOFError, KeyboardInterrupt):
+            print("\n∅")
+            break
+
+        # Commands
+        stripped = line.strip()
+        if stripped in (':q', ':quit'):
+            print("∅")
+            break
+        if stripped in (':h', ':help'):
+            print(HELP)
+            continue
+        if stripped == ':env':
+            for name, val in sorted(interpreter.global_env.bindings.items()):
+                print(f"  {name} = {repr(val)}")
+            print(f"\n  Content store: {len(interpreter.global_env.content_store)} entries")
+            continue
+        if stripped == ':trace':
+            interpreter.trace = not interpreter.trace
+            print(f"  Trace: {'on' if interpreter.trace else 'off'}")
+            continue
+        if stripped == ':reset':
+            interpreter = Interpreter()
+            print("  Environment reset.")
+            continue
+        if stripped.startswith(':load '):
+            path = stripped[6:].strip()
+            try:
+                with open(path, 'r', encoding='utf-8') as f:
+                    source = f.read()
+                result = interpreter.run_source(source)
+                print(f"  → {repr(result)}")
+            except FileNotFoundError:
+                print(f"  Error: File not found: {path}")
+            except TengwarError as e:
+                print(f"  Error: {e}")
+            continue
+
+        if not stripped:
+            continue
+
+        # Accumulate multiline input (count parens)
+        buffer += line + "\n"
+        open_parens = buffer.count('(') - buffer.count(')')
+        open_parens += buffer.count('⟨') - buffer.count('⟩')
+        open_parens += buffer.count('⟦') - buffer.count('⟧')
+
+        if open_parens > 0:
+            prompt = ".. "
+            continue
+
+        # Evaluate
+        try:
+            source = buffer.strip()
+            buffer = ""
+            prompt = "λ> "
+
+            result = interpreter.run_source(source)
+            if result is not None:
+                print(f"  → {repr(result)}")
+        except TengwarError as e:
+            print(f"  Error: {e}")
+        except Exception as e:
+            print(f"  Internal error: {e}")
+
+
+def run_file(path: str, trace: bool = False):
+    """Execute an TENGWAR source file"""
+    interpreter = Interpreter()
+    interpreter.trace = trace
+
+    with open(path, 'r', encoding='utf-8') as f:
+        source = f.read()
+
+    try:
+        result = interpreter.run_source(source)
+        return result
+    except TengwarError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    repl()

tengwar/vm.py

@@ -0,0 +1,425 @@
+"""
+TENGWAR Bytecode VM
+
+Compiles AST to stack-based bytecode and executes it.
+Gives 10-100x speedup over tree-walking for tight loops.
+
+Architecture:
+  - Stack-based VM (like Python, JVM, Lua)
+  - Compile AST → bytecode (list of instructions)
+  - Execute bytecode in a tight loop
+  - Falls back to tree-walker for complex forms (modules, parallel, etc.)
+"""
+
+from typing import Any, List, Optional, Dict
+from .ast_nodes import *
+from .interpreter import (
+    Interpreter, Environment, TengwarValue, TengwarInt, TengwarFloat,
+    TengwarStr, TengwarBool, TengwarUnit, TengwarVector, TengwarTuple,
+    TengwarClosure, TengwarBuiltin
+)
+
+
+# === OPCODES ===
+
+class BC:
+    """Bytecode opcodes"""
+    CONST       = 0   # push constant (arg: index into constants pool)
+    LOAD        = 1   # load variable (arg: name string)
+    STORE       = 2   # store variable (arg: name string)
+    POP         = 3   # discard top of stack
+    ADD         = 4   # pop 2, push sum
+    SUB         = 5
+    MUL         = 6
+    DIV         = 7
+    MOD         = 8
+    EQ          = 9
+    NEQ         = 10
+    LT          = 11
+    GT          = 12
+    LTE         = 13
+    GTE         = 14
+    AND         = 15
+    OR          = 16
+    NOT         = 17
+    JUMP        = 18  # unconditional jump (arg: target)
+    JUMP_IF_FALSE = 19  # conditional jump (arg: target)
+    CALL        = 20  # call function (arg: num_args)
+    RETURN      = 21  # return top of stack
+    MAKE_VEC    = 22  # make vector (arg: num_elements)
+    MAKE_TUPLE  = 23  # make tuple (arg: num_elements)
+    MAKE_CLOSURE = 24 # make closure (arg: index into code objects)
+    NOP         = 25  # no operation (used for patching)
+    DUP         = 26  # duplicate top of stack
+    NEG         = 27  # negate top of stack
+
+
+class Instruction:
+    __slots__ = ('op', 'arg')
+    def __init__(self, op: int, arg: Any = None):
+        self.op = op
+        self.arg = arg
+    def __repr__(self):
+        names = {v: k for k, v in BC.__dict__.items() if isinstance(v, int)}
+        return f"{names.get(self.op, '?')}({self.arg})"
+
+
+class CodeObject:
+    """Compiled function"""
+    __slots__ = ('params', 'code', 'constants', 'name')
+    def __init__(self, params: list, code: list, constants: list, name: str = "<fn>"):
+        self.params = params
+        self.code = code
+        self.constants = constants
+        self.name = name
+
+
+class CompiledClosure:
+    """Runtime closure wrapping a CodeObject"""
+    __slots__ = ('code_obj', 'env')
+    def __init__(self, code_obj: CodeObject, env: Environment):
+        self.code_obj = code_obj
+        self.env = env
+
+
+# === COMPILER ===
+
+class Compiler:
+    """Compile AST to bytecode"""
+    
+    def __init__(self):
+        self.code: List[Instruction] = []
+        self.constants: List[TengwarValue] = []
+        self.code_objects: List[CodeObject] = []
+    
+    def _emit(self, op: int, arg: Any = None) -> int:
+        idx = len(self.code)
+        self.code.append(Instruction(op, arg))
+        return idx
+    
+    def _add_const(self, val: TengwarValue) -> int:
+        self.constants.append(val)
+        return len(self.constants) - 1
+    
+    def compile(self, node: ASTNode) -> CodeObject:
+        """Compile an AST node to a code object"""
+        self.code = []
+        self.constants = []
+        self._compile_node(node)
+        self._emit(BC.RETURN)
+        return CodeObject(
+            params=[],
+            code=self.code[:],
+            constants=self.constants[:],
+            name="<main>"
+        )
+    
+    def _compile_node(self, node: ASTNode):
+        if isinstance(node, IntLit):
+            idx = self._add_const(TengwarInt(node.value))
+            self._emit(BC.CONST, idx)
+        
+        elif isinstance(node, FloatLit):
+            idx = self._add_const(TengwarFloat(node.value))
+            self._emit(BC.CONST, idx)
+        
+        elif isinstance(node, StrLit):
+            idx = self._add_const(TengwarStr(node.value))
+            self._emit(BC.CONST, idx)
+        
+        elif isinstance(node, BoolLit):
+            idx = self._add_const(TengwarBool(node.value))
+            self._emit(BC.CONST, idx)
+        
+        elif isinstance(node, UnitLit):
+            idx = self._add_const(TengwarUnit())
+            self._emit(BC.CONST, idx)
+        
+        elif isinstance(node, Symbol):
+            self._emit(BC.LOAD, node.name)
+        
+        elif isinstance(node, BinOp):
+            self._compile_node(node.left)
+            self._compile_node(node.right)
+            op_map = {
+                '+': BC.ADD, '-': BC.SUB, '*': BC.MUL, '/': BC.DIV,
+                '%': BC.MOD, '=': BC.EQ, '!=': BC.NEQ,
+                '<': BC.LT, '>': BC.GT, '<=': BC.LTE, '>=': BC.GTE,
+                '&': BC.AND, '|': BC.OR,
+            }
+            self._emit(op_map.get(node.op, BC.ADD))
+        
+        elif isinstance(node, UnOp):
+            self._compile_node(node.operand)
+            if node.op == '!':
+                self._emit(BC.NOT)
+            elif node.op == '-':
+                self._emit(BC.NEG)
+        
+        elif isinstance(node, Cond):
+            self._compile_node(node.condition)
+            jump_false = self._emit(BC.JUMP_IF_FALSE, None)
+            self._compile_node(node.then_branch)
+            jump_end = self._emit(BC.JUMP, None)
+            # Patch false jump
+            self.code[jump_false].arg = len(self.code)
+            self._compile_node(node.else_branch)
+            # Patch end jump
+            self.code[jump_end].arg = len(self.code)
+        
+        elif isinstance(node, Vector):
+            for elem in node.elements:
+                self._compile_node(elem)
+            self._emit(BC.MAKE_VEC, len(node.elements))
+        
+        elif isinstance(node, Tuple):
+            for elem in node.elements:
+                self._compile_node(elem)
+            self._emit(BC.MAKE_TUPLE, len(node.elements))
+        
+        elif isinstance(node, Define):
+            self._compile_node(node.value)
+            if isinstance(node.name, Symbol):
+                self._emit(BC.STORE, node.name.name)
+            else:
+                self._emit(BC.STORE, str(node.name))
+        
+        elif isinstance(node, Lambda):
+            # Compile lambda body as a separate code object
+            inner = Compiler()
+            inner._compile_node(node.body)
+            inner._emit(BC.RETURN)
+            params = [p.name if isinstance(p, Symbol) else str(p) for p in node.params]
+            co = CodeObject(
+                params=params,
+                code=inner.code[:],
+                constants=inner.constants[:],
+                name="<lambda>"
+            )
+            co_idx = len(self.code_objects)
+            self.code_objects.append(co)
+            self._emit(BC.MAKE_CLOSURE, co_idx)
+        
+        elif isinstance(node, Apply):
+            self._compile_node(node.func)
+            for arg in node.args:
+                self._compile_node(arg)
+            self._emit(BC.CALL, len(node.args))
+        
+        elif isinstance(node, Seq):
+            for i, expr in enumerate(node.exprs):
+                self._compile_node(expr)
+                if i < len(node.exprs) - 1:
+                    self._emit(BC.POP)
+        
+        elif isinstance(node, Program):
+            for i, expr in enumerate(node.body):
+                self._compile_node(expr)
+                if i < len(node.body) - 1:
+                    self._emit(BC.POP)
+        
+        elif isinstance(node, Let):
+            # Compile let bindings
+            for name_node, val_node in node.bindings:
+                self._compile_node(val_node)
+                name = name_node.name if isinstance(name_node, Symbol) else str(name_node)
+                self._emit(BC.STORE, name)
+            self._compile_node(node.body)
+        
+        elif isinstance(node, Recurse):
+            # Compile recursive definition
+            name = node.name.name if isinstance(node.name, Symbol) else str(node.name)
+            self._compile_node(node.body)
+            self._emit(BC.STORE, name)
+        
+        else:
+            # Fall back: store a reference to the AST node for interpreter eval
+            idx = self._add_const(node)  # Store AST node as constant
+            self._emit(BC.CONST, idx)
+
+
+# === VM ===
+
+class VM:
+    """Execute bytecode"""
+    
+    def __init__(self, interpreter: Interpreter):
+        self.interpreter = interpreter
+        self.compiler = Compiler()
+    
+    def execute(self, code_obj: CodeObject, env: Environment = None) -> TengwarValue:
+        """Execute a code object"""
+        if env is None:
+            env = self.interpreter.global_env
+        
+        stack: list = []
+        ip = 0
+        code = code_obj.code
+        consts = code_obj.constants
+        
+        while ip < len(code):
+            instr = code[ip]
+            op = instr.op
+            
+            if op == BC.CONST:
+                val = consts[instr.arg]
+                # If it's an AST node (fallback), evaluate it with interpreter
+                if isinstance(val, ASTNode):
+                    val = self.interpreter.eval(val, env)
+                stack.append(val)
+            
+            elif op == BC.LOAD:
+                try:
+                    stack.append(env.get(instr.arg))
+                except:
+                    # Try interpreter builtins
+                    stack.append(self.interpreter.global_env.get(instr.arg))
+            
+            elif op == BC.STORE:
+                val = stack[-1]  # Peek, don't pop (store returns the value)
+                env.set(instr.arg, val)
+            
+            elif op == BC.POP:
+                if stack:
+                    stack.pop()
+            
+            elif op == BC.ADD:
+                b, a = stack.pop(), stack.pop()
+                if isinstance(a, TengwarStr):
+                    stack.append(TengwarStr(a.value + self.interpreter._display(b)))
+                elif isinstance(a, TengwarFloat) or isinstance(b, TengwarFloat):
+                    stack.append(TengwarFloat(self.interpreter._num_val(a) + self.interpreter._num_val(b)))
+                else:
+                    stack.append(TengwarInt(a.value + b.value))
+            
+            elif op == BC.SUB:
+                b, a = stack.pop(), stack.pop()
+                if isinstance(a, TengwarFloat) or isinstance(b, TengwarFloat):
+                    stack.append(TengwarFloat(self.interpreter._num_val(a) - self.interpreter._num_val(b)))
+                else:
+                    stack.append(TengwarInt(a.value - b.value))
+            
+            elif op == BC.MUL:
+                b, a = stack.pop(), stack.pop()
+                if isinstance(a, TengwarFloat) or isinstance(b, TengwarFloat):
+                    stack.append(TengwarFloat(self.interpreter._num_val(a) * self.interpreter._num_val(b)))
+                else:
+                    stack.append(TengwarInt(a.value * b.value))
+            
+            elif op == BC.DIV:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarFloat(self.interpreter._num_val(a) / self.interpreter._num_val(b)))
+            
+            elif op == BC.MOD:
+                b, a = stack.pop(), stack.pop()
+                if isinstance(a, TengwarFloat) or isinstance(b, TengwarFloat):
+                    stack.append(TengwarFloat(self.interpreter._num_val(a) % self.interpreter._num_val(b)))
+                else:
+                    stack.append(TengwarInt(a.value % b.value))
+            
+            elif op == BC.EQ:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarBool(self.interpreter._values_equal(a, b)))
+            
+            elif op == BC.NEQ:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarBool(not self.interpreter._values_equal(a, b)))
+            
+            elif op == BC.LT:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarBool(self.interpreter._num_val(a) < self.interpreter._num_val(b)))
+            
+            elif op == BC.GT:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarBool(self.interpreter._num_val(a) > self.interpreter._num_val(b)))
+            
+            elif op == BC.LTE:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarBool(self.interpreter._num_val(a) <= self.interpreter._num_val(b)))
+            
+            elif op == BC.GTE:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarBool(self.interpreter._num_val(a) >= self.interpreter._num_val(b)))
+            
+            elif op == BC.AND:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarBool(self.interpreter._is_truthy(a) and self.interpreter._is_truthy(b)))
+            
+            elif op == BC.OR:
+                b, a = stack.pop(), stack.pop()
+                stack.append(TengwarBool(self.interpreter._is_truthy(a) or self.interpreter._is_truthy(b)))
+            
+            elif op == BC.NOT:
+                a = stack.pop()
+                stack.append(TengwarBool(not self.interpreter._is_truthy(a)))
+            
+            elif op == BC.NEG:
+                a = stack.pop()
+                if isinstance(a, TengwarFloat):
+                    stack.append(TengwarFloat(-a.value))
+                else:
+                    stack.append(TengwarInt(-self.interpreter._num_val(a)))
+            
+            elif op == BC.JUMP:
+                ip = instr.arg
+                continue
+            
+            elif op == BC.JUMP_IF_FALSE:
+                cond = stack.pop()
+                if not self.interpreter._is_truthy(cond):
+                    ip = instr.arg
+                    continue
+            
+            elif op == BC.CALL:
+                nargs = instr.arg
+                args = [stack.pop() for _ in range(nargs)][::-1]
+                func = stack.pop()
+                
+                if isinstance(func, CompiledClosure):
+                    # Execute compiled function
+                    child_env = Environment(parent=func.env)
+                    for param, arg in zip(func.code_obj.params, args):
+                        child_env.set(param, arg)
+                    result = self.execute(func.code_obj, child_env)
+                    stack.append(result)
+                elif isinstance(func, TengwarBuiltin):
+                    result = func.func(args)
+                    stack.append(result)
+                elif isinstance(func, TengwarClosure):
+                    result = self.interpreter._call_function(func, args)
+                    stack.append(result)
+                else:
+                    raise RuntimeError(f"Cannot call: {type(func)}")
+            
+            elif op == BC.RETURN:
+                return stack[-1] if stack else TengwarUnit()
+            
+            elif op == BC.MAKE_VEC:
+                n = instr.arg
+                elements = [stack.pop() for _ in range(n)][::-1]
+                stack.append(TengwarVector(elements))
+            
+            elif op == BC.MAKE_TUPLE:
+                n = instr.arg
+                elements = [stack.pop() for _ in range(n)][::-1]
+                stack.append(TengwarTuple(elements))
+            
+            elif op == BC.MAKE_CLOSURE:
+                co = self.compiler.code_objects[instr.arg]
+                stack.append(CompiledClosure(co, env))
+            
+            elif op == BC.DUP:
+                stack.append(stack[-1])
+            
+            ip += 1
+        
+        return stack[-1] if stack else TengwarUnit()
+    
+    def run_source(self, source: str) -> TengwarValue:
+        """Compile and execute source code"""
+        from .lexer import tokenize
+        from .parser import parse
+        tokens = tokenize(source)
+        ast = parse(tokens)
+        code_obj = self.compiler.compile(ast)
+        return self.execute(code_obj)