tengwar 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

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.2"
+__version__ = "0.3.4"
 __author__ = "TENGWAR Project"
 
 from .lexer import tokenize

tengwar/interpreter.py

@@ -74,6 +74,15 @@ class TengwarVector(TengwarValue):
     def __eq__(self, other): return isinstance(other, TengwarVector) and self.elements == other.elements
 
 
+class TengwarLazy(TengwarValue):
+    """Lazy sequence — uses a generator factory for composable lazy ops."""
+    def __init__(self, make_gen):
+        self._make_gen = make_gen  # callable that returns a fresh generator
+    def __iter__(self):
+        return self._make_gen()
+    def __repr__(self): return '<lazy-seq>'
+
+
 class TengwarClosure(TengwarValue):
     def __init__(self, params: list, body, env: 'Environment', name: str = ""):
         self.params = params
@@ -528,6 +537,8 @@ class Interpreter:
         return TengwarFloat(math.sqrt(args[0].value))
 
     def _builtin_mod(self, args):
+        if args[1].value == 0:
+            raise RuntimeError_("Modulo by zero")
         return TengwarInt(args[0].value % args[1].value)
 
     def _builtin_len(self, args):
@@ -627,15 +638,30 @@ class Interpreter:
         return TengwarVector(vec.elements[start:end])
 
     def _builtin_map(self, args):
-        fn, vec = args[0], args[1]
-        if not isinstance(vec, TengwarVector):
-            raise RuntimeError_("map requires a vector")
-        return TengwarVector([self._call_function(fn, [e]) for e in vec.elements])
+        fn, seq = args[0], args[1]
+        if isinstance(seq, TengwarLazy):
+            interp = self
+            parent = seq._make_gen
+            def make_gen():
+                for val in parent():
+                    yield interp._call_function(fn, [val])
+            return TengwarLazy(make_gen)
+        if not isinstance(seq, TengwarVector):
+            raise RuntimeError_("map requires a vector or lazy sequence")
+        return TengwarVector([self._call_function(fn, [e]) for e in seq.elements])
 
     def _builtin_filter(self, args):
-        fn, vec = args[0], args[1]
+        fn, seq = args[0], args[1]
+        if isinstance(seq, TengwarLazy):
+            interp = self
+            parent = seq._make_gen
+            def make_gen():
+                for val in parent():
+                    if interp._is_truthy(interp._call_function(fn, [val])):
+                        yield val
+            return TengwarLazy(make_gen)
         result = []
-        for e in vec.elements:
+        for e in seq.elements:
             if self._is_truthy(self._call_function(fn, [e])):
                 result.append(e)
         return TengwarVector(result)
@@ -729,12 +755,23 @@ class Interpreter:
 
     def _builtin_head(self, args):
         vec = args[0]
+        if isinstance(vec, TengwarLazy):
+            for val in vec:
+                return val
+            raise RuntimeError_("head of empty lazy sequence")
         if not vec.elements:
             raise RuntimeError_("head of empty vector")
         return vec.elements[0]
 
     def _builtin_tail(self, args):
         vec = args[0]
+        if isinstance(vec, TengwarLazy):
+            parent = vec._make_gen
+            def make_gen():
+                gen = parent()
+                next(gen, None)  # skip first
+                yield from gen
+            return TengwarLazy(make_gen)
         if not vec.elements:
             raise RuntimeError_("tail of empty vector")
         return TengwarVector(vec.elements[1:])
@@ -747,6 +784,11 @@ class Interpreter:
 
     def _builtin_nth(self, args):
         col, idx = args[0], args[1].value
+        if isinstance(col, TengwarLazy):
+            for i, val in enumerate(col):
+                if i == idx:
+                    return val
+            raise RuntimeError_(f"nth: index {idx} out of range")
         if isinstance(col, TengwarTuple): return col.elements[idx]
         if isinstance(col, TengwarVector): return col.elements[idx]
         raise RuntimeError_(f"Cannot nth into {type(col).__name__}")
@@ -880,8 +922,16 @@ class Interpreter:
     def _builtin_enumerate(self, args):
         """(enumerate vec) = vector of (index, element) tuples"""
         vec = args[0]
+        if isinstance(vec, TengwarLazy):
+            parent = vec._make_gen
+            def make_gen():
+                i = 0
+                for val in parent():
+                    yield TengwarTuple([TengwarInt(i), val])
+                    i += 1
+            return TengwarLazy(make_gen)
         if not isinstance(vec, TengwarVector):
