inscript-lang 2.2.0__tar.gz → 2.3.0__tar.gz

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.2.0
+Version: 2.3.0
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/ast_nodes.py

@@ -751,3 +751,8 @@ class DestructParam(Node):
     names:    list   # list of str (field/element names to bind)
     rest:     object # str name for rest element (...tail), or None
     type_ann: object # TypeAnnotation or None
+
+@dataclass
+class TaskSpawnExpr(Node):
+    """v2.3.0: spawn <expr> — run expression concurrently, return InScriptTask."""
+    expr: object

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "2.2.0"
+VERSION = "2.3.0"
 
 MANIFEST_FILENAME = "inscript.toml"
 LOCK_FILENAME     = "inscript.lock"

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/inscript_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.2.0
+Version: 2.3.0
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/interpreter.py

@@ -421,13 +421,16 @@ class Interpreter(Visitor):
             "is_bool":     lambda v: isinstance(v, bool),
             "is_array":    lambda v: isinstance(v, list),
             "is_dict":     lambda v: isinstance(v, dict),
-            # ── Concurrency (lightweight stubs, full impl via async/await) ─────
-            "thread":      lambda fn, *args: self._spawn_thread(fn, list(args)),
-            "channel":      lambda cap=0: {"_type":"channel","_channel":__import__("queue").SimpleQueue(),"_cap":int(cap)},
-            "make_channel": lambda cap=0: {"_type":"channel","_channel":__import__("queue").SimpleQueue(),"_cap":int(cap)},
-            "chan_send":    lambda ch, v: ch["_channel"].put(v) if isinstance(ch,dict) and "_channel" in ch else None,
-            "chan_recv":    lambda ch: ch["_channel"].get(timeout=5) if isinstance(ch,dict) and "_channel" in ch else None,
-            "sleep":       lambda s: __import__('time').sleep(s),
+            # ── Concurrency v2.3.0 ───────────────────────────────────────────
+            "thread":       lambda fn, *args: self._spawn_thread(fn, list(args)),
+            "channel":      lambda cap=0: __import__('stdlib_values').InScriptChannel(int(cap) if cap else 0),
+            "make_channel": lambda cap=0: __import__('stdlib_values').InScriptChannel(int(cap) if cap else 0),
+            "chan_send":     lambda ch, v: ch.send(v) if hasattr(ch, 'send') else (ch["_channel"].put(v) if isinstance(ch, dict) and "_channel" in ch else None),
+            "chan_recv":     lambda ch: ch.recv() if hasattr(ch, 'recv') else (ch["_channel"].get(timeout=5) if isinstance(ch, dict) and "_channel" in ch else None),
+            "chan_try_recv": lambda ch: ch.try_recv() if hasattr(ch, 'try_recv') else None,
+            "mutex":        lambda v=None: __import__('stdlib_values').InScriptMutex(v),
+            "rwlock":       lambda v=None: __import__('stdlib_values').InScriptRWLock(v),
+            "sleep":        lambda s: __import__('time').sleep(s),
             # ── JSON ──────────────────────────────────────────────────────────
             "json_encode": lambda v: __import__('json').dumps(v),
             "json_decode": lambda s: __import__('json').loads(s),
@@ -1080,6 +1083,30 @@ class Interpreter(Visitor):
         if isinstance(iterable, dict) and iterable.get("_enum_definition"):
             variants = [v for k, v in iterable.items() if not k.startswith("_")]
             iterable = variants
+        # v2.3.0: async for var in channel { } — drain channel until closed
+        from stdlib_values import InScriptChannel as _ISCh
+        if isinstance(iterable, _ISCh) and getattr(node, '_async_iter', False):
+            while not (iterable.closed and iterable._q.empty()):
+                val = iterable.try_recv()
+                if val is None:
+                    if iterable.closed:
+                        break
+                    import time as _t; _t.sleep(0.001)
+                    continue
+                self._push("for")
+                self._env.define(node.var_name, val)
+                try:
+                    self._exec_block_no_scope(node.body)
+                except BreakSignal as sig:
+                    self._pop()
+                    if sig.label: raise
+                    break
+                except ContinueSignal as sig:
+                    self._pop()
+                    if sig.label: raise
+                    continue
+                self._pop()
+            return
         # Support list, range, InScriptRange, string, dict, generator
         if isinstance(iterable, InScriptRange):
             it = iter(iterable)
