f-strings: f\"x={n}\" interpolation as parser sugar over concat_many

Second piece of the Python-ergonomics catch-up. Adds the f-string
syntax that Python users reach for first when formatting output.

Lexer:
- FStringPart enum with Literal(String) / Expr(String) variants
- Token::FString(Vec<FStringPart>) carries the lexed template
- read_fstring() handles brace-balanced expression segments + the
  Python-compatible `{{` / `}}` escapes for literal braces
- Lexer dispatch triggers on `f\"` or `f'` (also `F\"`/`F'`); bare `f`
  identifiers parse normally

Parser:
- Token::FString in primary-expression position re-parses each Expr
  segment via a sub-Parser (Parser::new + parse_expression) and
  emits Expression::Call { name: \"concat_many\", args }
- Literal segments become Expression::String; expression segments
  become whatever sub-parsing produces (Number, Call, Add, etc.)
- concat_many already handles mixed int/float/string args via
  to_string internally — f\"x={n}\" works for any value type
  without an explicit to_string call

Tests (examples/tests/test_fstrings.omc — 10 tests, all pass):
  - Simple int / float / string interpolation
  - Multiple {} segments in one string
  - Arithmetic inside braces
  - Function call inside braces (abs(), nth_fibonacci())
  - {{ and }} escapes for literal braces
  - No-interp f-string equivalent to regular string
  - Empty f-string returns empty string

What f-strings DON'T yet support (Python parity work):
- Format-spec syntax: f\"{x:.2f}\", f\"{n:>10}\". OMC has explicit
  formatters (str_pad_left, str_pad_right, etc.) that callers can use
  inside braces — f\"{str_pad_left(to_string(n), 10, \\\"0\\\")}\" works
  today and is composable. Format-spec sugar can come later as
  another parser-side translation.
- Multi-line f-strings via \"\"\"...\"\"\". Triple-quoted strings exist;
  f-prefix on them isn't wired through the lexer yet.
- Self-documenting expressions: f\"{n=}\" (Python 3.8+). Easy
  parser-level rewrite if/when users ask for it.

Regression: 8 exception tests + 57 substrate + 70 builtins + 18
harmonic libs + 16 heal + 10 new f-string = 179 OMC tests, all pass.

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

Author: RandomCoder-lab

examples/tests/test_fstrings.omc

@@ -0,0 +1,59 @@
+# Tests for f-string interpolation. `f"..."` syntax is sugar for
+# `concat_many(literal_segments, to_string_calls...)`.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn test_simple_interp() {
+    h x = 42;
+    assert_eq(f"x={x}", "x=42", "simple int interpolation");
+}
+
+fn test_multiple_segments() {
+    h a = 1;
+    h b = 2;
+    assert_eq(f"{a}+{b}={a+b}", "1+2=3", "expression interpolation");
+}
+
+fn test_no_interp() {
+    # An f-string with NO {expr} segments is equivalent to a regular string.
+    assert_eq(f"hello", "hello", "no-interp f-string == regular string");
+}
+
+fn test_empty_fstring() {
+    assert_eq(f"", "", "empty f-string is empty");
+}
+
+fn test_string_interp() {
+    h name = "world";
+    assert_eq(f"hello {name}", "hello world", "string interpolation");
+}
+
+fn test_float_interp() {
+    h pi = 3.14;
+    assert_eq(f"pi={pi}", "pi=3.14", "float interpolation");
+}
+
+fn test_arithmetic_in_braces() {
+    h n = 5;
+    assert_eq(f"{n*2+1}", "11", "arithmetic inside braces");
+}
+
+fn test_brace_escape() {
+    # `{{` and `}}` are escape sequences for literal `{` and `}`.
+    assert_eq(f"left{{right}}", "left{right}", "{{ and }} escape");
+}
+
+fn test_nested_function_call() {
+    h n = 100;
+    assert_eq(f"abs={abs(0 - n)}", "abs=100", "function call inside braces");
+}
+
+fn test_substrate_primitive_in_braces() {
+    # f-strings compose with the substrate. nth_fibonacci is JIT-eligible;
+    # the f-string just calls to_string on the result.
+    assert_eq(f"fib(11)={nth_fibonacci(11)}", "fib(11)=89", "substrate primitive in f-string");
+}

omnimcode-core/src/parser.rs

@@ -3,6 +3,16 @@
 use crate::ast::*;
 use std::collections::VecDeque;
 