-            raise RuntimeError_("enumerate requires a vector")
+            raise RuntimeError_("enumerate requires a vector or lazy sequence")
         return TengwarVector([
             TengwarTuple([TengwarInt(i), e])
             for i, e in enumerate(vec.elements)
@@ -898,10 +948,25 @@ class Interpreter:
     def _builtin_apply(self, args):
         fn, arg_vec = args[0], args[1]
         if isinstance(arg_vec, TengwarVector):
-            return self._call_function(fn, arg_vec.elements)
-        if isinstance(arg_vec, TengwarTuple):
-            return self._call_function(fn, arg_vec.elements)
-        return self._call_function(fn, [arg_vec])
+            elems = arg_vec.elements
+        elif isinstance(arg_vec, TengwarTuple):
+            elems = arg_vec.elements
+        else:
+            elems = [arg_vec]
+        if not elems:
+            raise RuntimeError_("apply: cannot apply function to empty collection")
+        if len(elems) == 1:
+            try:
+                return self._call_function(fn, elems)
+            except (TypeError, IndexError):
+                raise RuntimeError_("apply: function requires more arguments")
+        if len(elems) == 2:
+            return self._call_function(fn, elems)
+        # >2 args: reduce (Clojure-style variadic apply)
+        acc = self._call_function(fn, [elems[0], elems[1]])
+        for e in elems[2:]:
+            acc = self._call_function(fn, [acc, e])
+        return acc
 
     def _builtin_err(self, args):
         raise RuntimeError_(self._display(args[0]) if args else "error")
@@ -995,17 +1060,41 @@ 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):
+            result = []
+            for val in seq:
+                result.append(val)
+                if len(result) >= n:
+                    break
+            return TengwarVector(result)
+        return TengwarVector(seq.elements[:n])
 
     def _builtin_drop(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):
+            parent = seq._make_gen
+            count = n
+            def make_gen():
+                gen = parent()
+                for _ in range(count):
+                    next(gen, None)
+                yield from gen
+            return TengwarLazy(make_gen)
+        return TengwarVector(seq.elements[n:])
 
     def _builtin_take_while(self, args):
-        fn, vec = args[0], args[1]
+        fn, seq = args[0], args[1]
+        if isinstance(seq, TengwarLazy):
+            result = []
+            for val in seq:
+                if self._is_truthy(self._call_function(fn, [val])):
+                    result.append(val)
+                else:
+                    break
+            return TengwarVector(result)
         result = []
-        for e in vec.elements:
+        for e in seq.elements:
             if self._is_truthy(self._call_function(fn, [e])):
                 result.append(e)
             else:
@@ -1013,10 +1102,21 @@ class Interpreter:
         return TengwarVector(result)
 
     def _builtin_drop_while(self, args):
-        fn, vec = args[0], args[1]
+        fn, seq = args[0], args[1]
+        if isinstance(seq, TengwarLazy):
+            interp = self
+            parent = seq._make_gen
+            def make_gen():
+                dropping = True
+                for val in parent():
+                    if dropping and interp._is_truthy(interp._call_function(fn, [val])):
+                        continue
+                    dropping = False
+                    yield val
+            return TengwarLazy(make_gen)
         dropping = True
         result = []
-        for e in vec.elements:
+        for e in seq.elements:
             if dropping and self._is_truthy(self._call_function(fn, [e])):
                 continue
             dropping = False
@@ -1070,10 +1170,20 @@ class Interpreter:
         return TengwarTuple([TengwarVector(yes), TengwarVector(no)])
 
     def _builtin_scan(self, args):
-        fn, init, vec = args[0], args[1], args[2]
+        fn, init, seq = args[0], args[1], args[2]
+        if isinstance(seq, TengwarLazy):
+            interp = self
+            parent = seq._make_gen
+            def make_gen():
+                acc = init
+                yield acc
+                for val in parent():
+                    acc = interp._call_function(fn, [acc, val])
+                    yield acc
+            return TengwarLazy(make_gen)
         acc = init
         result = [acc]
-        for e in vec.elements:
+        for e in seq.elements:
             acc = self._call_function(fn, [acc, e])
             result.append(acc)
         return TengwarVector(result)
@@ -1095,6 +1205,16 @@ 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:
+            fn, init = args[0], args[1]
+            interp = self
+            def make_gen():
+                val = init
+                while True:
+                    yield val
+                    val = interp._call_function(fn, [val])
+            return TengwarLazy(make_gen)
         fn, init, n = args[0], args[1], int(self._num_val(args[2]))
         result = [init]
         val = init
@@ -1815,9 +1935,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)):
@@ -1831,7 +1951,9 @@ class Interpreter:
             if op == '/':
                 if rv == 0: raise RuntimeError_("Division by zero")
                 return TengwarFloat(lv / rv) if use_float else TengwarInt(lv // rv)
-            if op == '%': return wrap(lv % rv)
+            if op == '%':
+                if rv == 0: raise RuntimeError_("Modulo by zero")
+                return wrap(lv % rv)
             if op == '=': return TengwarBool(lv == rv)
             if op == '!=': return TengwarBool(lv != rv)
             if op == '<': return TengwarBool(lv < rv)

{tengwar-0.3.2.dist-info → tengwar-0.3.4.dist-info}/METADATA

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

{tengwar-0.3.2.dist-info → tengwar-0.3.4.dist-info}/RECORD

@@ -1,17 +1,17 @@
-tengwar/__init__.py,sha256=VTzmTP2TkxHnpaK9J0Scu_4UiIyo0rpM6bBEcEuN27E,579
+tengwar/__init__.py,sha256=r2Fv1Bxv43nmcSUzoe1rVFZ1c9rI8gwXht1EyIVuMLI,579
 tengwar/__main__.py,sha256=dF1qCzTBDRAf47QGJ6e2kqefPZztrEaE9WuM1n1NfLI,179
 tengwar/ast_nodes.py,sha256=ghhqQQBoqWT-oc9xdCGo2hXBLSqh1zz74hKDyIUtE_Y,7749
 tengwar/binary_ast.py,sha256=UVDGpk_OvHxPLcaToYkAuYA_cg9QQwj6yJXZ057dW0Q,20729
 tengwar/errors.py,sha256=tpZwlDorqUvqX-rtTjL2nhu51Kcdc2ozYBbnJBhR1Hk,773
-tengwar/interpreter.py,sha256=kqezVPs30DDE63Wb7LHu2SH2r6A5hMTaULKVK-ESAd8,80867
+tengwar/interpreter.py,sha256=t4Lun4pbUdVFwQoiU44_-1CSsjovo44u4CRX5IZRbuI,85532
 tengwar/lexer.py,sha256=d8MphHWmS6aA7HhRdu-CzX1Ma_3oYZSqkhNNrqLa_Ak,17666
 tengwar/mcp_server.py,sha256=P23h-OiedeiowHlvknKsDU1cZ1eaT2ZbXfjCMUGvHus,17921
 tengwar/parser.py,sha256=J9Sc4x8Rs9Rmc5IkOegcfuEWOSIi54fXhjwviF0SjvY,25141
 tengwar/repl.py,sha256=FOvKth8MLOEVExgUvdod-qJqLydbVFDEA1DRhVGjZnQ,4880
 tengwar/vm.py,sha256=etTJTufLqn76GAnZpzG_DLQQ3rXLsyFvHPEU3aNphIY,15883
-tengwar-0.3.2.dist-info/licenses/LICENSE,sha256=qzDJpz75A1ntwYbNw63k1J-9Ov6v4z62Uj7uDcWxv1w,1072
-tengwar-0.3.2.dist-info/METADATA,sha256=ZZ2gjmAMC7XCqCna3PzSNUfu5M7eIcRyU_jCBehIY9A,6949
-tengwar-0.3.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-tengwar-0.3.2.dist-info/entry_points.txt,sha256=W_Zolo2TLJBIDkgAkV7yWzQWKwicET_J9gs4crmrfI4,46
-tengwar-0.3.2.dist-info/top_level.txt,sha256=VyO8Esj_l1yx0c52WUt_KUheaLbXOv2O2kGPZ1eG38k,8
-tengwar-0.3.2.dist-info/RECORD,,
+tengwar-0.3.4.dist-info/licenses/LICENSE,sha256=qzDJpz75A1ntwYbNw63k1J-9Ov6v4z62Uj7uDcWxv1w,1072
+tengwar-0.3.4.dist-info/METADATA,sha256=Nb-AVaVRycCRe-lrQw8y7X7gkfNwyMSEl06vR4CTFa8,6949
+tengwar-0.3.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tengwar-0.3.4.dist-info/entry_points.txt,sha256=W_Zolo2TLJBIDkgAkV7yWzQWKwicET_J9gs4crmrfI4,46
+tengwar-0.3.4.dist-info/top_level.txt,sha256=VyO8Esj_l1yx0c52WUt_KUheaLbXOv2O2kGPZ1eG38k,8
+tengwar-0.3.4.dist-info/RECORD,,