@@ -2524,11 +2551,10 @@ class Interpreter(Visitor):
 
     def visit_AwaitExpr(self, node: AwaitExpr) -> Any:
         """
-        v1.9.7: True async/await.
-        - InScriptCoroutine → drive via Python coroutine protocol (sync driver).
-        - Plain value → passthrough (backwards compatible).
-        - Exceptions from inside the coroutine are converted to InScriptRuntimeError
-          so they are catchable by InScript try/catch blocks.
+        v2.3.0: await <expr>
+        InScript async fns return InScriptCoroutine. We drive them to completion
+        using send(None) — the coroutine body runs synchronously and raises
+        StopIteration(result) immediately (InScript has no real IO yields).
         """
         val = self.visit(node.expr)
         if isinstance(val, InScriptCoroutine):
@@ -2538,17 +2564,77 @@ class Interpreter(Visitor):
             except StopIteration as e:
                 return e.value
             except InScriptRuntimeError:
-                raise   # already an InScript error, let it propagate
+                raise
             except Exception as e:
-                # Convert Python exceptions to InScriptRuntimeError so
-                # they are catchable by InScript try/catch blocks.
                 err = InScriptRuntimeError(str(e), getattr(node, 'line', 0))
                 err.thrown_value = str(e)
                 raise err
-        return val   # plain value: passthrough
+        return val   # plain value passthrough
 
-    def visit_SpawnExpr(self, node: SpawnExpr) -> Any:
-        return None   # Phase 6 (ECS)
+    def visit_SpawnExpr(self, node) -> Any:
+        """ECS spawn — handled by game backend; stub in core interpreter."""
+        return None
+
+    def visit_TaskSpawnExpr(self, node) -> Any:
+        """v2.3.0: spawn <expr> — run in background thread, return InScriptTask."""
+        from stdlib_values import InScriptTask
+        expr_val = self.visit(node.expr)
+        if isinstance(expr_val, InScriptCoroutine):
+            coro = expr_val.coro
+            def _run_coro():
+                try:
+                    coro.send(None)
+                except StopIteration as e:
+                    return e.value
+                return None
+            task = InScriptTask(_run_coro, None)
+        elif callable(expr_val):
+            fn = expr_val
+            def _run_fn():
+                return self._call_fn(fn, [])
+            task = InScriptTask(_run_fn, None)
+        else:
+            val = expr_val
+            task = InScriptTask(lambda: val, None)
+        return task
+
+    def visit_SelectStmt(self, node) -> Any:
+        """v2.3.0: select { case x = ch.recv() { } case ch.send(v) { } case timeout(t) { } }"""
+        from stdlib_values import InScriptChannel
+        from ast_nodes import CallExpr, GetAttrExpr
+        for clause in node.clauses:
+            kind = clause.get("kind")
+            if kind == "recv":
+                # clause["channel"] is CallExpr(callee=GetAttr(ch, "recv"), args=[])
+                call_expr = clause.get("channel")
+                if call_expr and isinstance(call_expr, CallExpr):
+                    ch = self.visit(call_expr.callee.obj)
+                else:
+                    ch = None
+                if isinstance(ch, InScriptChannel):
+                    val = ch.try_recv()
+                    if val is not None:
+                        var = clause.get("var")
+                        if var:
+                            self._env.define(var, val)
+                        self.visit(clause["body"])
+                        return
+            elif kind == "send":
+                # clause["channel"] is CallExpr(callee=GetAttr(ch, "send"), args=[val])
+                call_expr = clause.get("channel")
+                if call_expr and isinstance(call_expr, CallExpr):
+                    ch  = self.visit(call_expr.callee.obj)
+                    val = self.visit(call_expr.args[0].value) if call_expr.args else None
+                else:
+                    ch = val = None
+                if isinstance(ch, InScriptChannel) and not ch._q.full():
+                    ch.send(val)
+                    self.visit(clause["body"])
+                    return
+            elif kind == "timeout":
+                # Timeout clause fires as fallback — always last resort
+                self.visit(clause["body"])
+                return
 
     def visit_MatchArm(self, node: MatchArm) -> Any:
         return self.visit(node.body)
