feat(lang): collection unpacking, sequence ordering, raise TypeError.

Author: dylan-sutton-chavez

compiler/src/modules/parser/expr.rs

@@ -294,10 +294,10 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         }
     }
 
-    /* Postfix trailers: `.attr`, [i], [s:e], (args), chained. */
+    /* Postfix trailers: `.attr`, [i], [s:e], (args), chained. A trailer must start on the same line, so a statement boundary ends the chain (else `x = []` ⏎ `[i]` parses as `[][i]`). */
     pub(super) fn postfix_tail(&mut self) {
         loop {
-            match self.peek() {
+            match self.peek_same_line() {
                 Some(TokenType::Lsqb) => {
                     self.advance();
                     let is_slice = matches!(self.peek(), Some(TokenType::Colon));

compiler/src/modules/parser/literals.rs

@@ -18,6 +18,22 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             self.chunk.emit(OpCode::BuildDict, 0);
             return;
         }
+        // `{**m, ...}`: leading mapping-unpack => dict built incrementally.
+        if self.eat_if(TokenType::DoubleStar) {
+            self.chunk.emit(OpCode::BuildDict, 0);
+            self.expr();
+            self.chunk.emit(OpCode::DictUpdate, 0);
+            self.dict_tail(0, true);
+            return;
+        }
+        // `{*s, ...}`: leading iterable-unpack => set built incrementally.
+        if self.eat_if(TokenType::Star) {
+            self.chunk.emit(OpCode::BuildSet, 0);
+            self.expr();
+            self.chunk.emit(OpCode::SetUpdate, 0);
+            self.set_tail(0, true);
+            return;
+        }
         let key_start = self.chunk.instructions.len();
         self.expr();
         match self.peek() {
@@ -33,16 +49,8 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
                     self.comprehension_loop(&[key_ins, val_ins], OpCode::MapAdd, &versions_before);
                     self.eat(TokenType::Rbrace);
                 } else {
-                    let mut pairs = 1u16;
-                    while self.eat_if(TokenType::Comma) {
-                        if matches!(self.peek(), Some(TokenType::Rbrace)) { break; }
-                        self.expr();
-                        self.eat(TokenType::Colon);
-                        self.expr();
-                        pairs += 1;
-                    }
-                    self.eat(TokenType::Rbrace);
-                    self.chunk.emit(OpCode::BuildDict, pairs);
+                    // First pair already emitted; dict_tail consolidates if a later `**` appears.
+                    self.dict_tail(1, false);
                 }
             }
             Some(TokenType::For) => {
@@ -53,14 +61,8 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
                 self.eat(TokenType::Rbrace);
             }
             _ => {
-                let mut count = 1u16;
-                while self.eat_if(TokenType::Comma) {
-                    if matches!(self.peek(), Some(TokenType::Rbrace)) { break; }
-                    self.expr();
-                    count += 1;
-                }
-                self.eat(TokenType::Rbrace);
-                self.chunk.emit(OpCode::BuildSet, count);
+                // First element already emitted; set_tail consolidates if a later `*` appears.
+                self.set_tail(1, false);
             }
         }
     }
@@ -72,6 +74,14 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             self.chunk.emit(OpCode::BuildList, 0);
             return;
         }
