gelang 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -4,6 +4,113 @@ 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).
 
+## [Unreleased]
+
+### Added
+
+- **Hybrid `.ge` frontend** — one file may mix Python-flavoured and
+  TypeScript-flavoured definitions. Flavour is detected per chunk.
+- **Named blocks** — `<name> ... </name>` gives a chunk a name; `@name(...)`
+  calls it from anywhere in the file, in either flavour, forward or backward.
+- **Mixed-backend native linking** — `ge build` emits each non-entry backend
+  in library mode with `extern "C"` exports, compiles it to an object, and
+  links one executable. No build script, no hand-written FFI.
+- **`ge diff`** — differential testing. Runs the same program through CPython
+  and every installed backend, comparing output byte-for-byte.
+- **`ge golden`** — golden lowering corpus. Emitted code must match the
+  committed golden, and compiling it must still print the expected output.
+- **`ge api-check`** — committed dumps of the CLI, diagnostics, and intrinsic
+  surfaces. Drift fails the check.
+- **`ge doctor`** — runtime and toolchain check with per-platform install
+  hints. `--json` for CI.
+- **`ge react`** — generates a React 19 + TypeScript + Vite project from a
+  `.ge.ui` file, one component per file.
+- **Organized build output** — `build/{desktop,web,mobile}/{backend,obj,bin}`.
+- **npm distribution** — `npx gelang` runs the compiler with bundled source,
+  no `pip install` required.
+- **`--target` buckets** — `desktop`, `web`, `mobile`.
+- **Target-keyword safety** — identifiers that collide with a target
+  language's reserved words are escaped (`@base` in C#, `r#match` in Rust)
+  or renamed consistently across the ABI (`double` → `double_`).
+
+### Fixed
+
+- C# reserved words in parameter positions emitted invalid code (`base`).
+- Function names colliding with target keywords broke compilation
+  (`double` in C++, `match` in Rust).
+- `from pyeffic.backends import rust` was resolved as user code, pulling the
+  compiler's own sources into the program.
+- `ge_build`/`build_flutter` used an undefined `preamble` variable.
+- Go backend wrote binaries next to the source instead of `build/<target>/bin`.
+- Module resolver matched a sibling file for dotted imports
+  (`app.main` resolved to `desktop/main.ge`).
+- `.ge.ui` parser rejected files with a leading docstring.
+- `.ge.ui` parser only accepted `Screen "title" {}`, not `Window { title: }`.
+
+### Changed
+
+- Canonical extension is `.ge`. `.ge.py` and `.ge.ts` remain supported for
+  single-flavour files; `.ts.ge.py` is accepted as a legacy alias.
+- Build root defaults to `build/` (was `ge_build/`).
+- Package name on npm is `gelang`.
+## [0.1.6] — 2026-09-13
+
+### Zig is now a full backend
+
+Zig modelled a GE list as a `[]const i64` slice, which cannot grow, so
+`append`, `sort`, `split`, list comprehensions and `min`/`max` over a list
+were either rejected or emitted Zig that did not compile. Research into
+Zig's allocator conventions settled the design: a generated program runs
+start to finish, so a single **arena** is the right fit — not
+`page_allocator` (a syscall per allocation) and not
+`GeneralPurposeAllocator` (a debugging allocator).
+
+Lists are now `std.ArrayList(T)` over an arena that `main()` releases:
+
+- literals become `geListFrom(elem, &[_]elem{...})`; an empty literal is
+  `geListNew(elem)`
+- append, sort, reverse, index, len, iteration, slicing and printing all work
+- a list parameter is `*std.ArrayList`, so mutation in the callee is visible
+  to the caller, matching Python's reference semantics. Call sites pass
+  `&name`; an rvalue argument is bound to a temporary first.
+- passing a list to a mutating callee marks the local `var` (Zig rejects an
+  unmutated `var`)
+
+Also implemented for Zig: `str.split`, `str.join`, `str.replace`,
+`str.upper`, `str.lower` (all arena-allocated), sets as
+`AutoHashMap(elem, void)` with a deduplicating literal, and dict literals
+over the arena.
+
+### Fixed
+
+- Iterating a Rust list yields `&i64`, so `for x in xs: if x == n` did not
+  compile. The loop now uses `.cloned()`, which yields owned values for both
+  `i64` and `String`. Python semantics are unchanged.
+- Go rejects `int64(3.9)` for an untyped constant; `int()` now truncates
+  through `math.Trunc`, matching Python.
+- `list.sort()` and `list.reverse()` had no implementation and fell through
+  to `xs.sort()`, valid only in Rust and Kotlin.
+- `ge analyze` parsed hybrid `.ge` files as plain Python, reporting a syntax
+  error on the first block tag, and never lowered `.ge.ts` at all.
+- `ge react` wrote to `web/` instead of the documented `build/web/`.
+- `ge flutter` handed a `.ge.ui` file to the module resolver, which tried to
+  parse `Window {` as Python.
+- The return type of `str.upper()` and friends was not inferred, so `print`
+  used the generic format — a Zig `[]const u8` rendered as a byte array.
+- `scripts/e2e.py` aborted the whole run with `UnicodeEncodeError` when a
+  compiler diagnostic contained a character the console codec cannot encode.
+
+### Added
+
+- `scripts/e2e.py` — 118 end-to-end cases that compile and run real programs
+  on every installed backend and compare stdout with CPython.
+- `str_upper`, `str_lower`, `str_replace`, `set_len` and `dict_len` on the
+  shared `Spec`, so every backend expresses these the same way.
+
+### Known limitations
+
+- Tuples are supported at arity 2; other arities are rejected with
+  `error[GE009]` rather than emitting broken code.
 ## [0.1.4] — 2026-09-13
 
 Found by `scripts/e2e.py`, a new harness that compiles and runs 118