@@ -2869,6 +2955,41 @@ def _arr_count(lst, fn_or_val, interp):
 
 
 def _get_attr(obj: Any, name: str, line: int, interp: Interpreter) -> Any:
+    # v2.3.0: concurrency primitive attribute dispatch
+    from stdlib_values import InScriptTask, InScriptChannel, InScriptMutex, InScriptRWLock, InScriptTimerHandle
+
+    if isinstance(obj, InScriptTask):
+        if name == "join":   return lambda timeout=None: obj.join(timeout)
+        if name == "done":   return obj.done
+        if name == "result": return obj._result
+        interp._error(f"Task has no member '{name}'. Available: join, done, result", line)
+
+    if isinstance(obj, InScriptChannel):
+        if name == "send":      return lambda v: obj.send(v)
+        if name == "recv":      return lambda: obj.recv()
+        if name == "try_recv":  return lambda: obj.try_recv()
+        if name == "close":     return lambda: obj.close()
+        if name == "closed":    return obj.closed
+        if name == "size":      return obj._q.qsize()
+        if name == "is_empty":  return obj._q.empty()
+        interp._error(f"Channel has no member '{name}'. Available: send, recv, try_recv, close, closed, size", line)
+
+    if isinstance(obj, InScriptMutex):
+        if name == "lock":   return lambda fn: obj.lock(lambda args: interp._call_fn(fn, args))
+        if name == "set":    return lambda v: obj.set(v)
+        if name == "value":  return obj.value
+        interp._error(f"Mutex has no member '{name}'. Available: lock, set, value", line)
+
+    if isinstance(obj, InScriptRWLock):
+        if name == "read":   return lambda fn: obj.read(lambda args: interp._call_fn(fn, args))
+        if name == "write":  return lambda fn: obj.write(lambda args: interp._call_fn(fn, args))
+        if name == "value":  return obj.value
+        interp._error(f"RWLock has no member '{name}'. Available: read, write, value", line)
+
+    if isinstance(obj, InScriptTimerHandle):
+        if name == "cancel": return lambda: obj.cancel()
+        interp._error(f"TimerHandle has no member '{name}'. Available: cancel", line)
+
     # StructDecl used as namespace for static method access: M.sq(5)
     if isinstance(obj, StructDecl):
         if hasattr(obj, '_static_ns') and name in obj._static_ns:

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/parser.py

@@ -147,6 +147,12 @@ class Parser:
 
         # --- Async/Await ---
         if tok.type == TT.ASYNC:
+            # v2.3.0: async for var in channel { } — iterate over async iterable
+            if self.peek.type == TT.FOR:
+                self.advance()  # consume 'async'
+                node = self.parse_for_in()
+                node._async_iter = True  # flag for interpreter
+                return node
             return self.parse_async_fn()
 
         # --- Await expr ---
@@ -1817,6 +1823,26 @@ class Parser:
                 args = self.parse_arg_list()
                 expr = CallExpr(callee=expr, args=args, line=line, col=col)
 
+            # v2.3.0: generic builtin call: channel<T>(cap) / Stack<T>() etc.
+            # Pattern: IDENT < TYPE_OR_IDENT > (
+            elif (self.check(TT.LT)
+                  and isinstance(expr, IdentExpr)
+                  and self.peek.type in (TT.INT_TYPE, TT.FLOAT_TYPE, TT.STRING_TYPE,
+                                         TT.BOOL_TYPE, TT.IDENT, TT.VOID_TYPE)):
+                saved = self.pos
+                self.advance()  # consume '<'
+                self.advance()  # consume type name
+                if self.check(TT.GT):
+                    self.advance()  # consume '>'
+                    if self.check(TT.LPAREN):
+                        # It's a generic call — type param is stripped (runtime ignores it)
+                        args = self.parse_arg_list()
+                        expr = CallExpr(callee=expr, args=args, line=line, col=col)
+                        continue
+                # Not a generic call — backtrack and stop postfix chain
+                self.pos = saved
+                break
+
             # Optional chaining: expr?.member  or  expr?.method(args)
             elif self.check(TT.QUESTION_DOT):
                 self.advance()  # consume '?.'