+        // `[*it, ...]`: leading iterable-unpack => list built incrementally.
+        if self.eat_if(TokenType::Star) {
+            self.chunk.emit(OpCode::BuildList, 0);
+            self.expr();
+            self.chunk.emit(OpCode::ListExtend, 0);
+            self.list_tail(0, true);
+            return;
+        }
         let elem_start = self.chunk.instructions.len();
         self.expr();
         if matches!(self.peek(), Some(TokenType::For)) {
@@ -81,15 +91,62 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             self.comprehension_loop(&[elem_ins], OpCode::ListAppend, &versions_before);
             self.eat(TokenType::Rsqb);
         } else {
-            let mut count = 1u16;
-            while self.eat_if(TokenType::Comma) {
-                if matches!(self.peek(), Some(TokenType::Rsqb)) { break; }
+            // First element already emitted; list_tail consolidates if a later `*` appears.
+            self.list_tail(1, false);
+        }
+    }
+
+    /* Finishes a `{}` dict after the first pair. `pairs` = loose key/val pairs on the stack; `incremental` = a Dict object is already on the stack. On the first `**` the loose pairs are consolidated with `BuildDict pairs`, then merges use `DictUpdate`/`MapAdd`. */
+    fn dict_tail(&mut self, mut pairs: u16, mut incremental: bool) {
+        while self.eat_if(TokenType::Comma) {
+            if matches!(self.peek(), Some(TokenType::Rbrace)) { break; }
+            if self.eat_if(TokenType::DoubleStar) {
+                if !incremental { self.chunk.emit(OpCode::BuildDict, pairs); incremental = true; }
                 self.expr();
-                count += 1;
+                self.chunk.emit(OpCode::DictUpdate, 0);
+            } else {
+                self.expr();
+                self.eat(TokenType::Colon);
+                self.expr();
+                if incremental { self.chunk.emit(OpCode::MapAdd, 0); } else { pairs += 1; }
+            }
+        }
+        self.eat(TokenType::Rbrace);
+        if !incremental { self.chunk.emit(OpCode::BuildDict, pairs); }
+    }
+
+    /* Finishes a `{}` set after the first element; mirrors `dict_tail` with `SetUpdate`/`SetAdd` and `BuildSet`. */
+    fn set_tail(&mut self, mut count: u16, mut incremental: bool) {
+        while self.eat_if(TokenType::Comma) {
+            if matches!(self.peek(), Some(TokenType::Rbrace)) { break; }
+            if self.eat_if(TokenType::Star) {
+                if !incremental { self.chunk.emit(OpCode::BuildSet, count); incremental = true; }
+                self.expr();
+                self.chunk.emit(OpCode::SetUpdate, 0);
+            } else {
+                self.expr();
+                if incremental { self.chunk.emit(OpCode::SetAdd, 0); } else { count += 1; }
+            }
+        }
+        self.eat(TokenType::Rbrace);
+        if !incremental { self.chunk.emit(OpCode::BuildSet, count); }
+    }
+
+    /* Finishes a `[]` list after the first element; mirrors `dict_tail` with `ListExtend`/`ListAppend` and `BuildList`. */
+    fn list_tail(&mut self, mut count: u16, mut incremental: bool) {
+        while self.eat_if(TokenType::Comma) {
+            if matches!(self.peek(), Some(TokenType::Rsqb)) { break; }
+            if self.eat_if(TokenType::Star) {
+                if !incremental { self.chunk.emit(OpCode::BuildList, count); incremental = true; }
+                self.expr();
+                self.chunk.emit(OpCode::ListExtend, 0);
+            } else {
+                self.expr();
+                if incremental { self.chunk.emit(OpCode::ListAppend, 0); } else { count += 1; }
             }
-            self.eat(TokenType::Rsqb);
-            self.chunk.emit(OpCode::BuildList, count);
         }
+        self.eat(TokenType::Rsqb);
+        if !incremental { self.chunk.emit(OpCode::BuildList, count); }
     }
 
     /* Emits for/if comprehension scaffolding; reinjcts body with loop-bound SSA slots. */

compiler/src/modules/parser/mod.rs

@@ -339,6 +339,17 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         }
     }
 
+    /* Like `peek` but stops at the logical-line boundary: a `Newline` yields `None` (unconsumed) so postfix trailers don't bind across statements. `Nl`/`Comment` (bracket-internal) still skip, so multiline `()`/`[]`/`{}` are unaffected. */
+    pub(super) fn peek_same_line(&mut self) -> Option<TokenType> {
+        loop {
+            match self.tokens.peek().map(|t| t.kind) {
+                Some(TokenType::Nl | TokenType::Comment) => { self.tokens.next(); }
+                Some(TokenType::Newline) | Some(TokenType::Endmarker) | None => return None,
+                Some(k) => return Some(k),
+            }
+        }
+    }
+
     pub(super) fn patch(&mut self, pos: usize) {
         self.chunk.instructions[pos].operand = self.chunk.instructions.len() as u16;
     }