@@ -57,55 +164,7 @@ programs on every installed backend and compares stdout with CPython.
 - Tuples are supported at arity 2; other arities are rejected with a
   diagnostic instead of emitting broken code.
 
-## [Unreleased]
-
-### Added
 
-- **Hybrid `.ge` frontend** — one file may mix Python-flavoured and
-  TypeScript-flavoured definitions. Flavour is detected per chunk.
-- **Named blocks** — `<name> ... </name>` gives a chunk a name; `@name(...)`
-  calls it from anywhere in the file, in either flavour, forward or backward.
-- **Mixed-backend native linking** — `ge build` emits each non-entry backend
-  in library mode with `extern "C"` exports, compiles it to an object, and
-  links one executable. No build script, no hand-written FFI.
-- **`ge diff`** — differential testing. Runs the same program through CPython
-  and every installed backend, comparing output byte-for-byte.
-- **`ge golden`** — golden lowering corpus. Emitted code must match the
-  committed golden, and compiling it must still print the expected output.
-- **`ge api-check`** — committed dumps of the CLI, diagnostics, and intrinsic
-  surfaces. Drift fails the check.
-- **`ge doctor`** — runtime and toolchain check with per-platform install
-  hints. `--json` for CI.
-- **`ge react`** — generates a React 19 + TypeScript + Vite project from a
-  `.ge.ui` file, one component per file.
-- **Organized build output** — `build/{desktop,web,mobile}/{backend,obj,bin}`.
-- **npm distribution** — `npx gelang` runs the compiler with bundled source,
-  no `pip install` required.
-- **`--target` buckets** — `desktop`, `web`, `mobile`.
-- **Target-keyword safety** — identifiers that collide with a target
-  language's reserved words are escaped (`@base` in C#, `r#match` in Rust)
-  or renamed consistently across the ABI (`double` → `double_`).
-
-### Fixed
-
-- C# reserved words in parameter positions emitted invalid code (`base`).
-- Function names colliding with target keywords broke compilation
-  (`double` in C++, `match` in Rust).
-- `from pyeffic.backends import rust` was resolved as user code, pulling the
-  compiler's own sources into the program.
-- `ge_build`/`build_flutter` used an undefined `preamble` variable.
-- Go backend wrote binaries next to the source instead of `build/<target>/bin`.
-- Module resolver matched a sibling file for dotted imports
-  (`app.main` resolved to `desktop/main.ge`).
-- `.ge.ui` parser rejected files with a leading docstring.
-- `.ge.ui` parser only accepted `Screen "title" {}`, not `Window { title: }`.
-
-### Changed
-
-- Canonical extension is `.ge`. `.ge.py` and `.ge.ts` remain supported for
-  single-flavour files; `.ts.ge.py` is accepted as a legacy alias.
-- Build root defaults to `build/` (was `ge_build/`).
-- Package name on npm is `gelang`.
 
 ## [0.1.0] — 2026-09-12
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gelang",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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/emitters/base.py

@@ -63,6 +63,15 @@ class Spec:
     # 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
@@ -100,6 +109,8 @@ class Spec:
     # 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()"
@@ -230,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":
@@ -1216,7 +1231,10 @@ class Emitter:
             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":
                 lt = self.spec.list_type.format(T=elem)
                 return f"new {lt}{{{elems}}}"
@@ -1247,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)
@@ -1277,8 +1304,16 @@ class Emitter:
             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)")
+                # 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)
@@ -1362,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])
@@ -1738,6 +1777,8 @@ 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":
@@ -1750,6 +1791,8 @@ 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":
@@ -1764,10 +1807,10 @@ class Emitter:
                 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 == "cpp":