@@ -2039,6 +2065,13 @@ class Parser:
             expr = self.parse_unary()
             return AwaitExpr(expr=expr, line=line, col=col)
 
+        # v2.3.0: spawn <expr> — concurrency task
+        if tok.type == TT.SPAWN:
+            self.advance()  # consume 'spawn'
+            expr = self.parse_unary()
+            from ast_nodes import TaskSpawnExpr
+            return TaskSpawnExpr(expr=expr, line=line, col=col)
+
         # try { expr } catch e { expr } — try as expression (returns value)
         if tok.type == TT.TRY:
             return self._parse_try_expr()

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "2.2.0"
+version = "2.3.0"
 description = "InScript — a game-focused scripting language with 59 game modules and a bytecode VM"
 readme = "README.md"
 license = { text = "MIT" }

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/repl.py

@@ -40,7 +40,7 @@ sys.path.insert(0, str(Path(__file__).parent))
 
 HISTORY_FILE = Path.home() / ".inscript" / "history"
 HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
-VERSION = "2.2.0"
+VERSION = "2.3.0"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/stdlib.py

@@ -1063,8 +1063,79 @@ except KeyError:
         "sleep_sync": _timer_sleep_sync,  # synchronous fallback
         "now":        lambda: int(_time_mod.time() * 1000),  # ms since epoch
         "now_sec":    lambda: _time_mod.time(),              # seconds since epoch
+        # v2.3.0: after / every / cancel
+        "after":      None,   # patched below
+        "every":      None,   # patched below
+        "cancel":     None,   # patched below
     })
 
+# v2.3.0: patch timer.after / timer.every / timer.cancel
+try:
+    import threading as _thr_mod
+    from stdlib_values import InScriptTimerHandle as _THndl
+
+    def _timer_after(ms, fn):
+        """timer.after(ms, fn) — call fn() once after ms milliseconds."""
+        def _fire():
+            try: fn([])
+            except Exception: pass
+        t = _thr_mod.Timer(int(ms) / 1000.0, _fire)
+        t.daemon = True
+        t.start()
+        return _THndl(t)
+
+    def _timer_every(ms, fn):
+        """timer.every(ms, fn) — call fn() every ms milliseconds until cancelled."""
+        handle = [None]
+        def _tick():
+            try: fn([])
+            except Exception: pass
+            t = _thr_mod.Timer(int(ms) / 1000.0, _tick)
+            t.daemon = True
+            handle[0] = t
+            t.start()
+        t0 = _thr_mod.Timer(int(ms) / 1000.0, _tick)
+        t0.daemon = True
+        handle[0] = t0
+        t0.start()
+        class _EveryHandle:
+            def cancel(self): handle[0] and handle[0].cancel()
+            def __repr__(self): return "<TimerHandle periodic>"
+        return _EveryHandle()
+
+    def _timer_cancel(handle):
+        if hasattr(handle, 'cancel'): handle.cancel()
+
+    _MODULES["timer"]["after"]  = _timer_after
+    _MODULES["timer"]["every"]  = _timer_every
+    _MODULES["timer"]["cancel"] = _timer_cancel
+except Exception as _te:
+    pass
+
+# v2.3.0: channel, mutex, rwlock as global builtins
+try:
+    from stdlib_values import InScriptChannel as _ISChannel
+    from stdlib_values import InScriptMutex   as _ISMutex
+    from stdlib_values import InScriptRWLock  as _ISRWLock
+
+    def _make_channel(capacity=0):
+        cap = capacity[0] if isinstance(capacity, list) and capacity else (capacity or 0)
+        return _ISChannel(int(cap))
+
+    def _make_mutex(value=None):
+        v = value[0] if isinstance(value, list) and value else value
+        return _ISMutex(v)
+
+    def _make_rwlock(value=None):
+        v = value[0] if isinstance(value, list) and value else value
+        return _ISRWLock(v)
+
+    # Register as global builtins (not modules)
+    # channel/mutex/rwlock are registered directly in the interpreter globals (interpreter.py)
+    pass
+except Exception as _ce:
+    pass
+
 
 
 # ── Extended stdlib (Part 1): collections, datetime, fs, process, log, test, compress

