Phase 1 ergonomics: string +, dicts, try/catch

Three Python-grade ergonomic gaps closed in one push.

* String + concat. `"count: " + 42` now produces "count: 42" instead
  of returning 0 via int coercion. Added Value::to_display_string()
  for bare-number stringification (concat_many's existing logic
  centralized into one helper); both tree-walk Expression::Add and
  VM arith_add use it when either operand is a string.

* Dictionaries / hash maps. New Value::Dict variant backed by
  BTreeMap<String, Value> (sorted-key iteration; deterministic for
  tests). Literal syntax `{"k": v, ...}`. Indexing via `d["key"]`
  routes through the same Op::ArrayIndex now made polymorphic
  (dispatches on container type). Nine builtins: dict_new / dict_get
  / dict_set / dict_has / dict_del / dict_keys / dict_values /
  dict_len / dict_merge. dict_get takes an optional default arg.
  VM gets dedicated Op::DictSetNamed / Op::DictDelNamed for
  mutating operations — same name-on-opcode pattern as
  Op::ArrPushNamed solves the synthetic-arg-shim mutation loss.

* try/catch error handling. `try { ... } catch err { ... }`. The
  caught value is a Value::String holding the error message;
  builtin failures and the new `error("msg")` builtin both raise.
  VM compiles Statement::Try to Op::ExecStmt — a tree-walk fallback
  that runs the AST node via the embedded Interpreter. Pragmatic
  choice: full exception unwind would require either a side
  try-stack or a Result-aware op dispatch loop refactor; this
  costs only a tree-walk per try block, which is rare in hot paths.
  Critical detail: after Op::ExecStmt the VM drains
  interp.return_value via a new vm_take_return helper, so a
  `return` inside a try body correctly bubbles out of the
  surrounding VM-compiled function.

40/40 functional examples produce byte-identical output under
tree-walk and VM. 92/92 unit tests pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

omnimcode-core/src/ast.rs

@@ -52,6 +52,16 @@ pub enum Statement {
         module: String,
         alias: Option<String>,
     },
+    /// `try { ... } catch err { ... }`. If the try block raises an
+    /// error (via `error("msg")` or any builtin failure), execution
+    /// jumps to the catch block with `err_var` bound to a Value::String
+    /// holding the error message. Without try/catch, builtin failures
+    /// crash the program.
+    Try {
+        body: Vec<Statement>,
+        err_var: String,
+        handler: Vec<Statement>,
+    },
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -68,6 +78,11 @@ pub enum Expression {
     String(String),
     Boolean(bool),
     Array(Vec<Expression>),
+    /// Dict literal: `{"k1": v1, "k2": v2}`. Keys are string-typed
+    /// expressions (must evaluate to strings); values are arbitrary.
+    /// Stored as a Vec<(key_expr, value_expr)> so the compiler can
+    /// emit them in source order.
+    Dict(Vec<(Expression, Expression)>),
 
     // Variables and access
     Variable(String),

omnimcode-core/src/bytecode.rs

@@ -98,7 +98,29 @@ pub enum Op {
 
     // Arrays
     NewArray(usize),       // pop N items into a new array, push
-    ArrayIndex,            // pop index, pop array, push array[index]
+    /// Pop 2N values (alternating key, value) off the stack and
+    /// build a Dict. Keys are stringified via to_display_string at
+    /// build time. Order matches source-order pairs in the literal.
+    NewDict(usize),
+    /// Mutating dict insert: pop value, pop key, store at named dict
+    /// variable in the current scope. Same name-on-opcode trick as
+    /// ArrSetNamed — required so the mutation propagates back through
+    /// the VM scope chain instead of getting lost in vm_call_builtin's
+    /// synthetic-arg shim. Emitted by the compiler when it sees
+    /// `dict_set(VAR, k, v)` with a literal Variable as the first arg.
+    DictSetNamed(String),
+    /// Mutating dict delete: pop key, remove from named dict variable.
+    /// Same rationale as DictSetNamed.
+    DictDelNamed(String),
+    /// Tree-walk fallback: execute an AST statement via the embedded
+    /// Interpreter rather than as bytecode. Used for forms whose
+    /// control flow doesn't map cleanly onto the stack VM (currently
+    /// just Statement::Try — exception unwind would require either
+    /// a side try-stack or a full Result-aware op dispatch refactor;
+    /// the fallback keeps the VM dispatch loop simple and pays a
+    /// per-try-block tree-walk cost only).
+    ExecStmt(Box<crate::ast::Statement>),
+    ArrayIndex,            // pop index, pop container; container dispatch (Array → idx int, Dict → idx str)
     ArrayIndexAssign(String), // pop value, pop index, assign array_var[idx] = value
     /// Mutating array push: pop one value off the stack and append it
     /// to the named array variable in the current scope. Emitted by the

omnimcode-core/src/compiler.rs

@@ -87,6 +87,7 @@ impl Compiler {
             Expression::String(_) => Some("string"),
             Expression::Boolean(_) => Some("bool"),
             Expression::Array(_) => Some("array"),
+            Expression::Dict(_) => Some("dict"),
             Expression::Variable(name) => self.var_types.get(name.as_str()).copied(),
             Expression::Add(l, r)
             | Expression::Sub(l, r)
@@ -255,6 +256,13 @@ impl Compiler {
                 }
                 self.emit(Op::NewArray(items.len()));
             }
+            Expression::Dict(pairs) => {
+                for (k, v) in pairs {
+                    self.compile_expr(k)?;
+                    self.compile_expr(v)?;
+                }
+                self.emit(Op::NewDict(pairs.len()));
+            }
             Expression::Add(l, r) => {
                 let lt = self.infer_type(l);
                 let rt = self.infer_type(r);
@@ -412,6 +420,28 @@ impl Compiler {
                             return Ok(());
                         }
                     }
+                    if name == "dict_set" && args.len() == 3 {
+                        if let Expression::Variable(d_name) = &args[0] {
+                            // key then value → stack top is value, beneath it is key
+                            self.compile_expr(&args[1])?; // key
+                            self.compile_expr(&args[2])?; // value
+                            self.emit(Op::DictSetNamed(d_name.clone()));
+                            // dict_set returns Null in tree-walk; mirror that
+                            // so the stack stays balanced for the caller.
+                            let null_idx = self.add_const(Const::Null);
+                            self.emit(Op::LoadConst(null_idx));
+                            return Ok(());
+                        }
+                    }
+                    if name == "dict_del" && args.len() == 2 {
+                        if let Expression::Variable(d_name) = &args[0] {
+                            self.compile_expr(&args[1])?; // key
+                            self.emit(Op::DictDelNamed(d_name.clone()));
+                            let null_idx = self.add_const(Const::Null);
+                            self.emit(Op::LoadConst(null_idx));
+                            return Ok(());
+                        }
+                    }
                 }
                 // Fast-path inline for hot harmonic ops — avoids the Call -> bridge
                 // -> stdlib lookup overhead. Only inline when the user HASN'T
@@ -829,6 +859,13 @@ impl Compiler {
             Statement::FunctionDef { .. } => {
                 // Function defs hoisted by compile_program(); skip here.
             }
+            Statement::Try { .. } => {
+                // Tree-walk fallback. See Op::ExecStmt comments — full
+                // exception unwind would require a side try-stack and
+                // a Result-aware op dispatch loop. Until that pays for
+                // itself, fall back to the AST walker for try/catch.
+                self.emit(Op::ExecStmt(Box::new(s.clone())));
+            }
         }
         Ok(())
     }

