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

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

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

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

@@ -735,3 +735,19 @@ class SelectStmt(Node):
     Each clause: {"kind": "recv"/"send"/"timeout", "var":str|None, "channel":expr|None, "value":expr|None, "duration":expr|None, "body":BlockStmt}
     """
     clauses: list   # list of clause dicts
+
+# ── v2.2.0 new nodes ─────────────────────────────────────────────────────────
+
+@dataclass
+class WithExpr(Node):
+    """with expr { .field = val, ... }  — clone-and-modify pattern."""
+    obj:    object   # expression producing the base object
+    fields: list     # list of (str field_name, expr value)
+
+@dataclass
+class DestructParam(Node):
+    """Destructuring parameter: fn f({x, y}: Point) or fn f([head, ...tail]: [])"""
+    kind:     str    # 'dict' or 'array'
+    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

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

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

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

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

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

@@ -1950,7 +1950,13 @@ class Interpreter(Visitor):
         op  = node.op
         target = node.target
 
-        if op != "=":
+        if op == "??=":
+            # v2.2.0: null-coalescing assignment — only assign if current value is nil
+            cur = self.visit(target)
+            if cur is not None:
+                return cur      # already non-nil, do nothing
+            # fall through to write val
+        elif op != "=":
             # Compound assignment: strip '=' to get operator ("+=" → "+", "**=" → "**")
             cur = self.visit(target)
             sym_op = op.rstrip("=")
@@ -2314,6 +2320,22 @@ class Interpreter(Visitor):
                     if getattr(param, 'is_variadic', False):
                         env.define(param.name, avs[i:]); break
                     val = avs[i] if i < len(avs) else (self.visit(param.default) if param.default else None)
+                    # v2.2.0: DestructParam — dict or array destructuring
+                    from ast_nodes import DestructParam as _DP
+                    if isinstance(param, _DP):
+                        if param.kind == 'dict':
+                            src = val if isinstance(val, dict) else (val.__dict__ if hasattr(val, '__dict__') else {})
+                            for fname in param.names:
+                                env.define(fname, src.get(fname))
+                            if param.rest:
+                                env.define(param.rest, {k: v for k, v in src.items() if k not in param.names})
+                        else:  # array
+                            src = list(val) if val is not None else []
+                            for j, fname in enumerate(param.names):
+                                env.define(fname, src[j] if j < len(src) else None)
+                            if param.rest:
+                                env.define(param.rest, src[len(param.names):])
+                        continue
                     if param.type_ann and val is not None:
                         ann_name = param.type_ann.name
                         if ann_name in generic_bindings:
@@ -2677,6 +2699,29 @@ class Interpreter(Visitor):
         val = self.visit(node.left)
         return self.visit(node.right) if val is None else val
 
+    def visit_WithExpr(self, node) -> Any:
+        """v2.2.0: with obj { .field = val, ... } — clone and modify."""
+        from stdlib_values import InScriptInstance
+        base = self.visit(node.obj)
+        if isinstance(base, InScriptInstance):
+            clone = InScriptInstance(
+                struct_name=base.struct_name,
+                fields=dict(base.fields),
+            )
+        elif isinstance(base, dict):
+            clone = dict(base)
+        else:
+            import copy; clone = copy.copy(base)
+        for field_name, val_expr in node.fields:
+            val = self.visit(val_expr)
+            if isinstance(clone, InScriptInstance):
+                clone.fields[field_name] = val
+            elif isinstance(clone, dict):
+                clone[field_name] = val
+            else:
+                _set_attr(clone, field_name, val, node.line, self)
+        return clone
+
     def visit_PipeExpr(self, node: PipeExpr) -> Any:
         """value |> fn — calls fn(value)."""
         val = self.visit(node.value)

{inscript_lang-2.1.1 → inscript_lang-2.2.0}/lexer.py

@@ -126,6 +126,7 @@ class TT(Enum):
     HASH        = auto()        # #   (attribute / annotation)
     AT          = auto()        # @   (decorator)
     NULLISH     = auto()        # ??  (nullish coalescing)
+    NULLISH_EQ  = auto()        # ??= (null-coalescing assignment)  v2.2.0
     QUESTION_DOT= auto()        # ?.  (optional chaining)
     PIPE_GT     = auto()        # |>  (pipe operator)
     FSTRING     = auto()        # f"..." (interpolated string — value is raw template)
@@ -574,7 +575,9 @@ class Lexer:
             if self.match(":"): emit(TT.DOUBLE_COLON, "::")
             else:               emit(TT.COLON,         ":")
         elif ch == "?":
-            if self.match("?"):  emit(TT.NULLISH,       "??")
+            if self.match("?"):
+                if self.match("="): emit(TT.NULLISH_EQ,   "??=")   # v2.2.0
+                else:               emit(TT.NULLISH,       "??")
             elif self.match("."): emit(TT.QUESTION_DOT, "?.")
             else:                emit(TT.QUESTION,       "?")
         elif ch == "#":

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

@@ -402,8 +402,24 @@ class Parser:
         line, col = self._pos()
 
         # Tuple type: (int, float)  — used for multiple return values
+        # v2.2.0: named return type (min: float, max: float)
         if self.check(TT.LPAREN):
             self.advance()  # consume '('
+            # Detect named tuple: (IDENT COLON ...)
+            if (self.current.type == TT.IDENT
+                    and self.peek.type == TT.COLON):
+                named_fields = []
+                while True:
+                    fname = self.expect_ident("Expected field name in named return type")
+                    self.expect(TT.COLON, "Expected ':' after field name")
+                    ftype = self.parse_type_annotation()
+                    named_fields.append((fname, ftype))
+                    if not self.match(TT.COMMA):
+                        break
+                self.expect(TT.RPAREN, "Expected ')' to close named return type")
+                ann = TypeAnnotation(name="NamedTuple", line=line, col=col)
+                ann.named_fields = named_fields
+                return ann
             # Just consume the tuple type contents and treat it as "Tuple"
             depth = 1
             while not self.is_at_end() and depth > 0:
@@ -416,12 +432,16 @@ class Parser:
             self.advance()  # consume final ')'
             return TypeAnnotation(name="Tuple", line=line, col=col)
 
-        # Array type: [int]
+        # Array type: [int]  or bare [] (any-element array)
         if self.match(TT.LBRACKET):
-            inner = self.parse_type_annotation()
-            self.expect(TT.RBRACKET, "Expected ']' to close array type")
-            ann = TypeAnnotation(name="Array", is_array=True,
-                                 generics=[inner], line=line, col=col)
+            if self.check(TT.RBRACKET):
+                self.advance()  # consume ']'  — bare [] means Array<any>
+                ann = TypeAnnotation(name="Array", is_array=True, line=line, col=col)
+            else:
+                inner = self.parse_type_annotation()
+                self.expect(TT.RBRACKET, "Expected ']' to close array type")
+                ann = TypeAnnotation(name="Array", is_array=True,
+                                     generics=[inner], line=line, col=col)
         # Dict type: {string: int}
         elif self.match(TT.LBRACE):
             key = self.parse_type_annotation()
@@ -647,6 +667,47 @@ class Parser:
         elif self.check(TT.ELLIPSIS):
             self.advance()   # consume '...'  (alias for variadic)
             is_variadic = True
+
+        # v2.2.0: dict destructuring param — fn f({x, y}: Point)
+        if self.check(TT.LBRACE):
+            self.advance()  # consume '{'
+            names = []
+            rest  = None
+            while not self.check(TT.RBRACE) and not self.check(TT.EOF):
+                if self.check(TT.ELLIPSIS):
+                    self.advance()
+                    rest = self.expect_ident("Expected rest name after '...'")
+                    break
+                names.append(self.expect_ident("Expected field name"))
+                self.match(TT.COMMA)
+            self.expect(TT.RBRACE, "Expected '}' to close destructuring param")
+            type_ann = None
+            if self.match(TT.COLON):
+                type_ann = self.parse_type_annotation()
+            from ast_nodes import DestructParam
+            return DestructParam(kind='dict', names=names, rest=rest,
+                                 type_ann=type_ann, line=line, col=col)
+
+        # v2.2.0: array destructuring param — fn f([head, ...tail]: [])
+        if self.check(TT.LBRACKET):
+            self.advance()  # consume '['
+            names = []
+            rest  = None
+            while not self.check(TT.RBRACKET) and not self.check(TT.EOF):
+                if self.check(TT.ELLIPSIS):
+                    self.advance()
+                    rest = self.expect_ident("Expected rest name after '...'")
+                    break
+                names.append(self.expect_ident("Expected element binding"))
+                self.match(TT.COMMA)
+            self.expect(TT.RBRACKET, "Expected ']' to close destructuring param")
+            type_ann = None
+            if self.match(TT.COLON):
+                type_ann = self.parse_type_annotation()
+            from ast_nodes import DestructParam
+            return DestructParam(kind='array', names=names, rest=rest,
+                                 type_ann=type_ann, line=line, col=col)
+
         name = self.expect_ident("Expected parameter name")
         type_ann = None
         if self.match(TT.COLON):
@@ -1418,6 +1479,7 @@ class Parser:
             TT.CARET_EQ:   "^=",
             TT.LSHIFT_EQ:  "<<=",
             TT.RSHIFT_EQ:  ">>=",
+            TT.NULLISH_EQ: "??=",   # v2.2.0
         }
 
         if self.current.type in ASSIGN_OPS:
@@ -1427,7 +1489,8 @@ class Parser:
 
             # Extract the binary operator from compound ops (strip trailing =)
             # e.g. "+=" → "+", "**=" → "**"
-            binop = op.rstrip("=") if op != "=" else None
+            # "??=" is special — not a binary op, handled by interpreter directly
+            binop = op.rstrip("=") if op not in ("=", "??=") else None
 
             # Determine which assignment node to create
             if isinstance(expr, IdentExpr):
@@ -1594,8 +1657,32 @@ class Parser:
         while self.check(TT.LT, TT.GT, TT.LTE, TT.GTE):
             op    = self.advance().value
             right = self.parse_shift()
-            left  = BinaryExpr(left=left, op=op, right=right,
-                                line=line, col=col)
+            node  = BinaryExpr(left=left, op=op, right=right,
+                               line=line, col=col)
+            # v2.2.0: chained comparisons — 0 < x < 10 → (0<x) and (x<10)
+            # If another comparison operator follows, desugar into `and`
+            if self.check(TT.LT, TT.GT, TT.LTE, TT.GTE):
+                left  = node   # left side of `and` is current comparison
+                # `right` becomes the new LHS for the next comparison
+                # We need to avoid evaluating `right` twice, but in a simple
+                # interpreter it's safe to reuse the same AST node (no side effects
+                # on simple expressions).  Build: node AND (right op next)
+                op2   = self.advance().value
+                right2 = self.parse_shift()
+                rhs   = BinaryExpr(left=right, op=op2, right=right2,
+                                   line=line, col=col)
+                left  = BinaryExpr(left=node, op="&&", right=rhs,
+                                   line=line, col=col)
+                while self.check(TT.LT, TT.GT, TT.LTE, TT.GTE):
+                    op3   = self.advance().value
+                    right3 = self.parse_shift()
+                    rhs3  = BinaryExpr(left=right2, op=op3, right=right3,
+                                       line=line, col=col)
+                    left  = BinaryExpr(left=left, op="&&", right=rhs3,
+                                       line=line, col=col)
+                    right2 = right3
+                return left
+            left = node
         return left
 
     def parse_shift(self) -> Node:
@@ -1879,6 +1966,25 @@ class Parser:
         # Grouped expression: (expr)  OR  Tuple: (expr, expr, ...)
         if tok.type == TT.LPAREN:
             self.advance()  # consume '('
+            # v2.2.0: named return tuple literal — (name: expr, name: expr, ...)
+            # Detect: IDENT COLON pattern at the start
+            if (self.current.type == TT.IDENT
+                    and self.peek.type == TT.COLON):
+                pairs = []
+                while True:
+                    key = self.expect_ident("Expected field name in named tuple")
+                    self.expect(TT.COLON, "Expected ':' after field name")
+                    val = self.parse_expr()
+                    pairs.append((key, val))
+                    if not self.match(TT.COMMA):
+                        break
+                self.expect(TT.RPAREN, "Expected ')' to close named tuple")
+                # Return as a DictLiteralExpr with string-key pairs
+                return DictLiteralExpr(
+                    pairs=[(StringLiteralExpr(value=k, line=line, col=col), v)
+                           for k, v in pairs],
+                    line=line, col=col
+                )
             first = self.parse_expr()
             if self.check(TT.COMMA):
                 # It's a tuple literal
@@ -1948,6 +2054,23 @@ class Parser:
                 self.advance()  # consume 'comptime'
                 body = self.parse_block()
                 return ComptimeExpr(body=body, line=line, col=col)
+            # v2.2.0: with expr { .field = val, ... } — clone-and-modify
+            if tok.value == "with":
+                self.advance()  # consume 'with'
+                obj = self.parse_postfix()
+                self.expect(TT.LBRACE, "Expected '{' after 'with <expr>'")
+                fields = []
+                while not self.check(TT.RBRACE) and not self.check(TT.EOF):
+                    self.expect(TT.DOT, "Expected '.field = val' inside with block")
+                    field_name = self.expect_ident("Expected field name after '.'")
+                    self.expect(TT.ASSIGN, "Expected '=' after field name in with block")
+                    val = self.parse_expr()
+                    fields.append((field_name, val))
+                    self.match(TT.COMMA)
+                    self.match(TT.NEWLINE) if hasattr(TT, 'NEWLINE') else None
+                self.expect(TT.RBRACE, "Expected '}' to close with block")
+                from ast_nodes import WithExpr
+                return WithExpr(obj=obj, fields=fields, line=line, col=col)
             return self.parse_ident_or_struct_init()
 
         # Type keywords used as constructors: Vec2(…) → these lex as IDENT anyway

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "2.1.1"
+version = "2.2.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.1.1 → inscript_lang-2.2.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.1.1"
+VERSION = "2.2.0"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):