gelang 0.1.3 → 0.1.5

package/python/pyeffic/emitters/base.py

@@ -48,6 +48,40 @@ 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 = ""
+    # str.upper() / str.lower(). Empty falls back to the per-backend
+    # branch in the dispatcher.
+    str_upper: str = ""
+    str_lower: str = ""
+    # str.replace(a, b). Empty falls back to the generic method call.
+    str_replace: str = ""
+    # in-place list.sort() / list.reverse()
+    list_sort: str = ""
+    list_reverse: 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 +108,9 @@ class Spec:
     dict_contains: str = "({d}.find({k}) != {d}.end())"
     # tuple support
     tuple_type: str = "std::tuple<{T}>"
+    set_type: str = ""  # native set type
+    set_len: str = ""  # len(set)
+    dict_len: str = ""  # len(dict)
     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 +127,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 +219,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
@@ -197,6 +241,10 @@ class Emitter:
                 elem_t = self._native_elem_type(self.param_elem_types[pname])
                 if self.spec.name == "rust":
                     return f"&[{elem_t}]"
+                if self.spec.name == "zig":
+                    # a list parameter is always a pointer to the caller's
+                    # ArrayList so mutation is visible to it
+                    return f"*std.ArrayList({elem_t})"
                 return self.spec.list_type.format(T=elem_t)
             return self.spec.list_param_type
         if t == "dict":
@@ -220,6 +268,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 +388,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 +814,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 +923,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 +1065,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 +1153,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 +1181,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 +1221,25 @@ 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} }}"
+                # Zig lists are growable ArrayLists; build one from the literal
+                if not node.elts:
+                    return f"geListNew({elem})"
+                return f"geListFrom({elem}, &[_]{elem}{{ {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):
@@ -1171,11 +1265,20 @@ class Emitter:
                                  for k, v in zip(node.keys, node.values))
                 return f"hashMapOf({pairs})"
             if self.spec.name == "zig":
-                # Zig doesn't have map literals — emit a block expression
-                # that creates and populates the map
-                puts = "\n".join(f"        m.put({self.expr(k)}, {self.expr(v)}) catch unreachable;"
-                                for k, v in zip(node.keys, node.values))
-                return f"blk: {{\n        var m = std.StringHashMap({self.spec.list_elem_type}).init(std.heap.page_allocator);\n{puts}\n        break :blk m;\n    }}"
+                # Zig has no map literal; build one with the arena allocator.
+                # An empty literal needs no block at all, and a block whose
+                # local is never mutated is rejected by Zig.
+                if not node.keys:
+                    return (f"std.StringHashMap({self.spec.list_elem_type})"
+                            f".init(ge_alloc)")
+                puts = "\n".join(
+                    f"    __m.put({self.expr(k)}, {self.expr(v)}) catch unreachable;"
+                    for k, v in zip(node.keys, node.values))
+                return (f"blk: {{\n"
+                        f"    var __m = std.StringHashMap({self.spec.list_elem_type}).init(ge_alloc);\n"
+                        f"{puts}\n"
+                        f"    break :blk __m;\n"
+                        f"}}")
             return f"{{{pairs}}}"
         if isinstance(node, ast.Set):
             elems = ", ".join(self.expr(e) for e in node.elts)
@@ -1186,15 +1289,44 @@ 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":
+                # Zig has no set type; GE uses AutoHashMap(elem, void) over
+                # the arena allocator
+                if not node.elts:
+                    return "geSetNew(i64)"
+                seen: list[str] = []
+                for e in node.elts:
+                    rendered = self.expr(e)
+                    if rendered not in seen:
+                        seen.append(rendered)
+                return f"geSetFrom(i64, &[_]i64{{ {', '.join(seen)} }})" 
             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})"
@@ -1265,6 +1397,10 @@ class Emitter:
                 return self.spec.str_len.format(x=self.expr(arg))
             if t == "list":
                 return self.spec.list_len.format(x=self.expr(arg))
+            if t == "set" and self.spec.set_len:
+                return self.spec.set_len.format(x=self.expr(arg))
+            if t == "dict" and self.spec.dict_len:
+                return self.spec.dict_len.format(x=self.expr(arg))
             return self.spec.len_call.format(x=self.expr(arg))
         if fname == "abs":
             t = self.infer_type(node.args[0])
@@ -1273,10 +1409,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 +1726,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
@@ -1617,10 +1777,12 @@ class Emitter:
             if base_type == "str" or (isinstance(node.func.value, ast.Constant) and isinstance(node.func.value.value, str)):
                 method = node.func.attr
                 if method == "upper":
+                    if self.spec.str_upper:
+                        return self.spec.str_upper.format(x=base)
                     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":
@@ -1629,8 +1791,12 @@ class Emitter:
                         return f"{base}.uppercase()"
                     return f"{base}.upper()"
                 if method == "lower":
+                    if self.spec.str_lower:
+                        return self.spec.str_lower.format(x=base)
                     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 +1804,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.str_replace:
+                        return self.spec.str_replace.format(x=base, a=a, b=b)
+                    if self.spec.name == "rust":
+                        return f"{base}.replace({a}.as_str(), {b}.as_str())"
+                    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()"
@@ -1648,6 +1827,18 @@ class Emitter:
                     if self.spec.name == "kotlin":
                         return f"{base}.trim()"
                     return f"{base}.strip()"
+            # in-place list operations: xs.sort() / xs.reverse()
+            if (isinstance(node.func, ast.Attribute)
+                    and node.func.attr in ("sort", "reverse")
+                    and not node.args):
+                list_base = self.expr(node.func.value)
+                tpl = (self.spec.list_sort if node.func.attr == "sort"
+                       else self.spec.list_reverse)
+                if tpl:
+                    return tpl.format(x=list_base)
+                return self._mark_unsupported(
+                    f"list.{node.func.attr} (not available on the "
+                    f"{self.spec.name} backend)")
             # generic method call
             return f"{base}.{node.func.attr}({', '.join(args)})"
         # generic (user) function call: borrow list args where appropriate
@@ -1666,6 +1857,20 @@ class Emitter:
                     else:
                         args.append(f"&mut {self.expr(a)}")
                     continue
+            if self.spec.name == "zig" and self.infer_type(a) == "list":
+                # Zig list params are *std.ArrayList, so the caller passes a
+                # pointer to its own list (mutations must be visible).
+                if isinstance(a, ast.Name):
+                    args.append(f"&{self.expr(a)}")
+                else:
+                    # a literal or call result is an rvalue and cannot be
+                    # addressed; bind it to a temporary first
+                    tmp = f"__ge_arg{i}_{len(self.lines)}"
+                    self.lines.append(
+                        f"{self.spec.indent * self.indent_lvl}"
+                        f"var {tmp} = {self.expr(a)};")
+                    args.append(f"&{tmp}")
+                continue
             args.append(self._arg(a))
         # handle keyword arguments: map to positional by reordering
         # (native languages don't support keyword args, so we just append them)
@@ -1674,12 +1879,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)
@@ -1993,11 +2222,17 @@ class Emitter:
                     f"for _, {var} := range {iter_src} {{ __v = append(__v, int64({elem})) }}; "
                     f"return __v; }}()")
         if self.spec.name == "zig":
+            # build an ArrayList (the GE list type), not a slice
+            et = self.spec.list_elem_type
             if lo is not None:
-                return (f"blk: {{ var __v = std.ArrayList({self.spec.list_elem_type}).init(std.heap.page_allocator); "
-                        f"var {var}: i64 = {lo}; while ({var} < {hi}) : ({var} += 1) {{ __v.append({elem}) catch unreachable; }} "
-                        f"break :blk __v.toOwnedSlice() catch unreachable; }}")
-            return self._mark_unsupported('for-in comprehension in Zig')
+                return (f"blk: {{ var __v = geListNew({et}); "
+                        f"var {var}: i64 = {lo}; while ({var} < {hi}) : ({var} += 1) {{ "
+                        f"__v.append(@as({et}, @intCast({elem}))) catch unreachable; }} "
+                        f"break :blk __v; }}")
+            return (f"blk: {{ var __v = geListNew({et}); "
+                    f"for ({iter_src}.items) |{var}| {{ "
+                    f"__v.append(@as({et}, @intCast({elem}))) catch unreachable; }} "
+                    f"break :blk __v; }}")
         if self.spec.name == "kotlin":
             if lo is not None:
                 return (f"run {{ val __v = mutableListOf<Long>(); "
@@ -2201,6 +2436,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 +2463,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):
@@ -2319,6 +2600,17 @@ class Emitter:
                 key = f"{node.func.value.id}.{node.func.attr}"
                 if key in self.func_return_types:
                     return self.func_return_types[key]
+            # str methods that return a string. Without this, print() falls
+            # back to the generic format and a Zig []const u8 renders as a
+            # byte array.
+            if (isinstance(node.func, ast.Attribute)
+                    and self.infer_type(node.func.value) == "str"
+                    and node.func.attr in ("upper", "lower", "strip", "replace",
+                                           "join", "title", "capitalize")):
+                return "str"
+            if (isinstance(node.func, ast.Attribute)
+                    and node.func.attr in ("split", "splitlines")):
+                return "list"
         if isinstance(node, ast.Set):
             return "set"
         if isinstance(node, ast.SetComp):

package/python/pyeffic/emitters/cpp.py

@@ -12,6 +12,15 @@ SPEC = Spec(
     list_type="std::vector<{T}>",
     list_param_type="std::vector<int64_t>&",
     list_elem_type="int64_t",
+    list_sort="std::sort({x}.begin(), {x}.end())",
+    list_reverse="std::reverse({x}.begin(), {x}.end())",
+    str_split="geStrSplit({x}, {sep})",
+    str_upper="geStrUpper({x})",
+    str_lower="geStrLower({x})",
+    str_replace="geStrReplace({x}, {a}, {b})",
+    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 +29,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 +39,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 +65,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 +96,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 +156,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 +186,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"