compiler/src/modules/parser/types.rs

@@ -30,6 +30,8 @@ pub enum OpCode {
     LoadModule,
     /* Read/write a `global`-declared name from/to `self.globals`; operand indexes the bare name in `chunk.names`. */
     LoadGlobal, StoreGlobal,
+    /* Literal unpacking: pop a source value and merge it into the container left below it on the stack. `{**m}` / `{*s}` / `[*it]`. */
+    DictUpdate, SetUpdate, ListExtend,
 }
 
 // Python builtin name -> (specialised OpCode, `leaves_value_on_stack`).

compiler/src/modules/vm/dispatch.rs

@@ -514,6 +514,7 @@ impl<'a> VM<'a> {
             OpCode::UnpackSequence | OpCode::UnpackEx | OpCode::FormatValue => self.handle_container(opcode, operand, chunk, slots)?,
 
             OpCode::ListAppend | OpCode::SetAdd | OpCode::MapAdd => self.handle_comprehension(opcode)?,
+            OpCode::DictUpdate | OpCode::SetUpdate | OpCode::ListExtend => self.handle_spread_merge(opcode)?,
 
             OpCode::Yield => self.handle_yield()?,
             OpCode::LoadEllipsis => {

compiler/src/modules/vm/handlers/data.rs

@@ -124,6 +124,46 @@ impl<'a> VM<'a> {
         Ok(())
     }
 
+    /* Merge the source on top of the stack into the container below it: `{**m}`, `{*s}`, `[*it]`. */
+    pub(crate) fn handle_spread_merge(&mut self, op: OpCode) -> Result<(), VmErr> {
+        let src = self.pop()?;
+        let acc = *self.stack.last().ok_or(VmErr::Runtime("stack underflow"))?;
+        if !acc.is_heap() { return Err(cold_runtime("spread accumulator corrupted")); }
+        match op {
+            OpCode::DictUpdate => {
+                // `**` requires a mapping; later keys overwrite earlier ones.
+                let pairs: Vec<(Val, Val)> = match self.heap.get(src) {
+                    HeapObj::Dict(rc) => rc.borrow().iter().collect(),
+                    _ => return Err(cold_type("argument after ** must be a mapping")),
+                };
+                if let HeapObj::Dict(rc) = self.heap.get(acc) {
+                    let mut m = rc.borrow_mut();
+                    for (k, v) in pairs { m.insert(k, v); }
+                }
+            }
+            OpCode::SetUpdate => {
+                let items = self.iter_to_vec_for_spread(src)?;
+                for it in items {
+                    self.require_hashable(it)?;
+                    let dup = match self.heap.get(acc) {
+                        HeapObj::Set(rc) => rc.borrow().iter().any(|&x| eq_vals_with_heap(x, it, &self.heap)),
+                        _ => return Err(cold_runtime("spread accumulator corrupted")),
+                    };
+                    if !dup && let HeapObj::Set(rc) = self.heap.get(acc) { rc.borrow_mut().insert(it); }
+                }
+            }
+            OpCode::ListExtend => {
+                let items = self.iter_to_vec_for_spread(src)?;
+                match self.heap.get(acc) {
+                    HeapObj::List(rc) => rc.borrow_mut().extend(items),
+                    _ => return Err(cold_runtime("spread accumulator corrupted")),
+                }
+            }
+            _ => return Err(cold_runtime("non-spread opcode in handle_spread_merge")),
+        }
+        Ok(())
+    }
+
     /* Yield: keep the value on the stack and flag the executor to suspend. */
     pub(crate) fn handle_yield(&mut self) -> Result<(), VmErr> {
         let v = self.pop()?;
@@ -180,7 +220,8 @@ impl<'a> VM<'a> {
                 let msg = match info {
                     Some((n, Some(arg))) => { let detail = self.display(arg); crate::s!(str &n, ": ", str &detail) }
                     Some((n, None)) => n,
-                    None => self.display(exc),
+                    // Non-exception value (str, int, ...): raises TypeError, catchable by `except Exception`.
+                    None => crate::s!("TypeError: exceptions must derive from BaseException"),
                 };
                 return Err(VmErr::Raised(msg));
             }

compiler/src/modules/vm/ops.rs

@@ -262,13 +262,34 @@ impl<'a> VM<'a> {
         if let Some((af, bf)) = coerce_floats(a, b) { return Ok(af < bf); }
         // Wide-int compare in i128; falls through when either side isn't int-like.
         if let (Some(ai), Some(bi)) = (as_i128(a, &self.heap), as_i128(b, &self.heap)) { return Ok(ai < bi); }
-        if a.is_heap() && b.is_heap()
-            && let (HeapObj::Str(x), HeapObj::Str(y)) = (self.heap.get(a), self.heap.get(b)) {
-                return Ok(x < y);
+        if a.is_heap() && b.is_heap() {
+            match (self.heap.get(a), self.heap.get(b)) {
+                (HeapObj::Str(x), HeapObj::Str(y)) => return Ok(x < y),
+                (HeapObj::Bytes(x), HeapObj::Bytes(y)) => return Ok(x < y),
+                // Sequences compare lexicographically; clone to drop the heap borrow before recursing.
+                (HeapObj::List(x), HeapObj::List(y)) => {
+                    let (x, y) = (x.borrow().clone(), y.borrow().clone());
+                    return self.seq_lt(&x, &y);
+                }
+                (HeapObj::Tuple(x), HeapObj::Tuple(y)) => {
+                    let (x, y) = (x.clone(), y.clone());
+                    return self.seq_lt(&x, &y);
+                }
+                _ => {}
+            }
         }
         Err(VmErr::TypeMsg(s!("'<' not supported between instances of '", str self.type_name(a), "' and '", str self.type_name(b), "'")))
     }
 
+    /* Lexicographic `<` for sequences: first differing element decides; otherwise the shorter is less. Recurses through `lt_vals`, so nested sequences and mixed element types are handled (and rejected) consistently. */
+    pub fn seq_lt(&self, xs: &[Val], ys: &[Val]) -> Result<bool, VmErr> {
+        for (&x, &y) in xs.iter().zip(ys.iter()) {
+            if eq_vals_with_heap(x, y, &self.heap) { continue; }
+            return self.lt_vals(x, y);
+        }
+        Ok(xs.len() < ys.len())
+    }
+
     /* Item presence in list/tuple/dict/set, or substring in string. */
     pub fn contains(&self, container: Val, item: Val) -> bool {
         if !container.is_heap() { return false; }

compiler/tests/cases/vm.json

@@ -1750,5 +1750,30 @@
   {"src": "async def child():\n    receive()\n    return receive()\ntry:\n    r = run(child())\n    print(f'ok:{r}')\nexcept Exception as e:\n    print(f'err:{e}')", "interactive_events": ["a", "b"], "output": ["ok:b"]},
   {"src": "def f():\n    return 'x'\nprint(f'val:{f()}')", "output": ["val:x"]},
   {"src": "print(f'got:{receive()}')", "events": ["hi"], "output": ["got:hi"]},
-  {"src": "async def child():\n    return 'x'\nprint(f'got:{run(child())}')", "output": ["got:x"]}
+  {"src": "async def child():\n    return 'x'\nprint(f'got:{run(child())}')", "output": ["got:x"]},
+  {"src": "print(len({**{1:1}, **{2:2}}))", "output": ["2"]},
+  {"src": "print({**{'a':1}, **{'a':9}})", "output": ["{'a': 9}"]},
+  {"src": "print({'x':1, **{'y':2}})", "output": ["{'x': 1, 'y': 2}"]},
+  {"src": "print({**{'a':1}, 'b':2})", "output": ["{'a': 1, 'b': 2}"]},
+  {"src": "d = {'a': 1}\nprint({**d, 'b': 2, **{'c': 3}})", "output": ["{'a': 1, 'b': 2, 'c': 3}"]},
+  {"src": "print([*[1, 2], 3, *[4, 5]])", "output": ["[1, 2, 3, 4, 5]"]},
+  {"src": "print([*[1, 2], 3])", "output": ["[1, 2, 3]"]},
+  {"src": "print([0, *range(3)])", "output": ["[0, 0, 1, 2]"]},
+  {"src": "print(len({*[1, 2], *[2, 3]}))", "output": ["3"]},
+  {"src": "print(sorted({*[3, 1], *[1, 2]}))", "output": ["[1, 2, 3]"]},
+  {"src": "try:\n    raise 'soy un string'\nexcept Exception as e:\n    print(type(e).__name__)", "output": ["TypeError"]},
+  {"src": "try:\n    raise 42\nexcept Exception as e:\n    print('caught', type(e).__name__)", "output": ["caught TypeError"]},
+  {"src": "try:\n    raise 'x'\nexcept TypeError:\n    print('ok')", "output": ["ok"]},
+  {"src": "x = [1, 2, 3]\n[print(i) for i in range(2)]", "output": ["0", "1"]},
+  {"src": "xs = []\n[xs.append(i) for i in range(3)]\nprint(xs)", "output": ["[0, 1, 2]"]},
+  {"src": "d = {'a': 1}\n[print(d[k]) for k in d]", "output": ["1"]},
+  {"src": "n = 5\n[0, 1, 2]\nprint(n)", "output": ["5"]},
+  {"src": "x = (\n    1 + 2 +\n    3\n)\nprint(x)", "output": ["6"]},
+  {"src": "x = [\n    1,\n    2,\n]\nprint(x)", "output": ["[1, 2]"]},
+  {"src": "[print(x) for x in range(2)]\nd = {}\n[d.update({x: x}) for x in range(2)]\nprint(d[0], d[1])\nxs = []\n[xs.append(x) for x in range(2)]\nprint(xs)", "output": ["0", "1", "0 1", "[0, 1]"]},
+  {"src": "print(sorted([(1, 2), (1, 1), (0, 9)]))", "output": ["[(0, 9), (1, 1), (1, 2)]"]},
+  {"src": "print([3, 1] < [3, 2])", "output": ["True"]},
+  {"src": "print((1, 2, 3) < (1, 2))", "output": ["False"]},
+  {"src": "print(b'abc' < b'abd')", "output": ["True"]},
+  {"src": "print(sorted([[2], [1], [1, 0]]))", "output": ["[[1], [1, 0], [2]]"]}
 ]

docs/pages/language/data-types.md

@@ -317,6 +317,25 @@ set()
 True
 ```
 
+## Unpacking in literals
+
+`*` spreads an iterable into a list/set literal; `**` spreads a mapping into a dict literal. Mix freely with regular elements; for dicts, later keys win.
+
+```python
+xs = [1, 2]
+print([*xs, 3, *xs]) # list spread
+print({*xs, 2, 3})   # set spread (deduped)
+
+a = {"x": 1}
+print({**a, "y": 2, **{"x": 9}}) # dict spread, later key wins
+```
+
+```text Output
+[1, 2, 3, 1, 2]
+{1, 2, 3}
+{'x': 9, 'y': 2}
+```
+
 ## Range
 
 Lazy integer sequence. `range(stop)`, `range(start, stop)`, `range(start, stop, step)`.

docs/pages/language/syntax.md

@@ -203,16 +203,20 @@ print(-5, +5)
 
 ### Comparison and chaining
 
+Ordering comparisons (`<`, `>`, `<=`, `>=`) work on numbers, strings, bytes, and tuples/lists (compared lexicographically); mixing un-orderable types raises `TypeError`.
+
 ```python
 print(1 < 2 < 3) # chained
 print(0 < 5 < 10)
 print(1 == 1 == 1)
+print([1, 2] < [1, 3]) # lexicographic
 ```
 
 ```text Output
 True
 True
 True
+True
 ```
 
 ### Logical