tengwar 0.3.1__tar.gz → 0.3.3__tar.gz

{tengwar-0.3.1/tengwar.egg-info → tengwar-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tengwar
-Version: 0.3.1
+Version: 0.3.3
 Summary: The AI-Native Programming Language
 Author: TENGWAR Project
 License: MIT

{tengwar-0.3.1 → tengwar-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tengwar"
-version = "0.3.1"
+version = "0.3.3"
 description = "The AI-Native Programming Language"
 readme = "README.md"
 license = {text = "MIT"}

{tengwar-0.3.1 → tengwar-0.3.3}/tengwar/__init__.py

@@ -5,7 +5,7 @@ Built from first principles for machine intelligence.
 Zero ambiguity. Maximum semantic density. Binary AST protocol.
 """
 
-__version__ = "0.3.1"
+__version__ = "0.3.3"
 __author__ = "TENGWAR Project"
 
 from .lexer import tokenize

{tengwar-0.3.1 → tengwar-0.3.3}/tengwar/ast_nodes.py

@@ -215,8 +215,9 @@ class TypeAnn(ASTNode):
 
 @dataclass
 class Proof(ASTNode):
-    """(⊢ assertion) - proof obligation"""
+    """(⊢ assertion) or (⊢ assertion message) - proof obligation"""
     assertion: Any = None
+    message: Any = None
     def __post_init__(self):
         self.type = NodeType.PROOF
 

{tengwar-0.3.1 → tengwar-0.3.3}/tengwar/interpreter.py

@@ -74,6 +74,21 @@ class TengwarVector(TengwarValue):
     def __eq__(self, other): return isinstance(other, TengwarVector) and self.elements == other.elements
 
 
+class TengwarLazy(TengwarValue):
+    """Lazy sequence — generated on demand by take/head/etc."""
+    def __init__(self, gen_fn, init_val):
+        self.gen_fn = gen_fn  # function: val -> next_val
+        self.init_val = init_val
+    def take(self, n, call_fn):
+        result = [self.init_val]
+        val = self.init_val
+        for _ in range(n - 1):
+            val = call_fn(self.gen_fn, [val])
+            result.append(val)
+        return result
+    def __repr__(self): return f'<lazy-seq from {repr(self.init_val)}>'
+
+
 class TengwarClosure(TengwarValue):
     def __init__(self, params: list, body, env: 'Environment', name: str = ""):
         self.params = params
@@ -241,6 +256,8 @@ class Interpreter:
         # Vector/sequence ops
         env.set('vec', TengwarBuiltin('vec', lambda args: TengwarVector(list(args))))
         env.set('push', TengwarBuiltin('push', self._builtin_push))
+        env.set('cons', TengwarBuiltin('cons', self._builtin_cons))
+        env.set('prepend', TengwarBuiltin('prepend', self._builtin_cons))
         env.set('pop', TengwarBuiltin('pop', self._builtin_pop))
         env.set('get', TengwarBuiltin('get', self._builtin_get))
         env.set('set-at', TengwarBuiltin('set-at', self._builtin_set_at))
@@ -314,6 +331,7 @@ class Interpreter:
         env.set('&', TengwarBuiltin('&', lambda args: self._eval_binop('&', args[0], args[1])))
         env.set('|', TengwarBuiltin('|', lambda args: self._eval_binop('|', args[0], args[1])))
         env.set('!', TengwarBuiltin('!', lambda args: self._eval_unop('!', args[0])))
+        env.set('not', TengwarBuiltin('not', lambda args: self._eval_unop('!', args[0])))
 
         # === DICT / HASHMAP ===
         env.set('dict', TengwarBuiltin('dict', self._builtin_dict))
@@ -583,6 +601,13 @@ class Interpreter:
             raise RuntimeError_("push requires a vector")
         return TengwarVector(vec.elements + [args[1]])
 
+    def _builtin_cons(self, args):
+        """(cons element vector) — prepend element to front"""
+        elem, vec = args[0], args[1]
+        if not isinstance(vec, TengwarVector):
+            raise RuntimeError_("cons requires a vector as second argument")
+        return TengwarVector([elem] + vec.elements)
+
     def _builtin_pop(self, args):
         vec = args[0]
         if not isinstance(vec, TengwarVector):
@@ -695,13 +720,15 @@ class Interpreter:
         return TengwarVector(sorted(vec.elements, key=lambda e: e.value))
 
     def _builtin_flatten(self, args):
-        result = []
-        for e in args[0].elements:
-            if isinstance(e, TengwarVector):
-                result.extend(e.elements)
-            else:
-                result.append(e)
-        return TengwarVector(result)
+        def _deep_flatten(elements):
+            result = []
+            for e in elements:
+                if isinstance(e, TengwarVector):
+                    result.extend(_deep_flatten(e.elements))
+                else:
+                    result.append(e)
+            return result
+        return TengwarVector(_deep_flatten(args[0].elements))
 
     def _builtin_zip(self, args):
         vecs = [a.elements for a in args]
@@ -717,6 +744,8 @@ class Interpreter:
 
     def _builtin_head(self, args):
         vec = args[0]
+        if isinstance(vec, TengwarLazy):
+            return vec.init_val
         if not vec.elements:
             raise RuntimeError_("head of empty vector")
         return vec.elements[0]
@@ -983,8 +1012,10 @@ class Interpreter:
         return TengwarInt(-1)
 
     def _builtin_take(self, args):
-        n, vec = int(self._num_val(args[0])), args[1]
-        return TengwarVector(vec.elements[:n])
+        n, seq = int(self._num_val(args[0])), args[1]
+        if isinstance(seq, TengwarLazy):
+            return TengwarVector(seq.take(n, self._call_function))
+        return TengwarVector(seq.elements[:n])
 
     def _builtin_drop(self, args):
         n, vec = int(self._num_val(args[0])), args[1]
@@ -1083,6 +1114,11 @@ class Interpreter:
         return TengwarVector([val] * n)
 
     def _builtin_iterate(self, args):
+        """(iterate fn init n) → eager vector, (iterate fn init) → lazy sequence"""
+        if len(args) == 2:
+            # Lazy form: return a TengwarLazy that take/head can consume
+            fn, init = args[0], args[1]
+            return TengwarLazy(fn, init)
         fn, init, n = args[0], args[1], int(self._num_val(args[2]))
         result = [init]
         val = init
@@ -1092,9 +1128,21 @@ class Interpreter:
         return TengwarVector(result)
 
     def _builtin_juxt(self, args):
-        """(juxt f1 f2 ... val) — apply multiple fns to same value"""
-        fns, val = args[:-1], args[-1]
-        return TengwarVector([self._call_function(fn, [val]) for fn in fns])
+        """(juxt f1 f2 ...) → fn, or ((juxt f1 f2 ...) val) → vector of results"""
+        def _is_tengwar_callable(x):
+            return isinstance(x, (TengwarBuiltin, TengwarClosure))
+        # If last arg is not callable, treat it as the value to apply to
+        if len(args) >= 2 and not _is_tengwar_callable(args[-1]):
+            fns, val = args[:-1], args[-1]
+            return TengwarVector([self._call_function(fn, [val]) for fn in fns])
+        else:
+            # Return a closure that applies all functions to a value
+            fns = list(args)
+            interp = self
+            def juxt_fn(inner_args):
+                val = inner_args[0]
+                return TengwarVector([interp._call_function(fn, [val]) for fn in fns])
+            return TengwarBuiltin('juxt*', juxt_fn)
 
     def _builtin_min_by(self, args):
         fn, vec = args[0], args[1]
@@ -1678,6 +1726,9 @@ class Interpreter:
         if isinstance(node, Proof):
             result = self.eval(node.assertion, env)
             if not self._is_truthy(result):
+                if node.message:
+                    msg = self.eval(node.message, env)
+                    raise ProofError(f"Proof obligation failed: {msg}")
                 raise ProofError(f"Proof obligation failed: {repr(result)}")
             return result
 
@@ -1788,9 +1839,9 @@ class Interpreter:
         raise RuntimeError_(f"Unknown node type: {type(node).__name__}")
 
     def _eval_binop(self, op: str, left: TengwarValue, right: TengwarValue) -> TengwarValue:
-        # String concatenation with +
-        if op == '+' and isinstance(left, TengwarStr):
-            return TengwarStr(left.value + self._display(right))
+        # String concatenation with + (both must be strings — no implicit coercion)
+        if op == '+' and isinstance(left, TengwarStr) and isinstance(right, TengwarStr):
+            return TengwarStr(left.value + right.value)
 
         # Numeric operations
         if isinstance(left, (TengwarInt, TengwarFloat)) and isinstance(right, (TengwarInt, TengwarFloat)):

{tengwar-0.3.1 → tengwar-0.3.3}/tengwar/lexer.py

@@ -120,7 +120,7 @@ KEYWORDS = {
     'do': TokenType.SEQ,
     'par': TokenType.PARALLEL,
     'nil': TokenType.UNIT,
-    'mod': TokenType.MODULE,
+    'module': TokenType.MODULE,
     # Note: let, pipe, throw, catch, try are handled as symbols
     # by the parser since they need custom parse rules
 }
@@ -130,6 +130,8 @@ SINGLE_CHAR = {
     ')': TokenType.RPAREN,
     '{': TokenType.LBRACE,
     '}': TokenType.RBRACE,
+    '[': TokenType.LBRACKET,
+    ']': TokenType.RBRACKET,
     '?': TokenType.COND,
     '~': TokenType.MATCH,
     '+': TokenType.PLUS,

{tengwar-0.3.1 → tengwar-0.3.3}/tengwar/parser.py

@@ -426,11 +426,14 @@ class Parser:
         return Recurse(name=name, body=body, line=line, col=col)
 
     def parse_proof(self, line: int, col: int) -> Proof:
-        """(⊢ assertion)"""
+        """(⊢ assertion) or (⊢ assertion message)"""
         self.advance()  # consume ⊢
         assertion = self.parse_expr()
+        message = None
+        if self.peek_type() != TokenType.RPAREN:
+            message = self.parse_expr()
         self.expect(TokenType.RPAREN)
-        return Proof(assertion=assertion, line=line, col=col)
+        return Proof(assertion=assertion, message=message, line=line, col=col)
 
     def parse_mutate(self, line: int, col: int) -> Mutate:
         """(μ name value)"""

{tengwar-0.3.1 → tengwar-0.3.3/tengwar.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tengwar
-Version: 0.3.1
+Version: 0.3.3
 Summary: The AI-Native Programming Language
 Author: TENGWAR Project
 License: MIT