-                        return f"geStrReplace({base}, {a}, {b})"
                     if self.spec.name == "csharp":
                         return f"{base}.Replace({a}, {b})"
                     if self.spec.name == "go":
@@ -1784,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
@@ -1802,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)
@@ -2153,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>(); "
@@ -2525,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,7 +12,12 @@ 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})",

package/python/pyeffic/emitters/csharp.py

@@ -17,7 +17,12 @@ SPEC = Spec(
     list_type="List<{T}>",
     list_param_type="List<long>",
     list_elem_type="long",
+    list_sort="{x}.Sort()",
+    list_reverse="{x}.Reverse()",
     str_split="{x}.Split({sep}).ToList()",
+    str_upper="{x}.ToUpper()",
+    str_lower="{x}.ToLower()",
+    str_replace="{x}.Replace({a}, {b})",
     str_join="string.Join({sep}, {x})",
     list_slice="{x}.GetRange((int)({start}), (int)(({stop}) - ({start})))",
     list_copy="new List<long>({x})",
@@ -26,6 +31,10 @@ SPEC = Spec(
     range_step_call="({lo}..{hi}).Step({step})",
     len_call="{x}.Length",
     list_len="{x}.Count",
+    # Dictionary and HashSet expose Count, not Length; len()
+    # fell back to len_call and emitted an invalid member.
+    dict_len="{x}.Count",
+    set_len="{x}.Count",
     print_int='Console.WriteLine({v})',
     print_float='Console.WriteLine({v})',
     print_str='Console.WriteLine({v})',

package/python/pyeffic/emitters/go.py

@@ -16,7 +16,12 @@ SPEC = Spec(
     list_type="[]{T}",
     list_param_type="[]int64",
     list_elem_type="int64",
+    list_sort="sort.Slice({x}, func(i, j int) bool {{ return {x}[i] < {x}[j] }})",
+    list_reverse="sort.Slice({x}, func(i, j int) bool {{ return i > j }})",
     str_split="strings.Split({x}, {sep})",
+    str_upper="strings.ToUpper({x})",
+    str_lower="strings.ToLower({x})",
+    str_replace="strings.ReplaceAll({x}, {a}, {b})",
     str_join="strings.Join({x}, {sep})",
     list_slice="append([]int64(nil), {x}[{start}:{stop}]...)",
     list_copy="append([]int64(nil), {x}...)",
@@ -31,7 +36,9 @@ SPEC = Spec(
     print_bool='fmt.Println(geBoolStr({v}))',
     print_generic='fmt.Println({v})',
     print_list='fmt.Println(geListStr({v}))',
-    int_cast="int64({x})",
+    # Go rejects int64(3.9) for an untyped constant; math.Trunc works
+    # for both constants and variables and matches Python int().
+    int_cast="int64(math.Trunc({x}))",
     float_cast="float64({x})",
     float_div="(float64({l}) / float64({r}))",
     floor_div="({l} / {r})",

package/python/pyeffic/emitters/kotlin.py

@@ -17,7 +17,12 @@ SPEC = Spec(
     list_type="MutableList<{T}>",
     list_param_type="MutableList<Long>",
     list_elem_type="Long",
+    list_sort="{x}.sort()",
+    list_reverse="{x}.reverse()",
     str_split="{x}.split({sep}).toMutableList()",
+    str_upper="{x}.uppercase()",
+    str_lower="{x}.lowercase()",
+    str_replace="{x}.replace({a}, {b})",
     str_join="{x}.joinToString({sep})",
     list_slice="{x}.subList(({start}).toInt(), ({stop}).toInt()).toMutableList()",
     list_copy="{x}.toMutableList()",

package/python/pyeffic/emitters/rust.py

@@ -12,7 +12,12 @@ SPEC = Spec(
     list_type="Vec<{T}>",
     list_param_type="&[i64]",
     list_elem_type="i64",
+    list_sort="{x}.sort()",
+    list_reverse="{x}.reverse()",
     str_split="{x}.split({sep}.as_str()).map(|s| s.to_string()).collect::<Vec<String>>()",
+    str_upper="{x}.to_uppercase()",
+    str_lower="{x}.to_lowercase()",
+    str_replace="{x}.replace({a}.as_str(), {b}.as_str())",
     str_join="{x}.join({sep}.as_str())",
     list_slice="{x}[({start}) as usize..({stop}) as usize].to_vec()",
     list_copy="{x}.clone()",
@@ -57,7 +62,9 @@ SPEC = Spec(
     str_slice_end="{x}[..{end}].to_string()",
     list_concat="{{ let mut t = {l}; t.extend({r}.iter()); t }}",
     condition_parens=False,
-    foreach_template="for {var} in {iter}.iter()",
+    # .cloned() so the loop variable is owned: iterating a &[i64]
+    # otherwise yields &i64 and `x == 5` does not compile.
+    foreach_template="for {var} in {iter}.iter().cloned()",
     try_template="// try/except not natively supported in Rust\n// {body}\n// {handler}",
     struct_template="#[derive(Clone)]\nstruct {name} {{\n{fields}\n}}",
     struct_field_template="    {type}: {name},",

package/python/pyeffic/emitters/zig.py

@@ -13,40 +13,40 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="zig",
     types={"int": "i64", "float": "f64", "bool": "bool", "str": "[]const u8", "None": "void"},
-    list_type="[]const {T}",
-    list_param_type="[]const i64",
+    list_type="std.ArrayList({T})",
+    list_param_type="*std.ArrayList(i64)",
     list_elem_type="i64",
-    list_slice="{x}[@intCast({start})..@intCast({stop})]",
-    list_copy="{x}",
+    list_slice="geListSlice(i64, {x}.items, @as(usize, @intCast({start})), @as(usize, @intCast({stop})))",
+    list_copy="geListCopy(i64, {x}.items)",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi})",
-    len_call="@as(i64, @intCast({x}.len))",
-    list_len="@as(i64, @intCast({x}.len))",
+    len_call="@as(i64, @intCast({x}.items.len))",
+    list_len="@as(i64, @intCast({x}.items.len))",
     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("{{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})',
+    list_sort="std.mem.sort(i64, {x}.items, {{}}, std.sort.asc(i64))",
+    list_reverse="std.mem.reverse(i64, {x}.items)",
+    print_list='gePrintList({v}.items)',
     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; }}",
+    sum_call="blk: {{ var s: i64 = 0; for ({it}.items) |v| {{ s += v; }} break :blk s; }}",
     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}...)",
+    min_call="blk: {{ var __m = {it}.items[0]; for ({it}.items) |v| {{ if (v < __m) __m = v; }} break :blk __m; }}",
+    max_call="blk: {{ var __m = {it}.items[0]; for ({it}.items) |v| {{ if (v > __m) __m = v; }} break :blk __m; }}",
     pow_call="std.math.pow(i64, {l}, {r})",
     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}))]",
