feat: add f-string support infrastructure in ZynML grammar

- Add fold_concat() helper function in grammar interpreter to desugar
  f-strings into nested concat(a, b) calls instead of multi-arg concat
- Add to_string mapping to $IO$format_dynamic for type conversion
- Add signature for $IO$string_concat in zrtl_io plugin
- Update f-string grammar rules to use fold_concat(parts)

Note: F-strings are not yet fully functional due to prelude bool
return type issue (is_some/is_none returning i32 instead of i8)
that causes function compilation to be skipped.

Author: darmie

crates/zyn_peg/src/runtime2/interpreter.rs

@@ -1798,6 +1798,73 @@ impl<'g> GrammarInterpreter<'g> {
 
                 Ok(acc)
             }
+            "fold_concat" => {
+                // fold_concat(parts) - fold string parts into nested concat calls
+                // e.g., fold_concat(["a", "b", "c"]) -> concat(concat("a", "b"), "c")
+                // Used by f-string desugaring
+                if args.len() != 1 {
+                    return Err("fold_concat() requires exactly 1 argument (parts list)".to_string());
+                }
+                let parts = self.eval_expr(&args[0], state)?;
+
+                // Get the parts as a list
+                let parts_list = match parts {
+                    ParsedValue::List(items) => items,
+                    ParsedValue::Optional(None) | ParsedValue::None => vec![],
+                    ParsedValue::Optional(Some(inner)) => {
+                        match *inner {
+                            ParsedValue::List(items) => items,
+                            other => vec![other],
+                        }
+                    }
+                    other => vec![other],
+                };
+
+                // Handle edge cases
+                if parts_list.is_empty() {
+                    // Return empty string
+                    return Ok(ParsedValue::Expression(Box::new(typed_node(
+                        TypedExpression::Literal(zyntax_typed_ast::TypedLiteral::String(
+                            state.intern(""),
+                        )),
+                        Type::Primitive(zyntax_typed_ast::PrimitiveType::String),
+                        span,
+                    ))));
+                }
+
+                if parts_list.len() == 1 {
+                    // Just return the single part as an expression
+                    return self.parsed_value_to_expr(parts_list.into_iter().next().unwrap(), state)
+                        .map(|e| ParsedValue::Expression(Box::new(e)));
+                }
+
+                // Fold left: concat(concat(a, b), c)
+                let concat_name = state.intern("concat");
+                let mut iter = parts_list.into_iter();
+                let first = iter.next().unwrap();
+                let mut acc = self.parsed_value_to_expr(first, state)?;
+
+                for part in iter {
+                    let part_expr = self.parsed_value_to_expr(part, state)?;
+                    // Create concat(acc, part)
+                    acc = typed_node(
+                        TypedExpression::Call(TypedCall {
+                            callee: Box::new(typed_node(
+                                TypedExpression::Variable(concat_name),
+                                Type::Unknown,
+                                span,
+                            )),
+                            positional_args: vec![acc, part_expr],
+                            named_args: vec![],
+                            type_args: vec![],
+                        }),
+                        Type::Primitive(zyntax_typed_ast::PrimitiveType::String),
+                        span,
+                    );
+                }
+
+                Ok(ParsedValue::Expression(Box::new(acc)))
+            }
             _ => Err(format!("unknown helper function: {}", function)),
         }
     }

crates/zynml/examples/test_concat_direct.zynml

@@ -0,0 +1,9 @@
+// Test direct concat call
+import prelude
+
+def main() {
+    let a = "Hello"
+    let b = " World"
+    let c = extern concat(a, b)
+    println(c)
+}

crates/zynml/examples/test_concat_minimal.zynml

@@ -0,0 +1,7 @@
+// Minimal concat test without prelude
+def main() {
+    let a = "Hello"
+    let b = " World"
+    let c = extern concat(a, b)
+    extern println_str(c)
+}

crates/zynml/examples/test_concat_simple.zynml

@@ -0,0 +1,9 @@
+// Test basic string concat
+import prelude
+
+def main() {
+    let a = "Hello"
+    let b = " World"
+    let c = extern string_concat(a, b)
+    println(c)
+}

crates/zynml/examples/test_fstring.zynml

@@ -0,0 +1,14 @@
+// Test f-string functionality
+import prelude
+
+def main() {
+    let name = "World"
+    println(f"Hello {name}!")
+
+    let x = 42
+    println(f"The answer is {x}")
+
+    let a = 10
+    let b = 20
+    println(f"a={a}, b={b}, sum={a}")
+}

crates/zynml/ml.zyn

@@ -217,9 +217,10 @@
     println_array_f64: "$IO$println_array_f64",
 
     // String operations
-    concat: "$IO$string_concat",         // Used by f-string desugaring
+    concat: "$IO$string_concat",         // Used by f-string desugaring (binary concat)
     string_concat: "$IO$string_concat",
     string_free: "$IO$string_free",
+    to_string: "$IO$format_dynamic",     // Used by f-string desugaring for interpolations
 
     // === File Operations (zrtl_fs) ===
     file_read: "$FS$read_string",
@@ -2683,24 +2684,18 @@ duration_unit = { "ms" | "s" | "m" | "h" | "d" }
 //   """
 //
 // Format specifiers (after colon) are supported:
-// F-strings desugar to concat(parts...) where each interpolation is wrapped in to_string()
-// Example: f"Hello {name}!" -> concat("Hello ", to_string(name), "!")
+// F-strings desugar to nested concat(a, b) calls where each interpolation is wrapped in to_string()
+// Example: f"Hello {name}!" -> concat(concat("Hello ", to_string(name)), "!")
 //
 f_string_literal = { f_string_triple | f_string_regular }
 
 // f"""multiline {expr} string"""
 f_string_triple = { "f\"\"\"" ~ parts:f_string_part* ~ "\"\"\"" }
-  -> TypedExpression::Call {
-      callee: TypedExpression::Variable { name: intern("concat") },
-      args: parts,
-  }
+  -> fold_concat(parts)
 
 // f"single line {expr} string"
 f_string_regular = { "f\"" ~ parts:f_string_part* ~ "\"" }
-  -> TypedExpression::Call {
-      callee: TypedExpression::Variable { name: intern("concat") },
-      args: parts,
-  }
+  -> fold_concat(parts)
 
 // Parts of an f-string: either text or interpolated expression
 f_string_part = { f_string_interp | f_string_text }

plugins/zrtl_io/src/lib.rs

@@ -918,7 +918,7 @@ zrtl_plugin! {
         ("$IO$println_array_f64", io_println_array_f64),
 
         // String operations
-        ("$IO$string_concat", io_string_concat),
+        ("$IO$string_concat", io_string_concat, (i64, i64) -> i64),
     ]
 }