gelang 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -4,6 +4,59 @@ All notable changes to GE. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.4] — 2026-09-13
+
+Found by `scripts/e2e.py`, a new harness that compiles and runs 118
+programs on every installed backend and compares stdout with CPython.
+
+### Fixed
+
+- **Wrong output.** `print(True)` printed lowercase `true` on Rust, C++,
+  Go, Zig and Kotlin; list printing used each target's native format
+  (`[1 2 3]` in Go, `{ 1, 2, 3 }` in Zig). Both now match Python.
+- **Dict iteration** walked `(key, value)` pairs instead of keys, so
+  `for k in d: d[k]` failed to compile on every backend.
+- **List slicing** was marked unsupported, which dropped the whole
+  function and surfaced as the misleading `main function not found`.
+  `xs[a:b]`, `xs[a:]`, `xs[:b]` and `xs[:]` are implemented everywhere.
+- **`str.split` / `str.join`** had no implementation at all.
+- **`str.replace`** had no implementation at all.
+- **`min(a, b)` / `max(a, b)`** emitted a bare call no target provides.
+- **`abs()`** on a literal was ambiguous in Rust, untyped in Zig, and
+  absent for `int64` in Go.
+- **Default arguments** were rejected outright. A call may now supply
+  between `n_required` and `len(params)` arguments.
+- **`set` annotations** became `f64`, because `set` was missing from the
+  native type mapping. Added `set_type` per backend.
+- **Lists of strings** could not be expressed: only Rust and C++ had a
+  `{T}` placeholder in `list_type`.
+- **C++ `std::sqrt`** appeared before `#include <cmath>`.
+- **Kotlin** used `Math.pow` (no such class in Kotlin/Native) and a
+  C-style ternary (Kotlin has no `?:`).
+- **C++ `upper()` / `lower()`** emitted a bare comment, so the program
+  compiled but did nothing.
+- **Rust string concatenation** moved the left operand.
+- **Emitter crashes**: when the entry function was rejected, zig, go,
+  kotlin and csharp raised `IndexError` instead of reporting the reason.
+- **`ge tools check`** disagreed with `ge doctor` because `CompilerInfo`
+  field names (`dotnet`, `kotlinc`) differ from the public toolchain
+  names.
+- **Zig** emitted a raw newline inside a string literal, and
+  `_mark_unsupported` produced a C-style comment, which Zig rejects.
+
+### Added
+
+- `scripts/e2e.py` — end-to-end tests against real toolchains.
+- `ge doctor` — runtime and toolchain check with install hints.
+
+### Known limitations
+
+- Zig models lists as fixed slices, so `list.append` is rejected with a
+  clear diagnostic rather than compiling. Switching the backend to
+  `std.ArrayList` needs an allocator threaded through every signature.
+- Tuples are supported at arity 2; other arities are rejected with a
+  diagnostic instead of emitting broken code.
+
 ## [Unreleased]
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gelang",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "One typed source language, compiled to Rust, C++, C#, Zig, Go, or Kotlin — chosen per function. Generates Flutter and React UIs from one DSL.",
   "keywords": [
     "ge",

package/python/pyeffic/analyzer.py

@@ -38,6 +38,11 @@ class FuncUnit:
     param_elem_types: dict[str, str] = field(default_factory=dict)
     # dict key/value types: {"d": ("str", "int")} means d is dict[str, int]
     param_dict_types: dict[str, tuple[str, str]] = field(default_factory=dict)
+    # Number of leading parameters without a default. Calls may
+    # supply between n_required_params and len(params) arguments.
+    n_required_params: int = 0
+    # Default expressions per parameter name, as source text.
+    param_defaults: dict[str, str] = field(default_factory=dict)
 
     def mark_unsupported(self, reason: str) -> None:
         self.supported = False
@@ -310,6 +315,19 @@ def parse_source_full(source: str) -> tuple[list[FuncUnit], list[ClassUnit]]:
             ret = _norm_type(node.returns)
             if ret not in SCALAR_TYPES and ret not in CONTAINER_TYPES and ret != "None" and ret not in _class_names:
                 ret = "any"
+            # Default arguments: a call may supply between n_required and
+            # len(params) arguments; the rest are filled in at the call site.
+            _args = node.args.args
+            _n_defaults = len(node.args.defaults)
+            _n_required = len(_args) - _n_defaults
+            _param_defaults: dict[str, str] = {}
+            for _i, _a in enumerate(_args):
+                if _i >= _n_required:
+                    _d = node.args.defaults[_i - _n_required]
+                    try:
+                        _param_defaults[_a.arg] = ast.unparse(_d)
+                    except Exception:
+                        _param_defaults[_a.arg] = ""
             unit = FuncUnit(
                 name=node.name,
                 lineno=node.lineno,
@@ -319,6 +337,8 @@ def parse_source_full(source: str) -> tuple[list[FuncUnit], list[ClassUnit]]:
                 source="\n".join(src_lines[node.lineno - 1 : node.end_lineno]),
                 param_elem_types=param_elem_types,
                 param_dict_types=param_dict_types,
+                n_required_params=_n_required,
+                param_defaults=_param_defaults,
             )
             # parse @rust/@cpp/@dart/@csharp/@zig/@go decorators for per-function backend selection
             for dec in node.decorator_list:

package/python/pyeffic/downloader.py

@@ -293,10 +293,22 @@ def get_tools_status() -> dict[str, dict]:
     """Get status of all known toolchains."""
     from .config import detect_compilers
     detected = detect_compilers()
+    # CompilerInfo field names differ from the public toolchain names
+    # (`dotnet` backs C#, `kotlinc` backs Kotlin), so map them explicitly.
+    fields = {
+        "rust": "rustc",
+        "cpp": "cpp",
+        "csharp": "dotnet",
+        "zig": "zig",
+        "go": "go",
+        "kotlin": "kotlinc",
+        "dart": "dart",
+    }
     status = {}
     for name in ["rust", "cpp", "csharp", "zig", "go", "kotlin", "dart"]:
-        available = is_toolchain_available(name) or getattr(detected, name, None) is not None
-        path = get_toolchain_path(name) or getattr(detected, name, None)
+        detected_path = getattr(detected, fields.get(name, name), None)
+        available = is_toolchain_available(name) or detected_path is not None
+        path = get_toolchain_path(name) or detected_path
         downloadable = name in DOWNLOAD_URLS
         status[name] = {
             "available": bool(available),

package/python/pyeffic/emitters/base.py

@@ -48,6 +48,31 @@ class Spec:
     var_decl_template: str = "{nt} {target} = {val};"  # typed variable declaration
     ffi_prefix: str = ""  # decoration for C-ABI exports in library mode
     indent: str = "    "
+    # Type-aware exponentiation. Integer `**` and float `**` need different
+    # target syntax in most languages; when these are empty the emitter falls
+    # back to pow_call.
+    pow_int: str = ""
+    pow_float: str = ""
+    # two-argument min(a, b) / max(a, b). Most targets have no plain
+    # min/max function, so these carry the target-specific spelling.
+    min2_call: str = ""
+    max2_call: str = ""
+    # List slicing. `{x}` is the list, `{start}` and `{stop}` are integer
+    # bounds. list_copy is the full-slice form (`xs[:]`), which Python
+    # defines as a shallow copy.
+    # str.split(sep) / sep.join(list). Empty means unsupported.
+    str_split: str = ""
+    str_join: str = ""
+    list_slice: str = ""
+    list_copy: str = ""
+    # Iterating a dict in Python yields its keys. `dict_keys` is an
+    # expression producing those keys; `foreach_dict_template` is the
+    # loop head to use with it (Go ranges a map differently).
+    dict_keys: str = ""
+    foreach_dict_template: str = ""
+    # Printing a sequence. Python renders lists as `[1, 2, 3]`, so every
+    # backend must match that rather than its own native format.
+    print_list: str = ""
     # string operations
     str_concat: str = "{l} + {r}"  # string concatenation
     str_len: str = "{x}.length()"  # string length (C++ style)
@@ -74,6 +99,7 @@ class Spec:
     dict_contains: str = "({d}.find({k}) != {d}.end())"
     # tuple support
     tuple_type: str = "std::tuple<{T}>"
+    set_type: str = ""  # native set type
     tuple_get: str = "std::get<{i}>({t})"
     # list length (separate from len_call which may be used for strings)
     list_len: str = "{x}.size()"
@@ -90,6 +116,9 @@ class Emitter:
         self.params: set[str] = set()  # param names (already borrowed if list)
         self.library_mode: bool = False  # emit C-ABI exports instead of a main()
         self.extern_names: set[str] = set()  # extern "C" fns from other backends
+        # {name: ([param names], {param: default source text})} so a call site
+        # that omits defaults can fill them in.
+        self.func_signatures: dict[str, tuple[list[str], dict[str, str]]] = {}
         self.force_extern_c: bool = False  # force extern "C" on all functions (multi-backend)
         self.export_names: set[str] = set()  # Rust fns called from C++ — export them
         self.class_names: set[str] = set()  # known class names for constructor calls
@@ -179,6 +208,10 @@ class Emitter:
             return self.spec.dict_type.format(V=self.spec.list_elem_type)
         if t == "tuple":
             return self.spec.tuple_type.format(T=self.spec.list_elem_type)
+        if t == "set":
+            if self.spec.set_type:
+                return self.spec.set_type
+            return self.spec.list_type.format(T=self.spec.list_elem_type)
         # class type — use the class name directly
         if t in self.class_names:
             return t
@@ -220,6 +253,12 @@ class Emitter:
             return self.spec.dict_type.format(V=self.spec.list_elem_type)
         if t == "tuple":
             return self.spec.tuple_type.format(T=self.spec.list_elem_type)
+        if t == "set":
+            if self.spec.set_type:
+                if self.spec.name == "cpp":
+                    return f"const {self.spec.set_type}&"
+                return self.spec.set_type
+            return self.spec.list_param_type
         # class type — pass by value (or const ref in C++)
         if t in self.class_names:
             if self.spec.name == "cpp":
@@ -334,6 +373,12 @@ class Emitter:
                 self.var_types[target] = t
                 self.declared.add(target)
             nt = self.py_to_native(t)
+            if t == "list":
+                # a bare `list` annotation carries no element type; take it
+                # from the value so `xs = "a,b".split(",")` is a string list
+                elem = self._list_elem_of_value(node.value)
+                if elem and elem != self.spec.list_elem_type:
+                    nt = self.spec.list_type.format(T=elem)
             if self.spec.name == "rust":
                 self.lines.append(f"{ind}let mut {target}: {nt} = {self.expr(node.value)};")
             else:
@@ -754,7 +799,12 @@ class Emitter:
         msg = f"{self.current_func}: {feature}"
         if msg not in self.unsupported_emissions:
             self.unsupported_emissions.append(msg)
-        return f"/*unsupported: {feature}*/"
+        # Use the backend's own comment syntax: a C-style comment is not
+        # valid in Zig, and the placeholder still has to parse.
+        marker = getattr(self.spec, "comment", "//") or "//"
+        if marker.startswith("/*"):
+            return f"/*unsupported: {feature}*/"
+        return f"{marker} unsupported: {feature}"
 
     def _ident(self, name: str) -> str:
         """Escape a local/parameter name that collides with a target keyword.
@@ -858,12 +908,21 @@ class Emitter:
             self._for_zip(node, ind)
             return
         else:
-            # iterate a container (list)
+            # iterate a container
             iter_s = self.expr(it)
-            elem_type = self._iter_elem_type(it)
-            self.var_types[var] = elem_type
-            head = self.spec.foreach_template.format(var=var, iter=iter_s,
-                                                      etype=self.spec.list_elem_type)
+            if self.infer_type(it) == "dict" and self.spec.dict_keys:
+                # Python iterates dict keys, not (key, value) pairs
+                iter_s = self.spec.dict_keys.format(x=iter_s)
+                tmpl = (self.spec.foreach_dict_template
+                        or self.spec.foreach_template)
+                self.var_types[var] = "str"
+                head = tmpl.format(var=var, iter=iter_s,
+                                   etype=self.spec.list_elem_type)
+            else:
+                elem_type = self._iter_elem_type(it)
+                self.var_types[var] = elem_type
+                head = self.spec.foreach_template.format(
+                    var=var, iter=iter_s, etype=self.spec.list_elem_type)
             self.lines.append(f"{ind}{head} {{")
         self.indent_lvl += 1
         for s in node.body:
@@ -991,7 +1050,7 @@ class Emitter:
             if isinstance(node.op, ast.FloorDiv):
                 return self.spec.floor_div.format(l=left, r=right)
             if isinstance(node.op, ast.Pow):
-                return self.spec.pow_call.format(l=left, r=right)
+                return self._pow(left, right, node)
             if isinstance(node.op, ast.Add):
                 lt = self.infer_type(node.left)
                 rt = self.infer_type(node.right)
@@ -1079,8 +1138,11 @@ class Emitter:
             orelse = self.expr(node.orelse)
             if self.spec.name == "rust":
                 return f"if {cond} {{ {body} }} else {{ {orelse} }}"
-            if self.spec.name in ("cpp", "csharp", "kotlin"):
+            if self.spec.name in ("cpp", "csharp"):
                 return f"({cond} ? {body} : {orelse})"
+            if self.spec.name == "kotlin":
+                # Kotlin has no ?: operator — it uses an if expression
+                return f"(if ({cond}) {body} else {orelse})"
             if self.spec.name == "go":
                 return f"(func() int64 {{ if {cond} {{ return {body} }}; return {orelse} }}())"
             if self.spec.name == "zig":
@@ -1104,9 +1166,18 @@ class Emitter:
                     if stop:
                         return self.spec.str_slice_end.format(x=base, end=stop)
                     return base  # full slice s[:] = s
-                # list slicing — not fully supported, mark as unsupported
-                if start and stop:
-                    return self._mark_unsupported(f"list slice {base}[{start}:{stop}]")
+                # list slicing — xs[a:b], xs[a:], xs[:b], xs[:]
+                if self.spec.list_slice:
+                    length = self.spec.len_call.format(x=base)
+                    if not start:
+                        start = self.spec.int_cast.format(x="0")
+                    if not stop:
+                        stop = length
+                    if not sl.lower and not sl.upper:
+                        if self.spec.list_copy:
+                            return self.spec.list_copy.format(x=base)
+                    return self.spec.list_slice.format(
+                        x=base, start=start, stop=stop)
                 return self._mark_unsupported(f"list slice {base}")
             idx = self.expr(node.slice)
             if base_type == "dict":
@@ -1135,17 +1206,22 @@ class Emitter:
             return self.spec.index_call.format(x=base, i=idx)
         if isinstance(node, ast.List):
             elems = ", ".join(self.expr(e) for e in node.elts)
+            # a literal of strings needs a string element type, not the
+            # backend's default integer element
+            elem = self._list_elem_of_value(node) or self.spec.list_elem_type
             if self.spec.name == "rust":
                 return f"vec![{elems}]"
             if self.spec.name == "go":
-                return f"[]{self.spec.list_elem_type}{{{elems}}}"
+                return f"[]{elem}{{{elems}}}"
             if self.spec.name == "kotlin":
                 return f"mutableListOf({elems})"
             if self.spec.name == "zig":
                 return f"&[_]i64{{ {elems} }}"
             if self.spec.name == "csharp":
-                return f"new {self.spec.list_type}{{{elems}}}"
-            return f"std::vector<{self.spec.list_elem_type}>{{{elems}}}"
+                lt = self.spec.list_type.format(T=elem)
+                return f"new {lt}{{{elems}}}"
+            lt = self.spec.list_type.format(T=elem)
+            return f"{lt}{{{elems}}}"
         if isinstance(node, ast.ListComp):
             return self._list_comp(node)
         if isinstance(node, ast.Dict):
@@ -1186,15 +1262,36 @@ class Emitter:
             if self.spec.name == "csharp":
                 return f"new HashSet<long>{{{elems}}}"
             if self.spec.name == "go":
-                return f"map[int64_t]struct{{}}{{}}"
+                # Go has no set type; GE uses map[elem]bool. Go rejects
+                # duplicate *constant* keys at compile time, so literals are
+                # deduplicated here (a runtime set would collapse them anyway).
+                seen: list[str] = []
+                for e in node.elts:
+                    rendered = self.expr(e)
+                    if rendered not in seen:
+                        seen.append(rendered)
+                if not seen:
+                    return "map[int64]bool{}"
+                pairs = ", ".join(f"{v}: true" for v in seen)
+                return f"map[int64]bool{{{pairs}}}"
             if self.spec.name == "kotlin":
                 return f"hashSetOf({elems})"
+            if self.spec.name == "zig":
+                # no allocator-backed set in the Zig runtime
+                return self._mark_unsupported("set literal (Zig)")
             return f"std::set<int64_t>{{{elems}}}"
         if isinstance(node, ast.SetComp):
             return self._set_comp(node)
         if isinstance(node, ast.DictComp):
             return self._dict_comp(node)
         if isinstance(node, ast.Tuple):
+            # GE models tuples as fixed-width pairs. Anything else would need
+            # a per-arity native type (Go structs, Kotlin Triple, ...), so it
+            # is rejected loudly rather than emitted as broken code.
+            if len(node.elts) != 2:
+                return self._mark_unsupported(
+                    f"tuple of {len(node.elts)} elements "
+                    f"(only 2-element tuples are supported)")
             elems = ", ".join(self.expr(e) for e in node.elts)
             if self.spec.name == "rust":
                 return f"({elems})"
@@ -1273,10 +1370,16 @@ class Emitter:
         if fname == "sum":
             return self.spec.sum_call.format(it=self.expr(node.args[0]))
         if fname in ("min", "max"):
-            tmpl = self.spec.min_call if fname == "min" else self.spec.max_call
+            is_min = fname == "min"
+            tmpl = self.spec.min_call if is_min else self.spec.max_call
             raw = [self.expr(a) for a in node.args]
             if len(raw) == 1:
                 return tmpl.format(it=raw[0])
+            if len(raw) == 2:
+                pair = (self.spec.min2_call if is_min
+                        else self.spec.max2_call)
+                if pair:
+                    return pair.format(a=raw[0], b=raw[1])
             return f"{fname}({', '.join(raw)})"
         if fname == "pow":
             return self.spec.pow_call.format(l=self.expr(node.args[0]), r=self.expr(node.args[1]))
@@ -1584,8 +1687,26 @@ class Emitter:
             return self._stdlib_call("ge_log", node.args)
         if fname == "exp":
             return self._stdlib_call("ge_exp", node.args)
+        if (isinstance(node.func, ast.Attribute) and node.func.attr == "split"
+                and len(node.args) == 1):
+            if not self.spec.str_split:
+                return self._mark_unsupported(
+                    f"str.split (not available on the {self.spec.name} backend)")
+            return self.spec.str_split.format(
+                x=self.expr(node.func.value), sep=self.expr(node.args[0]))
+        if (isinstance(node.func, ast.Attribute) and node.func.attr == "join"
+                and len(node.args) == 1):
+            if not self.spec.str_join:
+                return self._mark_unsupported(
+                    f"str.join (not available on the {self.spec.name} backend)")
+            return self.spec.str_join.format(
+                x=self.expr(node.args[0]), sep=self.expr(node.func.value))
         if isinstance(node.func, ast.Attribute) and node.func.attr == "append":
             base = self.expr(node.func.value)
+            if not self.spec.append_call:
+                return self._mark_unsupported(
+                    f"list.append (the {self.spec.name} backend models lists "
+                    f"as fixed slices)")
             return self.spec.append_call.format(x=base, v=self.expr(node.args[0]))
         # super().method(args) -> ParentClass_method(_self, args)
         if (isinstance(node.func, ast.Attribute) and
@@ -1620,7 +1741,7 @@ class Emitter:
                     if self.spec.name == "rust":
                         return f"{base}.to_uppercase()"
                     if self.spec.name == "cpp":
-                        return f"/*str.upper()*/"
+                        return f"geStrUpper({base})"
                     if self.spec.name == "csharp":
                         return f"{base}.ToUpper()"
                     if self.spec.name == "go":
@@ -1631,6 +1752,8 @@ class Emitter:
                 if method == "lower":
                     if self.spec.name == "rust":
                         return f"{base}.to_lowercase()"
+                    if self.spec.name == "cpp":
+                        return f"geStrLower({base})"
                     if self.spec.name == "csharp":
                         return f"{base}.ToLower()"
                     if self.spec.name == "go":
@@ -1638,6 +1761,19 @@ class Emitter:
                     if self.spec.name == "kotlin":
                         return f"{base}.lowercase()"
                     return f"{base}.lower()"
+                if method == "replace" and len(node.args) == 2:
+                    a = self.expr(node.args[0])
+                    b = self.expr(node.args[1])
+                    if self.spec.name == "rust":
+                        return f"{base}.replace({a}.as_str(), {b}.as_str())"
+                    if self.spec.name == "cpp":
+                        return f"geStrReplace({base}, {a}, {b})"
+                    if self.spec.name == "csharp":
+                        return f"{base}.Replace({a}, {b})"
+                    if self.spec.name == "go":
+                        return f"strings.ReplaceAll({base}, {a}, {b})"
+                    if self.spec.name == "kotlin":
+                        return f"{base}.replace({a}, {b})"
                 if method == "strip":
                     if self.spec.name == "rust":
                         return f"{base}.trim().to_string()"
@@ -1674,12 +1810,36 @@ class Emitter:
                 # **kwargs — not supported, skip
                 continue
             args.append(self.expr(kw.value))
+        args = self._fill_defaults(fname, args, node)
         call_str = f"{fname}({', '.join(args)})"
         # wrap extern "C" calls in unsafe block (Rust requires this)
         if fname in self.extern_names and self.spec.name == "rust":
             return f"unsafe {{ {call_str} }}"
         return call_str
 
+    def _fill_defaults(self, fname: str, args: list[str],
+                       node: ast.Call) -> list[str]:
+        """Append default arguments a call site omitted.
+
+        `def f(a, b=10)` called as `f(5)` must emit `f(5, 10)` in the target
+        language, which has no notion of Python default parameters.
+        """
+        if node.keywords:
+            return args
+        sig = self.func_signatures.get(fname)
+        if not sig:
+            return args
+        names, defaults = sig
+        if len(args) >= len(names):
+            return args
+        filled = list(args)
+        for name in names[len(filled):]:
+            d = defaults.get(name)
+            if d is None or d == "":
+                break
+            filled.append(d)
+        return filled
+
     def _str_call(self, arg: ast.AST) -> str:
         """Convert a value to string."""
         t = self.infer_type(arg)
@@ -2201,6 +2361,8 @@ class Emitter:
             return self.spec.print_float.format(v=v)
         if t == "bool":
             return self.spec.print_bool.format(v=v)
+        if t in ("list", "tuple", "set") and self.spec.print_list:
+            return self.spec.print_list.format(v=v)
         # fallback to heuristics on the source text
         if any(c in v for c in ".") and not v.startswith('"'):
             return self.spec.print_float.format(v=v)
@@ -2226,6 +2388,50 @@ class Emitter:
             return base if base in ("list", "dict", "tuple", "set") else "list"
         return "int"
 
+    def _list_elem_of_value(self, node: ast.AST) -> str:
+        """Native element type of a list-producing expression, or "".
+
+        A bare `list` annotation says nothing about the element type, so it is
+        taken from the value: `"a,b".split(",")` yields strings, not ints.
+        """
+        if (isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Attribute)):
+            attr = node.func.attr
+            if attr in ("split", "splitlines", "keys"):
+                return self.spec.types.get("str") or self._native_elem_type("str")
+            if attr == "values":
+                return self.spec.list_elem_type
+            if attr in ("copy", "sorted", "reverse"):
+                return self._list_elem_of_value(node.func.value) or ""
+            if attr == "split" or attr == "items":
+                return self.spec.types.get("str", "String")
+        if isinstance(node, ast.List):
+            types = [self.infer_type(e) for e in node.elts]
+            types = [t for t in types if t]
+            if types and all(t == types[0] for t in types):
+                return self._native_elem_type(types[0])
+        if isinstance(node, ast.ListComp):
+            return self._native_elem_type(self.infer_type(node.elt))
+        if isinstance(node, ast.Subscript):
+            return self._list_elem_of_value(node.value)
+        return ""
+
+    def _pow(self, left: str, right: str, node: ast.AST) -> str:
+        """Render `a ** b`.
+
+        Integer and float exponentiation need different target syntax, and a
+        bare literal like `2 ** 10` is ambiguous in Rust, so the operand type
+        decides which template is used.
+        """
+        lt = self.infer_type(node.left)
+        rt = self.infer_type(node.right)
+        is_float = lt == "float" or rt == "float"
+        if is_float and self.spec.pow_float:
+            return self.spec.pow_float.format(l=left, r=right)
+        if not is_float and self.spec.pow_int:
+            return self.spec.pow_int.format(l=left, r=right)
+        return self.spec.pow_call.format(l=left, r=right)
+
     def infer_type(self, node: ast.AST) -> str:
         if isinstance(node, ast.Constant):
             if isinstance(node.value, bool):

package/python/pyeffic/emitters/cpp.py

@@ -12,6 +12,10 @@ SPEC = Spec(
     list_type="std::vector<{T}>",
     list_param_type="std::vector<int64_t>&",
     list_elem_type="int64_t",
+    str_split="geStrSplit({x}, {sep})",
+    str_join="geStrJoin({x}, {sep})",
+    list_slice="std::vector<int64_t>({x}.begin() + ({start}), {x}.begin() + ({stop}))",
+    list_copy="std::vector<int64_t>({x})",
     borrow_list_arg=False,
     range_call="for_range({lo}, {hi})",
     range_step_call="for_range({lo}, {hi}, {step})",
@@ -20,8 +24,9 @@ SPEC = Spec(
     print_int='std::cout << ({v}) << std::endl',
     print_float='std::cout << ({v}) << std::endl',
     print_str='std::cout << ({v}) << std::endl',
-    print_bool='std::cout << ({v}) << std::endl',
+    print_bool='std::cout << (({v}) ? "True" : "False") << std::endl',
     print_generic='std::cout << ({v}) << std::endl',
+    print_list='std::cout << geListStr({v}) << std::endl',
     int_cast="static_cast<int64_t>({x})",
     float_cast="static_cast<double>({x})",
     float_div="(static_cast<double>({l}) / static_cast<double>({r}))",
@@ -29,9 +34,13 @@ SPEC = Spec(
     sum_call="std::accumulate({it}.begin(), {it}.end(), 0LL)",
     abs_int="std::abs({x})",
     abs_float="std::fabs({x})",
+    min2_call="std::min({a}, {b})",
+    max2_call="std::max({a}, {b})",
     min_call="*std::min_element({it}.begin(), {it}.end())",
     max_call="*std::max_element({it}.begin(), {it}.end())",
     pow_call="std::pow({l}, {r})",
+    pow_int="static_cast<int64_t>(std::pow(static_cast<double>({l}), static_cast<double>({r})))",
+    pow_float="std::pow({l}, {r})",
     append_call="{x}.push_back({v})",
     index_call="{x}[{i}]",
     comment="//",
@@ -51,8 +60,10 @@ SPEC = Spec(
     struct_field_template="    {type} {name};",
     struct_new_template="{name} {name}_new({params}) {{\n{body}\n}}",
     dict_type="std::map<std::string, {V}>",
+    set_type="std::set<int64_t>",
     dict_get="{d}.at({k})",
     dict_set="{d}[{k}] = {v}",
+    dict_keys="geDictKeys({x})",
     dict_contains="({d}.find({k}) != {d}.end())",
     tuple_type="std::tuple<{T}, {T}>",
     tuple_get="std::get<{i}>({t})",
@@ -80,8 +91,13 @@ class CppEmitter(Emitter):
                 )
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "int"
-            self.lines.append(f"{ind}for (auto& {var} : {iter_s}) {{")
+            if self.infer_type(it) == "dict":
+                self.var_types[var] = "str"
+                self.lines.append(
+                    f"{ind}for (auto {var} : geDictKeys({iter_s})) {{")
+            else:
+                self.var_types[var] = "int"
+                self.lines.append(f"{ind}for (auto& {var} : {iter_s}) {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -135,6 +151,11 @@ def emit_cpp(units: list[FuncUnit], entry: str | None,
              constants: dict | None = None,
              preamble: dict | None = None) -> tuple[str, dict[str, str]]:
     emitter = CppEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
     # in multi-backend mode, force extern "C" on all functions so Rust can link
@@ -160,6 +181,8 @@ def emit_cpp(units: list[FuncUnit], entry: str | None,
         "#include <cmath>\n"
         "#include <numeric>\n"
         "#include <algorithm>\n"
+        "#include <set>\n"
+        "#include <cctype>\n"
         "#include <string>\n\n"
         "using std::cout;\n"
         "using std::endl;\n\n"

package/python/pyeffic/emitters/csharp.py

@@ -14,9 +14,13 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="csharp",
     types={"int": "long", "float": "double", "bool": "bool", "str": "string", "None": "void"},
-    list_type="List<long>",
+    list_type="List<{T}>",
     list_param_type="List<long>",
     list_elem_type="long",
+    str_split="{x}.Split({sep}).ToList()",
+    str_join="string.Join({sep}, {x})",
+    list_slice="{x}.GetRange((int)({start}), (int)(({stop}) - ({start})))",
+    list_copy="new List<long>({x})",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi}).Step({step})",
@@ -27,6 +31,7 @@ SPEC = Spec(
     print_str='Console.WriteLine({v})',
     print_bool='Console.WriteLine({v})',
     print_generic='Console.WriteLine({v})',
+    print_list='Console.WriteLine("[" + string.Join(", ", {v}) + "]")',
     int_cast="(long)({x})",
     float_cast="(double)({x})",
     float_div="((double)({l}) / (double)({r}))",
@@ -34,9 +39,13 @@ SPEC = Spec(
     sum_call="{it}.Sum()",
     abs_int="Math.Abs({x})",
     abs_float="Math.Abs({x})",
+    min2_call="Math.Min({a}, {b})",
+    max2_call="Math.Max({a}, {b})",
     min_call="{it}.Min()",
     max_call="{it}.Max()",
     pow_call="Math.Pow({l}, {r})",
+    pow_int="(long)Math.Pow({l}, {r})",
+    pow_float="Math.Pow({l}, {r})",
     append_call="{x}.Add({v})",
     index_call="{x}[(int)({i})]",
     comment="//",
@@ -57,8 +66,10 @@ SPEC = Spec(
     struct_field_template="    public {type} {name};",
     struct_new_template="static {name} {name}_New({params}) {{\n{body}\n}}",
     dict_type="Dictionary<string, {V}>",
+    set_type="HashSet<long>",
     dict_get="{d}[{k}]",
     dict_set="{d}[{k}] = {v}",
+    dict_keys="{x}.Keys",
     dict_contains="{d}.ContainsKey({k})",
     tuple_type="({T}, {T})",
     tuple_get="{t}.Item{i1}",
@@ -108,8 +119,12 @@ class CSharpEmitter(Emitter):
             self.lines.append(f"{ind}for (long {var} = {lo}; {var} < {hi}; {var}++) {{")
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "long"
-            self.lines.append(f"{ind}foreach (var {var} in {iter_s}) {{")
+            if self.infer_type(it) == "dict":
+                self.var_types[var] = "str"
+                self.lines.append(f"{ind}foreach (var {var} in {iter_s}.Keys) {{")
+            else:
+                self.var_types[var] = "long"
+                self.lines.append(f"{ind}foreach (var {var} in {iter_s}) {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -133,9 +148,15 @@ class CSharpEmitter(Emitter):
     def stmt(self, node):  # type: ignore[override]
         # escape C# keywords in variable declarations
         if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+            # bare `list` gets its element type from the value
+            _ann = self._ann_type(node.annotation)
+            _elem = (self._list_elem_of_value(node.value)
+                     if (_ann == "list" and node.value is not None) else "")
             name = self._esc(node.target.id)
             ann_type = self._ann_type(node.annotation)
             nt = self.py_to_native(ann_type)
+            if _elem and _elem != self.spec.list_elem_type:
+                nt = self.spec.list_type.format(T=_elem)
             if node.value is not None:
                 val = self.expr(node.value)
                 self.lines.append(f"{self.spec.indent * self.indent_lvl}{nt} {name} = {val};")
@@ -227,6 +248,11 @@ def emit_csharp(units: list[FuncUnit], entry: str | None,
     extern_fns: functions from other backends that this C# code calls.
     """
     emitter = CSharpEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
     emitted: dict[str, str] = {}
@@ -317,6 +343,9 @@ def emit_csharp(units: list[FuncUnit], entry: str | None,
             for line in fn.split("\n"):
                 indented_fns.append("    " + line)
         indented_fns.append(wrapper.rstrip())
+    elif not fns:
+        # entry rejected during emission; see the pipeline diagnostic
+        return prelude, emitted
     else:
         # rename main to Main for C# entry point
         # C# Main must return void or int (32-bit), not long

package/python/pyeffic/emitters/go.py

@@ -13,9 +13,13 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="go",
     types={"int": "int64", "float": "float64", "bool": "bool", "str": "string", "None": ""},
-    list_type="[]int64",
+    list_type="[]{T}",
     list_param_type="[]int64",
     list_elem_type="int64",
+    str_split="strings.Split({x}, {sep})",
+    str_join="strings.Join({x}, {sep})",
+    list_slice="append([]int64(nil), {x}[{start}:{stop}]...)",
+    list_copy="append([]int64(nil), {x}...)",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi})",
@@ -24,18 +28,23 @@ SPEC = Spec(
     print_int='fmt.Println({v})',
     print_float='fmt.Println({v})',
     print_str='fmt.Println({v})',
-    print_bool='fmt.Println({v})',
+    print_bool='fmt.Println(geBoolStr({v}))',
     print_generic='fmt.Println({v})',
+    print_list='fmt.Println(geListStr({v}))',
     int_cast="int64({x})",
     float_cast="float64({x})",
     float_div="(float64({l}) / float64({r}))",
     floor_div="({l} / {r})",
     sum_call="func() int64 {{ var s int64; for _, v := range {it} {{ s += v }}; return s }}()",
-    abs_int="abs({x})",
+    abs_int="geAbsInt({x})",
     abs_float="math.Abs({x})",
+    min2_call="geMin2({a}, {b})",
+    max2_call="geMax2({a}, {b})",
     min_call="func() int64 {{ var m int64; for i, v := range {it} {{ if i == 0 || v < m {{ m = v }} }}; return m }}()",
     max_call="func() int64 {{ var m int64; for i, v := range {it} {{ if i == 0 || v > m {{ m = v }} }}; return m }}()",
     pow_call="int64(math.Pow(float64({l}), float64({r})))",
+    pow_int="int64(math.Pow(float64({l}), float64({r})))",
+    pow_float="math.Pow({l}, {r})",
     append_call="{x} = append({x}, {v})",
     index_call="{x}[{i}]",
     comment="//",
@@ -58,8 +67,11 @@ SPEC = Spec(
     struct_field_template="\t{type} {name}",
     struct_new_template="func {name}_New({params}) {name} {{\n{body}\n}}",
     dict_type="map[string]{V}",
+    set_type="map[int64]bool",
     dict_get="{d}[{k}]",
     dict_set="{d}[{k}] = {v}",
+    dict_keys="{x}",
+    foreach_dict_template="for {var} := range {iter}",
     dict_contains="dictContains({d}, {k})",
     tuple_type="struct {{ a {T}; b {T} }}",
     tuple_get="{t}.{field}",
@@ -157,8 +169,13 @@ class GoEmitter(Emitter):
             self.lines.append(f"{ind}    {var_a} := {it_a}[__i]; {var_b} := {it_b}[__i]")
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "long"
-            self.lines.append(f"{ind}for _, {var} := range {iter_s} {{")
+            if self.infer_type(it) == "dict":
+                # range over a map yields keys
+                self.var_types[var] = "str"
+                self.lines.append(f"{ind}for {var} := range {iter_s} {{")
+            else:
+                self.var_types[var] = "long"
+                self.lines.append(f"{ind}for _, {var} := range {iter_s} {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -186,6 +203,10 @@ class GoEmitter(Emitter):
             name = node.target.id
             ann_type = self._ann_type(node.annotation)
             nt = self.py_to_native(ann_type)
+            if ann_type == "list" and node.value is not None:
+                elem = self._list_elem_of_value(node.value)
+                if elem and elem != self.spec.list_elem_type:
+                    nt = self.spec.list_type.format(T=elem)
             if node.value is not None:
                 val = self.expr(node.value)
                 self.lines.append(f"{self.spec.indent * self.indent_lvl}var {name} {nt} = {val}")
@@ -211,7 +232,8 @@ class GoEmitter(Emitter):
     def _ann_type(self, node: ast.AST) -> str:
         if isinstance(node, ast.Name):
             t = node.id
-            if t in ("int", "float", "bool", "str", "list", "dict", "tuple"):
+            if t in ("int", "float", "bool", "str", "list", "dict",
+                     "tuple", "set"):
                 return t
             if t in self.class_names:
                 return t
@@ -276,6 +298,11 @@ def emit_go(units: list[FuncUnit], entry: str | None,
     extern_fns: functions from other backends that this Go code calls.
     """
     emitter = GoEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
     emitted: dict[str, str] = {}
@@ -294,6 +321,7 @@ def emit_go(units: list[FuncUnit], entry: str | None,
         "package main\n\n"
         'import "fmt"\n'
         'import "strings"\n'
+        'import "strconv"\n'
         'import "sort"\n'
         'import "os"\n'
         'import "math"\n'
@@ -369,6 +397,10 @@ def emit_go(units: list[FuncUnit], entry: str | None,
         else:
             wrapper = f"func main() {{\n\t_ = {entry_u.name}()\n}}\n"
         fns.append(wrapper)
+    elif not fns:
+        # the entry function was rejected during emission; the pipeline
+        # already holds the reason, so return what we have
+        return prelude + "\n".join(fns), emitted
     else:
         # Go main() must have no arguments and no return values
         # Rename the user's main() to __ge_main() and add a wrapper

package/python/pyeffic/emitters/kotlin.py

@@ -14,9 +14,13 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="kotlin",
     types={"int": "Long", "float": "Double", "bool": "Boolean", "str": "String", "None": "Unit"},
-    list_type="MutableList<Long>",
+    list_type="MutableList<{T}>",
     list_param_type="MutableList<Long>",
     list_elem_type="Long",
+    str_split="{x}.split({sep}).toMutableList()",
+    str_join="{x}.joinToString({sep})",
+    list_slice="{x}.subList(({start}).toInt(), ({stop}).toInt()).toMutableList()",
+    list_copy="{x}.toMutableList()",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi} step {step})",
@@ -25,8 +29,9 @@ SPEC = Spec(
     print_int='println({v})',
     print_float='println({v})',
     print_str='println({v})',
-    print_bool='println({v})',
+    print_bool='println(if ({v}) "True" else "False")',
     print_generic='println({v})',
+    print_list='println({v}.joinToString(", ", "[", "]"))',
     int_cast="{x}.toLong()",
     float_cast="{x}.toDouble()",
     float_div="({l}.toDouble() / {r}.toDouble())",
@@ -34,9 +39,13 @@ SPEC = Spec(
     sum_call="{it}.sum()",
     abs_int="abs({x})",
     abs_float="abs({x})",
+    min2_call="minOf({a}, {b})",
+    max2_call="maxOf({a}, {b})",
     min_call="{it}.minOrNull()!!",
     max_call="{it}.maxOrNull()!!",
-    pow_call="Math.pow({l}.toDouble(), {r}.toDouble()).toLong()",
+    pow_call="{l}.toDouble().pow({r}.toDouble()).toLong()",
+    pow_int="{l}.toDouble().pow({r}.toDouble()).toLong()",
+    pow_float="{l}.pow({r})",
     append_call="{x}.add({v})",
     index_call="{x}[{i}.toInt()]",
     comment="//",
@@ -58,8 +67,10 @@ SPEC = Spec(
     struct_field_template="    val {type}: {name},",
     struct_new_template="fun {name}_new({params}): {name} {{\n{body}\n}}",
     dict_type="HashMap<String, {V}>",
-    dict_get="{d}[{k}]",
+    set_type="MutableSet<Long>",
+    dict_get="{d}[{k}]!!",
     dict_set="{d}[{k}] = {v}",
+    dict_keys="{x}.keys",
     dict_contains="{d}.containsKey({k})",
     tuple_type="Pair<{T}, {T}>",
     tuple_get="{t}.{field}",
@@ -146,8 +157,12 @@ class KotlinEmitter(Emitter):
             self.lines.append(f"{ind}for ({var} in {lo} until {hi}) {{")
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "long"
-            self.lines.append(f"{ind}for ({var} in {iter_s}) {{")
+            if self.infer_type(it) == "dict":
+                self.var_types[var] = "str"
+                self.lines.append(f"{ind}for ({var} in {iter_s}.keys) {{")
+            else:
+                self.var_types[var] = "long"
+                self.lines.append(f"{ind}for ({var} in {iter_s}) {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -217,6 +232,11 @@ def emit_kotlin(units: list[FuncUnit], entry: str | None,
     extern_fns: functions from other backends that this Kotlin code calls.
     """
     emitter = KotlinEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
     emitted: dict[str, str] = {}
@@ -295,6 +315,9 @@ def emit_kotlin(units: list[FuncUnit], entry: str | None,
         else:
             wrapper = f"fun main() {{\n    {entry_u.name}()\n}}\n"
         fns.append(wrapper)
+    elif not fns:
+        # entry rejected during emission; see the pipeline diagnostic
+        return prelude + "\n".join(fns), emitted
     else:
         # Kotlin main() must return Unit (void)
         # Rename the user's main() to __ge_main() and add a wrapper

package/python/pyeffic/emitters/rust.py

@@ -12,6 +12,10 @@ SPEC = Spec(
     list_type="Vec<{T}>",
     list_param_type="&[i64]",
     list_elem_type="i64",
+    str_split="{x}.split({sep}.as_str()).map(|s| s.to_string()).collect::<Vec<String>>()",
+    str_join="{x}.join({sep}.as_str())",
+    list_slice="{x}[({start}) as usize..({stop}) as usize].to_vec()",
+    list_copy="{x}.clone()",
     borrow_list_arg=True,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi}).step_by({step} as usize)",
@@ -20,25 +24,32 @@ SPEC = Spec(
     print_int='println!("{{}}", {v})',
     print_float='println!("{{}}", {v})',
     print_str='println!("{{}}", {v})',
-    print_bool='println!("{{}}", {v})',
+    print_bool='println!("{{}}", if {v} {{ "True" }} else {{ "False" }})',
     print_generic='println!("{{:?}}", {v})',
+    print_list='println!("{{:?}}", {v})',
     int_cast="{x} as i64",
     float_cast="{x} as f64",
     float_div="({l} as f64 / {r} as f64)",
     floor_div="({l} / {r})",
     sum_call="{it}.iter().sum::<i64>()",
-    abs_int="{x}.abs()",
+    abs_int="i64::abs({x})",
     abs_float="{x}.abs()",
+    min2_call="std::cmp::min({a}, {b})",
+    max2_call="std::cmp::max({a}, {b})",
     min_call="{it}.iter().min().unwrap()",
     max_call="{it}.iter().max().unwrap()",
     pow_call="{l}.pow({r} as u32)",
+    pow_int="i64::pow({l}, {r} as u32)",
+    pow_float="f64::powf({l}, {r})",
     append_call="{x}.push({v})",
     index_call="{x}[{i} as usize]",
     comment="//",
     fn_template="{sig} {{\n{body}\n}}",
     main_template="",
     ffi_prefix="#[no_mangle]\npub extern \"C\" ",
-    str_concat="{l} + &{r}",
+    # `String + &String` is not Add in Rust and `a + b` moves `a`, so a
+    # format! is used instead — always correct, and it accepts &str too.
+    str_concat="format!(\"{{}}{{}}\", {l}, {r})",
     str_len="{x}.len() as i64",
     str_index="{x}.as_bytes()[{i} as usize] as i64",
     str_slice="{x}[{start}..{end}].to_string()",
@@ -52,8 +63,11 @@ SPEC = Spec(
     struct_field_template="    {type}: {name},",
     struct_new_template="fn {name}_new({params}) -> {name} {{\n{body}\n}}",
     dict_type="std::collections::HashMap<String, {V}>",
+    set_type="std::collections::HashSet<i64>",
     dict_get="{d}.get(&{k}).copied().unwrap_or(0)",
     dict_set="{d}.insert({k}, {v})",
+    dict_keys="{x}.keys().cloned().collect::<Vec<String>>()",
+    foreach_dict_template="for {var} in {iter}",
     dict_contains="{d}.contains_key(&{k})",
     tuple_type="({T}, {T})",
     tuple_get="{t}.{i}",
@@ -188,6 +202,11 @@ def emit_rust(units: list[FuncUnit], entry: str | None,
     constants: module-level constants to inline (name -> value).
     """
     emitter = RustEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.export_names = set(export_fns) if export_fns else set()
     emitter.constants = constants or {}

package/python/pyeffic/emitters/zig.py

@@ -13,9 +13,11 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="zig",
     types={"int": "i64", "float": "f64", "bool": "bool", "str": "[]const u8", "None": "void"},
-    list_type="[]const i64",
+    list_type="[]const {T}",
     list_param_type="[]const i64",
     list_elem_type="i64",
+    list_slice="{x}[@intCast({start})..@intCast({stop})]",
+    list_copy="{x}",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi})",
@@ -24,19 +26,26 @@ SPEC = Spec(
     print_int='std.io.getStdOut().writer().print("{{d}}\\n", .{{{v}}}) catch unreachable',
     print_float='std.io.getStdOut().writer().print("{{d}}\\n", .{{{v}}}) catch unreachable',
     print_str='std.io.getStdOut().writer().print("{{s}}\\n", .{{{v}}}) catch unreachable',
-    print_bool='std.io.getStdOut().writer().print("{}\\n", .{{{v}}}) catch unreachable',
+    print_bool='std.io.getStdOut().writer().print("{{s}}\\n", .{{if ({v}) "True" else "False"}}) catch unreachable',
     print_generic='std.io.getStdOut().writer().print("{{any}}\\n", .{{{v}}}) catch unreachable',
+    print_list='gePrintList({v})',
     int_cast="@as(i64, {x})",
     float_cast="@as(f64, {x})",
     float_div="(@as(f64, {l}) / @as(f64, {r}))",
     floor_div="@divFloor({l}, {r})",
     sum_call="blk: {{ var s: i64 = 0; for ({it}) |v| {{ s += v; }} break :blk s; }}",
-    abs_int="@intCast(if ({x} < 0) -{x} else {x})",
+    abs_int="@as(i64, @intCast(if ({x} < 0) -{x} else {x}))",
     abs_float="@abs({x})",
+    min2_call="@min({a}, {b})",
+    max2_call="@max({a}, {b})",
     min_call="@min({it}...)",
     max_call="@max({it}...)",
     pow_call="std.math.pow(i64, {l}, {r})",
-    append_call="{x}.append({v}) catch unreachable",
+    pow_int="std.math.pow(i64, {l}, {r})",
+    pow_float="std.math.pow(f64, {l}, {r})",
+    # Zig lists are `[]const i64` slices and cannot grow; list.append
+    # is rejected with a clear diagnostic rather than emitting invalid Zig.
+    append_call="",
     index_call="{x}[@as(usize, @intCast({i}))]",
     comment="//",
     fn_template="{sig} {{\n{body}\n}}",
@@ -194,6 +203,7 @@ class ZigEmitter(Emitter):
                 self.lines.append(f"{ind}_ = {self.expr(node.value)};")
                 return
         if isinstance(node, ast.AnnAssign) and node.value is not None:
+            # bare `list` gets its element type from the value
             target = node.target.id if isinstance(node.target, ast.Name) else self.expr(node.target)
             t = self._ann_type(node.annotation) if isinstance(node.target, ast.Name) else self.infer_type(node.value)
             if isinstance(node.target, ast.Name):
@@ -244,8 +254,16 @@ class ZigEmitter(Emitter):
             self.lines.append(f"{ind}while ({var} < {hi}) : ({var} += 1) {{")
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "long"
-            self.lines.append(f"{ind}for ({iter_s}) |{var}| {{")
+            if self.infer_type(it) == "dict":
+                # Zig has no allocator here, so walk the map's key iterator
+                # instead of materialising a key list.
+                self.var_types[var] = "str"
+                self.lines.append(f"{ind}var __keys_{var} = {iter_s}.keyIterator();")
+                self.lines.append(f"{ind}while (__keys_{var}.next()) |__kp_{var}| {{")
+                self.lines.append(f"{ind}    const {var} = __kp_{var}.*;")
+            else:
+                self.var_types[var] = "long"
+                self.lines.append(f"{ind}for ({iter_s}) |{var}| {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -315,6 +333,11 @@ def emit_zig(units: list[FuncUnit], entry: str | None,
     extern_fns: functions from other backends that this Zig code calls.
     """
     emitter = ZigEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
     emitted: dict[str, str] = {}
@@ -392,6 +415,10 @@ def emit_zig(units: list[FuncUnit], entry: str | None,
         else:
             wrapper = f"pub fn main() void {{\n    _ = {entry_u.name}();\n}}\n"
         fns.append(wrapper)
+    elif not fns:
+        # the entry function was rejected during emission; the pipeline
+        # already has the reason, so emit a stub rather than crashing
+        return prelude, emitted
     else:
         # Zig main() must return void (or u8 for exit code)
         # Rename the user's main() to __ge_main() and add a wrapper

package/python/pyeffic/stdlib.py

@@ -156,6 +156,64 @@ fn ge_exp(x: f64) -> f64 { x.exp() }
 ''',
     "cpp": '''
 // GE Math runtime (C++)
+std::string geStrUpper(std::string s) {
+    for (auto& c : s) c = (char)std::toupper((unsigned char)c);
+    return s;
+}
+
+std::string geStrLower(std::string s) {
+    for (auto& c : s) c = (char)std::tolower((unsigned char)c);
+    return s;
+}
+
+std::string geStrReplace(std::string s, const std::string& from,
+                         const std::string& to) {
+    if (from.empty()) return s;
+    size_t pos = 0;
+    while ((pos = s.find(from, pos)) != std::string::npos) {
+        s.replace(pos, from.size(), to);
+        pos += to.size();
+    }
+    return s;
+}
+
+std::vector<std::string> geStrSplit(const std::string& s, const std::string& sep) {
+    std::vector<std::string> out;
+    if (sep.empty()) { out.push_back(s); return out; }
+    size_t pos = 0, found;
+    while ((found = s.find(sep, pos)) != std::string::npos) {
+        out.push_back(s.substr(pos, found - pos));
+        pos = found + sep.size();
+    }
+    out.push_back(s.substr(pos));
+    return out;
+}
+
+std::string geStrJoin(const std::vector<std::string>& v, const std::string& sep) {
+    std::string out;
+    for (size_t i = 0; i < v.size(); ++i) {
+        if (i) out += sep;
+        out += v[i];
+    }
+    return out;
+}
+
+std::vector<std::string> geDictKeys(const std::map<std::string, int64_t>& d) {
+    std::vector<std::string> ks;
+    ks.reserve(d.size());
+    for (const auto& kv : d) ks.push_back(kv.first);
+    return ks;
+}
+
+std::string geListStr(const std::vector<int64_t>& v) {
+    std::string s = "[";
+    for (size_t i = 0; i < v.size(); ++i) {
+        if (i) s += ", ";
+        s += std::to_string(v[i]);
+    }
+    return s + "]";
+}
+
 double ge_sqrt(double x) { return std::sqrt(x); }
 double ge_floor(double x) { return std::floor(x); }
 double ge_ceil(double x) { return std::ceil(x); }
@@ -180,6 +238,42 @@ static double GeExp(double x) { return System.Math.Exp(x); }
 ''',
     "go": '''
 // GE Math runtime (Go)
+func geAbsInt(x int64) int64 {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+func geMin2(a, b int64) int64 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func geMax2(a, b int64) int64 {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func geListStr(v []int64) string {
+	parts := make([]string, len(v))
+	for i, x := range v {
+		parts[i] = strconv.FormatInt(x, 10)
+	}
+	return "[" + strings.Join(parts, ", ") + "]"
+}
+
+func geBoolStr(b bool) string {
+	if b {
+		return "True"
+	}
+	return "False"
+}
+
 func geSqrt(x float64) float64 { return math.Sqrt(x) }
 func geFloor(x float64) float64 { return math.Floor(x) }
 func geCeil(x float64) float64 { return math.Ceil(x) }
@@ -205,6 +299,16 @@ fun ge_exp(x: Double): Double = exp(x)
 ''',
     "zig": '''
 // GE Math runtime (Zig)
+fn gePrintList(v: []const i64) void {
+    const w = std.io.getStdOut().writer();
+    w.print("[", .{}) catch unreachable;
+    for (v, 0..) |x, i| {
+        if (i > 0) w.print(", ", .{}) catch unreachable;
+        w.print("{d}", .{x}) catch unreachable;
+    }
+    w.print("]\\n", .{}) catch unreachable;
+}
+
 fn ge_sqrt(x: f64) f64 { return @sqrt(x); }
 fn ge_floor(x: f64) f64 { return @floor(x); }
 fn ge_ceil(x: f64) f64 { return @ceil(x); }

package/python/pyeffic/typecheck.py

@@ -34,6 +34,8 @@ class TypeChecker:
         self.file = file
         self.errors = ErrorReporter()
         self.func_sigs: dict[str, tuple[list[str], str]] = {}  # name -> (param_types, ret_type)
+
+        self.func_required: dict[str, int] = {}
         self.func_names: set[str] = set()
         self.class_names: set[str] = set()
 
@@ -49,6 +51,8 @@ class TypeChecker:
             if u.supported and u.body:
                 param_types = [t for _, t in u.params]
                 self.func_sigs[u.name] = (param_types, u.ret_type)
+                self.func_required[u.name] = getattr(
+                    u, "n_required_params", len(param_types)) or len(param_types)
                 self.func_names.add(u.name)
         # collect class names
         if classes:
@@ -97,16 +101,25 @@ class TypeChecker:
             # check if calling a known function with wrong number of args
             if fname in self.func_sigs:
                 param_types, _ = self.func_sigs[fname]
-                if len(node.args) != len(param_types):
+                n_req = self.func_required.get(fname, len(param_types))
+                n_given = len(node.args)
+                if n_given < n_req or n_given > len(param_types):
+                    if n_req == len(param_types):
+                        expect = f"{len(param_types)} args"
+                    else:
+                        expect = (f"between {n_req} and "
+                                  f"{len(param_types)} args")
                     self.errors.error(
                         "GE002",
-                        f"function '{fname}' expects {len(param_types)} args, "
-                        f"got {len(node.args)}",
+                        f"function '{fname}' expects {expect}, "
+                        f"got {n_given}",
                         file=self.file, line=node.lineno,
                     )
             # check for undefined function calls
             elif fname not in ("print", "len", "range", "abs", "sum", "min", "max",
                                "float", "int", "str", "bool", "dict", "list", "tuple",
+                               "round", "sorted", "reversed", "enumerate", "zip",
+                               "any", "all", "pow", "divmod", "ord", "chr",
                                "ge_inline", "ge_raw", "ge_preamble"):
                 if fname not in self.class_names:
                     self.errors.error(