+    append_call="{x}.append({v}) catch unreachable",
+    index_call="{x}.items[@as(usize, @intCast({i}))]",
     comment="//",
     fn_template="{sig} {{\n{body}\n}}",
     main_template="",
@@ -59,16 +59,24 @@ SPEC = Spec(
     str_slice="{x}[{start}..{end}]",
     str_slice_start="{x}[{start}..]",
     str_slice_end="{x}[..{end}]",
-    list_concat="blk: {{ var t = std.ArrayList(i64).init(std.heap.page_allocator); t.appendSlice({l}) catch unreachable; t.appendSlice({r}) catch unreachable; break :blk t.toOwnedSlice() catch unreachable; }}",
-    foreach_template="for ({iter}) |{var}|",
+    list_concat="geListConcat(i64, {l}.items, {r}.items)",
+    str_split="geStrSplit({x}, {sep})",
+    str_join="geStrJoin({x}.items, {sep})",
+    str_upper="geStrUpper({x})",
+    str_lower="geStrLower({x})",
+    str_replace="geStrReplace({x}, {a}, {b})",
+    foreach_template="for ({iter}.items) |{var}|",
     try_template="// try/except limited in Zig\n// {body}\n// {handler}",
     struct_template="const {name} = struct {{\n{fields}\n}};",
     struct_field_template="    {type}: {name},",
     struct_new_template="fn {name}_new({params}) {name} {{\n{body}\n}}",
     dict_type="std.StringHashMap({V})",
+    set_type="std.AutoHashMap(i64, void)",
     dict_get="{d}.get({k}).?",
     dict_set="{d}.put({k}, {v}) catch unreachable",
     dict_contains="{d}.contains({k})",
+    set_len="@as(i64, @intCast({x}.count()))",
+    dict_len="@as(i64, @intCast({x}.count()))",
     tuple_type="[2]{T}",
     tuple_get="{t}[{i}]",
 )
@@ -121,69 +129,49 @@ class ZigEmitter(Emitter):
             elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
                 if node.func.attr == "append" and isinstance(node.func.value, ast.Name):
                     mutated.add(node.func.value.id)
+            elif isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+                # passing a list to a callee that mutates it counts as a
+                # mutation here, so the local must be `var`
+                for idx in self.func_mutated_params.get(node.func.id, ()):
+                    if idx < len(node.args):
+                        arg = node.args[idx]
+                        if isinstance(arg, ast.Name):
+                            mutated.add(arg.id)
         return mutated
 
     def emit(self, unit: FuncUnit) -> str:
-        """Override emit to track mutated variables and make mutable param copies."""
+        """Emit a function.
+
+        A list parameter is a `*std.ArrayList(i64)`, so no conversion is
+        needed: the callee mutates the caller's list directly. Only scalar
+        parameters that are reassigned need a mutable local, because Zig
+        parameters are immutable.
+        """
         self.mutated = self._find_mutated_vars(unit.body)
-        # Detect mutated list parameters (append, subscript assign, etc.)
-        self.mutated_list_params: set[str] = set()
-        for pname, ptype in unit.params:
-            if ptype == "list" and pname in self.mutated:
-                self.mutated_list_params.add(pname)
-        # Zig parameters are const — make mutable copies for any scalar param that's mutated
-        # List params that are mutated need ArrayList conversion
-        mutated_params = []
-        for pname, ptype in unit.params:
-            if pname in self.mutated and ptype != "list":
-                mutated_params.append(pname)
-        # We'll insert mutable copies as the first lines of the body
-        self._zig_mut_copies = mutated_params
-        self._zig_list_conversions = list(self.mutated_list_params)
+        self.mutated_list_params = {
+            pname for pname, ptype in unit.params
+            if ptype == "list" and pname in self.mutated
+        }
+        self.mutated_params = {
+            pname for pname, ptype in unit.params
+            if pname in self.mutated and ptype != "list"
+        }
         result = super().emit(unit)
-        if mutated_params or self.mutated_list_params:
-            # Insert mutable copies and list conversions right after the opening brace
+        if self.mutated_params:
             lines = result.split("\n")
-            insert_lines = []
-            for pname in mutated_params:
-                insert_lines.append(f"    var {pname}_ = {pname};")
-            for pname in self.mutated_list_params:
-                # Convert []const i64 to ArrayList for mutation
-                insert_lines.append(f"    var {pname}_list = std.ArrayList(i64).init(std.heap.page_allocator);")
-                insert_lines.append(f"    for ({pname}) |item| {{ {pname}_list.append(item) catch unreachable; }}")
+            insert = [f"    var {p}_ = {p};" for p in sorted(self.mutated_params)]
             for i, line in enumerate(lines):
-                if "{" in line and "fn" in lines[i]:
-                    for j, il in enumerate(insert_lines):
+                if "fn" in line and "{" in line:
+                    for j, il in enumerate(insert):
                         lines.insert(i + 1 + j, il)
                     break
             result = "\n".join(lines)
-            # Replace param references with mutable version
             import re
-            for pname in mutated_params:
-                old = result
-                result = re.sub(r'\b' + pname + r'\b', pname + "_", result)
-                result = re.sub(r'\b' + pname + r'_: ', pname + ': ', result, count=1)
-                result = result.replace(f"var {pname}_ = {pname}_;", f"var {pname}_ = {pname};")
-            # Replace list param references with ArrayList.items where indexing, or the list itself for append
-            for pname in self.mutated_list_params:
-                # Replace append calls: pname.append(v) -> pname_list.append(v)
-                result = re.sub(
-                    r'\b' + pname + r'\.append\(',
-                    pname + '_list.append(',
-                    result
-                )
-                # Replace indexing: pname[i] -> pname_list.items[i]
-                result = re.sub(
-                    r'\b' + pname + r'\[',
-                    pname + '_list.items[',
-                    result
-                )
-                # Replace len(pname) -> pname_list.items.len
-                result = re.sub(
-                    r'\b' + pname + r'\.len\b',
-                    pname + '_list.items.len',
-                    result
-                )
+            for pname in self.mutated_params:
+                result = re.sub(r"\b" + pname + r"\b", pname + "_", result)
+                result = re.sub(r"\b" + pname + r"_: ", pname + ": ", result, count=1)
+                result = result.replace(f"var {pname}_ = {pname}_;",
+                                        f"var {pname}_ = {pname};")
         return result
 
     def _is_mutated(self, var: str) -> bool:
@@ -210,6 +198,12 @@ class ZigEmitter(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 `"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)
             kw = self._decl_keyword(target)
             self.lines.append(f"{ind}{kw} {target}: {nt} = {self.expr(node.value)};")
             return
@@ -263,7 +257,7 @@ class ZigEmitter(Emitter):
                 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.lines.append(f"{ind}for ({iter_s}.items) |{var}| {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -274,7 +268,7 @@ class ZigEmitter(Emitter):
         emit_name = unit.name.replace(".", "_")
         params = []
         for pname, ptype in unit.params:
-            nt = self.param_native_type(ptype)
+            nt = self.param_native_type(ptype, pname)
             params.append(f"{pname}: {nt}")
         ret = self.py_to_native(unit.ret_type) if unit.ret_type != "None" else "void"
         param_str = ", ".join(params)
@@ -321,6 +315,23 @@ def _emit_structs_zig(classes: list) -> str:
     return "\n".join(out)
 
 
+def _precompute_mutated_params(emitter, units) -> None:
+    """Record which parameters each function mutates.
+
+    The emitter normally learns this as it emits each unit, so a function
+    defined after its caller would not be known yet. Doing it up front makes
+    call-site handling independent of definition order.
+    """
+    for u in units:
+        if u.body is None:
+            continue
+        mutated = emitter._find_mutated_vars(u.body.body)
+        indices = {i for i, (pname, _pt) in enumerate(u.params)
+                   if pname in mutated}
+        if indices:
+            emitter.func_mutated_params[u.name] = indices
+
+
 def emit_zig(units: list[FuncUnit], entry: str | None,
              library_mode: bool = False,
              extern_fns: list[FuncUnit] | None = None,
@@ -340,6 +351,7 @@ def emit_zig(units: list[FuncUnit], entry: str | None,
     }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
+    _precompute_mutated_params(emitter, units)
     emitted: dict[str, str] = {}
     fns: list[str] = []
 
@@ -411,9 +423,13 @@ def emit_zig(units: list[FuncUnit], entry: str | None,
 
     if entry_u.name != "main":
         if entry_u.ret_type == "None":
-            wrapper = "pub fn main() void {\n    " + entry_u.name + "();\n}\n"
+            wrapper = ("pub fn main() void {\n"
+                       "    defer _ = ge_arena.deinit();\n"
+                       "    " + entry_u.name + "();\n}\n")
         else:
-            wrapper = f"pub fn main() void {{\n    _ = {entry_u.name}();\n}}\n"
+            wrapper = (f"pub fn main() void {{\n"
+                       f"    defer _ = ge_arena.deinit();\n"
+                       f"    _ = {entry_u.name}();\n}}\n")
         fns.append(wrapper)
     elif not fns:
         # the entry function was rejected during emission; the pipeline
@@ -421,13 +437,19 @@ def emit_zig(units: list[FuncUnit], entry: str | None,
         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
+        # Rename the user's main() to __ge_main() and add a wrapper that also
+        # releases the arena.
         if entry_u.ret_type != "None":
             fns[-1] = fns[-1].replace(f"fn {entry_u.name}(", "fn __ge_main(")
-            wrapper = "pub fn main() void {\n    _ = __ge_main();\n}\n"
-            fns.append(wrapper)
+            wrapper = ("pub fn main() void {\n"
+                       "    defer _ = ge_arena.deinit();\n"
+                       "    _ = __ge_main();\n}\n")
         else:
-            fns[-1] = fns[-1].replace(f"fn {entry_u.name}(", "pub fn main(")
+            fns[-1] = fns[-1].replace(f"fn {entry_u.name}(", "fn __ge_main(")
+            wrapper = ("pub fn main() void {\n"
+                       "    defer _ = ge_arena.deinit();\n"
+                       "    __ge_main();\n}\n")
+        fns.append(wrapper)
 
     program = prelude + "\n".join(fns) + "\n"
     # inject stdlib runtime

package/python/pyeffic/ge_cli.py

@@ -211,11 +211,27 @@ def cmd_analyze(args) -> int:
         return 1
 
     source = source_path.read_text(encoding="utf-8")
+    original_source = source
     entry = args.entry or "main"
 
+    # Lower non-Python flavours (.ge hybrid, .ge.ts) before analysis, exactly
+    # as build() does. Without this, `ge analyze` parses a hybrid file as
+    # plain Python and reports a syntax error on the first block tag.
+    # resolve_imports lowers internally, so it gets the original source.
+    from .frontends import frontend_for
+    from .frontends.typescript import TypeScriptSyntaxError
+    from .modules import _lower_source
+
+    if frontend_for(source_path) != "python":
+        try:
+            source = _lower_source(source, source_path)
+        except TypeScriptSyntaxError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+
     # Resolve imports first
     try:
-        units, classes, warnings = resolve_imports(source, source_path)
+        units, classes, warnings = resolve_imports(original_source, source_path)
         for w in warnings:
             print(f"  warning: {w}")
     except Exception as e:
@@ -411,8 +427,96 @@ def _print_flutter(report) -> None:
         print(f"  ! {e}")
 
 
+def _ui_node_to_tree(node) -> dict:
+    """Convert a .ge.ui WidgetNode into the dict dartgen.generate_main wants."""
+    if node is None:
+        return {"kind": "Column", "children": [], "align": "center"}
+    d: dict = {"kind": node.kind}
+    if node.children:
+        d["children"] = [_ui_node_to_tree(c) for c in node.children]
+    child = node.props.get("child")
+    if child is not None and hasattr(child, "kind"):
+        d["child"] = _ui_node_to_tree(child)
+    if node.text is not None:
+        d["text"] = node.text
+    elif "text" in node.props:
+        d["text"] = node.props["text"]
+    if node.label is not None:
+        d["label"] = node.label
+    elif "label" in node.props:
+        d["label"] = node.props["label"]
+    if node.state:
+        d["state"] = node.state
+    style = node.props.get("style") or node.style_dict.get("style")
+    if style:
+        d["style"] = style
+    for key in ("align", "padding", "color", "hint"):
+        if key in node.props:
+            d[key] = node.props[key]
+    if node.action:
+        d["action"] = node.action
+    return d
+
+
+def _flutter_from_ui(args, ui_path: Path) -> int:
+    """`ge flutter foo.ge.ui` — generate a Flutter project from the UI DSL."""
+    from .ui_dsl import parse_ui_file
+    from .dartgen import generate_main, generate_pubspec
+    from .config import Config
+
+    try:
+        screen = parse_ui_file(ui_path)
+    except SyntaxError as e:
+        print(f"error: invalid .ge.ui — {e}", file=sys.stderr)
+        return 1
+
+    app_name = args.app_name or ui_path.stem
+    cfg = Config(out_dir=Path(args.out_dir), target="mobile")
+    project_dir = cfg.target_dir / app_name
+    lib_dir = project_dir / "lib"
+    lib_dir.mkdir(parents=True, exist_ok=True)
+
+    tree = _ui_node_to_tree(screen.root)
+    title = screen.title or app_name
+    main_dart = generate_main(tree, [], app_title=title)
+
+    (lib_dir / "main.dart").write_text(main_dart, encoding="utf-8")
+    # generate_main always imports bindings.dart; a UI-only project has no
+    # FFI exports, so emit the stub rather than leaving a dangling import.
+    from .dartgen import generate_bindings
+    (lib_dir / "bindings.dart").write_text(
+        generate_bindings([], app_name), encoding="utf-8")
+    (project_dir / "pubspec.yaml").write_text(
+        generate_pubspec(app_name), encoding="utf-8")
+
+    print(GE_BANNER)
+    print()
+    print(f"== GE flutter app: {project_dir} ==")
+    print(f"Title       : {title}")
+    print(f"Dart files  : {lib_dir / 'main.dart'}")
+    print(f"\nNext: cd {project_dir} && flutter pub get && flutter run")
+
+    dart = _find_dart()
+    if dart:
+        r = subprocess.run([dart, "analyze", str(lib_dir)],
+                           capture_output=True, text=True, timeout=120)
+        out = ((r.stdout or "") + (r.stderr or "")).strip()
+        print(out[:1200] if out else "(analyzer: no output)")
+        print("Dart analysis: " + ("PASS" if r.returncode == 0 else "issues found"))
+    else:
+        print("\n(dart not found — install Flutter to validate generated Dart)")
+    return 0
+
+
 def cmd_flutter(args) -> int:
-    source = _maybe_transpile_ts(Path(args.file))
+    src_path = Path(args.file)
+    # A .ge.ui file is a UI definition, not GE source. `ge flutter` used to
+    # hand it to the module resolver, which tried to parse `Window {` as
+    # Python and failed. Generate the Dart UI directly instead.
+    if src_path.suffix == ".ui":
+        return _flutter_from_ui(args, src_path)
+
+    source = _maybe_transpile_ts(src_path)
     # a Flutter app is a mobile artifact, so it always lands in build/mobile/
     cfg = Config(out_dir=Path(args.out_dir), target="mobile",
                  force_backend=None if args.backend == "auto" else args.backend,
@@ -502,12 +606,14 @@ def cmd_react(args) -> int:
         return 1
 
     app_name = args.app_name or ui_path.stem.replace(".ge", "")
-    # default: sibling web/frontend next to the ui/ directory
+    # Output goes under the target-aware build root so every artifact of a
+    # project lives in one place: build/web/frontend. An explicit -o wins.
     if args.out_dir:
         out_dir = Path(args.out_dir)
     else:
-        base = ui_path.parent.parent if ui_path.parent.name == "ui" else ui_path.parent
-        out_dir = base / "web" / "frontend"
+        from .config import Config
+        cfg = Config(target="web")
+        out_dir = cfg.target_dir / "frontend"
 
     files = generate_react_app(screen, app_name)
     written = write_react_app(files, out_dir, force=args.force)

package/python/pyeffic/stdlib.py

@@ -298,17 +298,125 @@ fun ge_log(x: Double): Double = ln(x)
 fun ge_exp(x: Double): Double = exp(x)
 ''',
     "zig": '''
-// GE Math runtime (Zig)
-fn gePrintList(v: []const i64) void {
+// GE runtime (Zig)
+//
+// GE lists are growable, so they need an allocator. A generated program
+// runs start-to-finish, so a single arena is the right fit: it amortises
+// the page-grain cost across many small lists and everything is released
+// in one call. (std.heap.page_allocator alone would issue a syscall per
+// allocation, and GeneralPurposeAllocator is a debugging allocator.)
+var ge_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+const ge_alloc = ge_arena.allocator();
+
+fn geListNew(comptime T: type) std.ArrayList(T) {
+    return std.ArrayList(T).init(ge_alloc);
+}
+
+fn geListFrom(comptime T: type, items: []const T) std.ArrayList(T) {
+    var l = std.ArrayList(T).init(ge_alloc);
+    l.appendSlice(items) catch unreachable;
+    return l;
+}
+
+fn geListCopy(comptime T: type, src: []const T) std.ArrayList(T) {
+    return geListFrom(T, src);
+}
+
+fn geListSlice(comptime T: type, src: []const T, lo: usize, hi: usize) std.ArrayList(T) {
+    var l = std.ArrayList(T).init(ge_alloc);
+    l.appendSlice(src[lo..hi]) catch unreachable;
+    return l;
+}
+
+fn geListConcat(comptime T: type, a: []const T, b: []const T) std.ArrayList(T) {
+    var l = std.ArrayList(T).init(ge_alloc);
+    l.appendSlice(a) catch unreachable;
+    l.appendSlice(b) catch unreachable;
+    return l;
+}
+
+// Python renders a sequence as [1, 2, 3] and quotes strings with '.
+fn gePrintList(v: anytype) 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;
+        switch (@typeInfo(@TypeOf(x))) {
+            .pointer => w.print("'{s}'", .{x}) catch unreachable,
+            .float => w.print("{d}", .{x}) catch unreachable,
+            .bool => w.print("{s}", .{if (x) "True" else "False"}) catch unreachable,
+            else => w.print("{d}", .{x}) catch unreachable,
+        }
     }
     w.print("]\\n", .{}) catch unreachable;
 }
 
+fn geSetNew(comptime T: type) std.AutoHashMap(T, void) {
+    return std.AutoHashMap(T, void).init(ge_alloc);
+}
+
+fn geSetFrom(comptime T: type, items: []const T) std.AutoHashMap(T, void) {
+    var s = std.AutoHashMap(T, void).init(ge_alloc);
+    for (items) |x| s.put(x, {{}}) catch unreachable;
+    return s;
+}
+fn geStrSplit(s: []const u8, sep: []const u8) std.ArrayList([]const u8) {
+    var l = std.ArrayList([]const u8).init(ge_alloc);
+    if (sep.len == 0) {
+        l.append(s) catch unreachable;
+        return l;
+    }
+    var it = std.mem.splitSequence(u8, s, sep);
+    while (it.next()) |part| l.append(part) catch unreachable;
+    return l;
+}
+
+fn geStrJoin(parts: []const []const u8, sep: []const u8) []const u8 {
+    var total: usize = 0;
+    for (parts, 0..) |p, i| {
+        total += p.len;
+        if (i > 0) total += sep.len;
+    }
+    const buf = ge_alloc.alloc(u8, total) catch unreachable;
+    var pos: usize = 0;
+    for (parts, 0..) |p, i| {
+        if (i > 0) {
+            @memcpy(buf[pos..][0..sep.len], sep);
+            pos += sep.len;
+        }
+        @memcpy(buf[pos..][0..p.len], p);
+        pos += p.len;
+    }
+    return buf;
+}
+
+fn geStrReplace(s: []const u8, from: []const u8, to: []const u8) []const u8 {
+    if (from.len == 0) return s;
+    var out = std.ArrayList(u8).init(ge_alloc);
+    var i: usize = 0;
+    while (i < s.len) {
+        if (i + from.len <= s.len and std.mem.eql(u8, s[i..][0..from.len], from)) {
+            out.appendSlice(to) catch unreachable;
+            i += from.len;
+        } else {
+            out.append(s[i]) catch unreachable;
+            i += 1;
+        }
+    }
+    return out.items;
+}
+
+fn geStrUpper(s: []const u8) []const u8 {
+    const buf = ge_alloc.alloc(u8, s.len) catch unreachable;
+    for (s, 0..) |c, i| buf[i] = std.ascii.toUpper(c);
+    return buf;
+}
+
+fn geStrLower(s: []const u8) []const u8 {
+    const buf = ge_alloc.alloc(u8, s.len) catch unreachable;
+    for (s, 0..) |c, i| buf[i] = std.ascii.toLower(c);
+    return buf;
+}
 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); }