{inscript_lang-2.2.0 → inscript_lang-2.3.0}/stdlib_values.py

@@ -326,3 +326,151 @@ class InScriptGenerator:
         except StopIteration:
             self._done = True
             return None
+
+
+# ── v2.3.0: Concurrency primitives ───────────────────────────────────────────
+
+import threading as _threading
+import queue as _queue
+
+class InScriptTask:
+    """
+    v2.3.0: Handle returned by `spawn expr`.
+    Runs a callable in a background thread.
+    """
+    def __init__(self, fn, args):
+        self._result  = None
+        self._error   = None
+        self._done    = _threading.Event()
+        self._thread  = _threading.Thread(target=self._run, args=(fn, args), daemon=True)
+        self._thread.start()
+
+    def _run(self, fn, args):
+        try:
+            self._result = fn()
+        except Exception as e:
+            self._error = e
+        finally:
+            self._done.set()
+
+    def join(self, timeout=None):
+        """Block until task completes. Returns result or raises."""
+        self._done.wait(timeout)
+        if self._error:
+            raise self._error
+        return self._result
+
+    @property
+    def done(self):
+        return self._done.is_set()
+
+    def __repr__(self):
+        return f"<Task {'done' if self.done else 'running'}>"
+
+
+class InScriptChannel:
+    """
+    v2.3.0: `channel<T>(capacity)` — typed message-passing queue.
+    .send(v)       — put value (blocks if full, capacity=0 means unbounded)
+    .recv()        — get value (blocks until available)
+    .try_recv()    — get value or nil (non-blocking)
+    .close()       — mark channel closed
+    .closed        — bool
+    """
+    def __init__(self, capacity: int = 0):
+        self._q      = _queue.Queue(maxsize=capacity)
+        self._closed = False
+
+    def send(self, value):
+        if self._closed:
+            raise RuntimeError("send on closed channel")
+        self._q.put(value)
+
+    def recv(self):
+        return self._q.get()
+
+    def try_recv(self):
+        try:
+            return self._q.get_nowait()
+        except _queue.Empty:
+            return None
+
+    def close(self):
+        self._closed = True
+
+    @property
+    def closed(self):
+        return self._closed
+
+    def __repr__(self):
+        return f"<Channel size={self._q.qsize()} closed={self._closed}>"
+
+
+class InScriptMutex:
+    """
+    v2.3.0: `mutex(value)` — thread-safe value wrapper.
+    .lock(fn)    — call fn(value) under lock, returns fn's result
+    .value       — read current value (unsafe, prefer lock())
+    .set(v)      — set value under lock
+    """
+    def __init__(self, value):
+        self._value = value
+        self._lock  = _threading.Lock()
+
+    def lock(self, fn):
+        with self._lock:
+            result = fn([self._value]) if callable(fn) else None
+            return result
+
+    def set(self, value):
+        with self._lock:
+            self._value = value
+
+    @property
+    def value(self):
+        return self._value
+
+    def __repr__(self):
+        return f"<Mutex value={self._value!r}>"
+
+
+class InScriptRWLock:
+    """
+    v2.3.0: `rwlock(value)` — reader/writer lock.
+    .read(fn)    — call fn(value) under read lock
+    .write(fn)   — call fn(value) under write lock, fn may return new value
+    """
+    def __init__(self, value):
+        self._value  = value
+        self._lock   = _threading.RLock()   # simplified: use reentrant lock
+
+    def read(self, fn):
+        with self._lock:
+            return fn([self._value]) if callable(fn) else self._value
+
+    def write(self, fn):
+        with self._lock:
+            result = fn([self._value]) if callable(fn) else None
+            if result is not None:
+                self._value = result
+            return result
+
+    @property
+    def value(self):
+        return self._value
+
+    def __repr__(self):
+        return f"<RWLock value={self._value!r}>"
+
+
+class InScriptTimerHandle:
+    """Handle returned by timer.after / timer.every for cancellation."""
+    def __init__(self, timer_obj):
+        self._timer = timer_obj   # threading.Timer or periodic wrapper
+
+    def cancel(self):
+        if hasattr(self._timer, 'cancel'):
+            self._timer.cancel()
+
+    def __repr__(self):
+        return "<TimerHandle>"