omnimcode-core/src/disasm.rs

@@ -71,6 +71,10 @@ fn op_mnemonic(op: &Op, ip: usize, constants: &[Const]) -> String {
         Op::ReturnNull => "RETURN_NULL".to_string(),
 
         Op::NewArray(n) => format!("NEW_ARRAY    {}", n),
+        Op::NewDict(n) => format!("NEW_DICT     {}", n),
+        Op::DictSetNamed(name) => format!("DICT_SET_NAMED  {}", name),
+        Op::DictDelNamed(name) => format!("DICT_DEL_NAMED  {}", name),
+        Op::ExecStmt(_) => "EXEC_STMT       <ast>".to_string(),
         Op::ArrayIndex => "ARRAY_INDEX".to_string(),
         Op::ArrayIndexAssign(name) => format!("ARRAY_INDEX_ASSIGN {}", name),
         Op::ArrPushNamed(name) => format!("ARR_PUSH_NAMED  {}", name),

omnimcode-core/src/formatter.rs

@@ -170,6 +170,17 @@ fn format_stmt(stmt: &Statement, level: usize, out: &mut String) {
             }
             out.push_str(";\n");
         }
+        Statement::Try { body, err_var, handler } => {
+            out.push_str("try {\n");
+            for s in body { format_stmt(s, level + 1, out); }
+            indent_to(level, out);
+            out.push_str("} catch ");
+            out.push_str(err_var);
+            out.push_str(" {\n");
+            for s in handler { format_stmt(s, level + 1, out); }
+            indent_to(level, out);
+            out.push_str("}\n");
+        }
     }
 }
 
@@ -216,6 +227,16 @@ fn format_expr(expr: &Expression, out: &mut String) {
             }
             out.push(']');
         }
+        Expression::Dict(pairs) => {
+            out.push('{');
+            for (i, (k, v)) in pairs.iter().enumerate() {
+                if i > 0 { out.push_str(", "); }
+                format_expr(k, out);
+                out.push_str(": ");
+                format_expr(v, out);
+            }
+            out.push('}');
+        }
         Expression::Add(l, r) => format_binop(l, "+", r, out),
         Expression::Sub(l, r) => format_binop(l, "-", r, out),
         Expression::Mul(l, r) => format_binop(l, "*", r, out),