+/// One segment of an f-string body. `f"x={n+1} done"` lexes as
+/// `[Literal("x="), Expr("n+1"), Literal(" done")]`. The parser
+/// re-parses each Expr segment via a sub-Parser to produce a real
+/// Expression AST and stitches the parts together via `concat_many`.
+#[derive(Clone, Debug, PartialEq)]
+pub enum FStringPart {
+    Literal(String),
+    Expr(String),
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum Token {
     // Keywords
@@ -31,6 +41,10 @@ pub enum Token {
     Finally,
     Throw,
     Match,
+    /// f-string template — alternating literal and expression segments.
+    /// Parser turns this into `concat_many(parts...)` at expression
+    /// position.
+    FString(Vec<FStringPart>),
     /// `..` for inclusive ranges in match patterns: `0..9`, `"a".."z"`.
     /// Lexed when not part of `..=` (which we don't use yet) or `...`.
     DotDot,
@@ -220,6 +234,87 @@ impl Lexer {
         result
     }
 
+    /// Read an f-string body — `f"x={n}"` syntax. Splits the body into
+    /// alternating literal and expression segments at `{...}` markers.
+    /// The expression segments are stored as raw source strings; the
+    /// parser later re-parses each via a sub-parser into a real
+    /// Expression AST. `{{` and `}}` are escape sequences for literal
+    /// `{` and `}` (Python-compatible).
+    fn read_fstring(&mut self, quote: char) -> Vec<FStringPart> {
+        let mut parts: Vec<FStringPart> = Vec::new();
+        let mut cur_lit = String::new();
+        self.advance(); // skip opening quote
+        while let Some(c) = self.current() {
+            if c == quote {
+                self.advance();
+                break;
+            }
+            if c == '{' {
+                // `{{` -> literal `{`
+                if self.peek(1) == Some('{') {
+                    cur_lit.push('{');
+                    self.advance(); self.advance();
+                    continue;
+                }
+                // Flush current literal segment.
+                if !cur_lit.is_empty() {
+                    parts.push(FStringPart::Literal(std::mem::take(&mut cur_lit)));
+                }
+                self.advance(); // consume `{`
+                let mut depth: i32 = 1;
+                let mut expr_src = String::new();
+                while let Some(ec) = self.current() {
+                    if ec == '{' { depth += 1; expr_src.push(ec); self.advance(); continue; }
+                    if ec == '}' {
+                        depth -= 1;
+                        if depth == 0 { self.advance(); break; }
+                        expr_src.push(ec);
+                        self.advance();
+                        continue;
+                    }
+                    expr_src.push(ec);
+                    self.advance();
+                }
+                parts.push(FStringPart::Expr(expr_src.trim().to_string()));
+                continue;
+            }
+            if c == '}' {
+                // `}}` -> literal `}`
+                if self.peek(1) == Some('}') {
+                    cur_lit.push('}');
+                    self.advance(); self.advance();
+                    continue;
+                }
+                // Bare `}` is an error in Python f-strings, but we
+                // accept it as a literal for ergonomics.
+                cur_lit.push('}');
+                self.advance();
+                continue;
+            }
+            if c == '\\' {
+                self.advance();
+                match self.current() {
+                    Some('n') => cur_lit.push('\n'),
+                    Some('t') => cur_lit.push('\t'),
+                    Some('r') => cur_lit.push('\r'),
+                    Some('\\') => cur_lit.push('\\'),
+                    Some('"') => cur_lit.push('"'),
+                    Some('\'') => cur_lit.push('\''),
+                    Some(c) => cur_lit.push(c),
+                    None => break,
+                }
+                self.advance();
+            } else {
+                cur_lit.push(c);
+                self.advance();
+            }
+        }
+        if !cur_lit.is_empty() {
+            parts.push(FStringPart::Literal(cur_lit));
+        }
+        parts
+    }
+
     fn read_number(&mut self) -> Token {
         let mut num_str = String::new();
         let mut is_float = false;
@@ -342,6 +437,15 @@ impl Lexer {
                 }
                 Some('\'') => return Token::String(self.read_string('\'')),
                 Some(c) if c.is_ascii_digit() => return self.read_number(),
+                // f-string prefix: `f"..."` or `f'...'` (also `F"..."`).
+                // Triggered ONLY when `f` is directly followed by a
+                // quote — a bare `f` identifier still parses normally.
+                Some(c) if (c == 'f' || c == 'F')
+                    && matches!(self.peek(1), Some('"') | Some('\'')) => {
+                    self.advance(); // consume `f`
+                    let quote = self.current().unwrap();
+                    return Token::FString(self.read_fstring(quote));
+                }
                 Some(c) if c.is_alphabetic() || c == '_' => {
                     let ident = self.read_ident();
                     return match ident.as_str() {
@@ -1536,6 +1640,35 @@ impl Parser {
                 self.advance();
                 Ok(Expression::String(val))
             }
+            Token::FString(parts) => {
+                let parts_copy = parts.clone();
+                self.advance();
+                // Turn the f-string into `concat_many(seg0, seg1, ...)`
+                // where literal segments are Expression::String and
+                // expression segments are re-parsed via a sub-Parser.
+                // concat_many tolerates int/float args by calling
+                // to_string internally — so `f"x={n}"` works for any
+                // value type without an explicit to_string call.
+                let mut args: Vec<Expression> = Vec::new();
+                for part in parts_copy {
+                    match part {
+                        FStringPart::Literal(s) => args.push(Expression::String(s)),
+                        FStringPart::Expr(src) => {
+                            let mut sub = Parser::new(&src);
+                            let expr = sub.parse_expression()
+                                .map_err(|e| format!("f-string expr `{}`: {}", src, e))?;
+                            args.push(expr);
+                        }
+                    }
+                }
+                // Empty f-string `f""` produces "".
+                if args.is_empty() { return Ok(Expression::String(String::new())); }
+                Ok(Expression::Call {
+                    name: "concat_many".to_string(),
+                    args,
+                    pos: crate::ast::Pos::unknown(),
+                })
+            }
             Token::LBracket => self.parse_array(),
             Token::LBrace => self.parse_dict(),
             Token::LParen => {