gelang 0.1.0

package/python/pyeffic/stdlib.py

@@ -0,0 +1,246 @@
+"""GE Standard Library
+
+This module provides GE runtime helper functions that are emitted as
+backend-specific runtime code. These are NOT Python functions — they are
+templates that get inlined into the generated native code.
+
+Available categories:
+  - file I/O: open, read, write, close
+  - JSON: parse, stringify
+  - string: upper, lower, strip, contains, split, join
+  - math: sqrt, sin, cos, tan, log, exp, floor, ceil, round
+
+Each function maps to backend-specific runtime code emitted by the
+backend's Spec or emitter.
+"""
+from __future__ import annotations
+
+# File I/O runtime templates per backend
+FILE_IO_RUNTIME = {
+    "rust": '''
+// GE File I/O runtime (Rust)
+use std::io::{Read, Write};
+
+fn ge_read_file(path: &str) -> String {
+    std::fs::read_to_string(path).unwrap_or_default()
+}
+
+fn ge_write_file(path: &str, content: &str) -> bool {
+    std::fs::write(path, content).is_ok()
+}
+
+fn ge_append_file(path: &str, content: &str) -> bool {
+    use std::io::Write;
+    let mut f = std::fs::OpenOptions::new()
+        .append(true)
+        .create(true)
+        .open(path);
+    match f {
+        Ok(mut f) => f.write_all(content.as_bytes()).is_ok(),
+        Err(_) => false,
+    }
+}
+''',
+    "cpp": '''
+// GE File I/O runtime (C++)
+#include <fstream>
+#include <sstream>
+
+std::string ge_read_file(const std::string& path) {
+    std::ifstream f(path);
+    std::stringstream ss;
+    ss << f.rdbuf();
+    return ss.str();
+}
+
+bool ge_write_file(const std::string& path, const std::string& content) {
+    std::ofstream f(path);
+    if (!f) return false;
+    f << content;
+    return true;
+}
+
+bool ge_append_file(const std::string& path, const std::string& content) {
+    std::ofstream f(path, std::ios::app);
+    if (!f) return false;
+    f << content;
+    return true;
+}
+''',
+    "csharp": '''
+// GE File I/O runtime (C#)
+static string GeReadFile(string path) {
+    return System.IO.File.ReadAllText(path);
+}
+
+static bool GeWriteFile(string path, string content) {
+    try { System.IO.File.WriteAllText(path, content); return true; }
+    catch { return false; }
+}
+
+static bool GeAppendFile(string path, string content) {
+    try { System.IO.File.AppendAllText(path, content); return true; }
+    catch { return false; }
+}
+''',
+    "go": '''
+// GE File I/O runtime (Go)
+func geReadFile(path string) string {
+    data, err := os.ReadFile(path)
+    if err != nil { return "" }
+    return string(data)
+}
+
+func geWriteFile(path string, content string) bool {
+    return os.WriteFile(path, []byte(content), 0644) == nil
+}
+
+func geAppendFile(path string, content string) bool {
+    f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+    if err != nil { return false }
+    defer f.Close()
+    _, err = f.WriteString(content)
+    return err == nil
+}
+''',
+    "kotlin": '''
+// GE File I/O runtime (Kotlin) — file I/O requires JDK
+// geReadFile/geWriteFile/geAppendFile omitted (JDK not in default classpath)
+''',
+    "zig": '''
+// GE File I/O runtime (Zig)
+fn ge_read_file(path: []const u8) []const u8 {
+    const file = std.fs.cwd().openFile(path, .{}) catch return "";
+    defer file.close();
+    const stat = file.stat() catch return "";
+    const buf = std.heap.page_allocator.alloc(u8, stat.size) catch return "";
+    _ = file.read(buf) catch return "";
+    return buf;
+}
+
+fn ge_write_file(path: []const u8, content: []const u8) bool {
+    const file = std.fs.cwd.createFile(path, .{}) catch return false;
+    defer file.close();
+    _ = file.write(content) catch return false;
+    return true;
+}
+
+fn ge_append_file(path: []const u8, content: []const u8) bool {
+    const file = std.fs.cwd.openFile(path, .{ .mode = .write_only }) catch {
+        const f2 = std.fs.cwd.createFile(path, .{}) catch return false;
+        defer f2.close();
+        _ = f2.write(content) catch return false;
+        return true;
+    };
+    defer file.close();
+    file.seekFromEnd(0) catch return false;
+    _ = file.write(content) catch return false;
+    return true;
+}
+''',
+}
+
+# Math runtime templates per backend
+MATH_RUNTIME = {
+    "rust": '''
+// GE Math runtime (Rust)
+fn ge_sqrt(x: f64) -> f64 { x.sqrt() }
+fn ge_floor(x: f64) -> f64 { x.floor() }
+fn ge_ceil(x: f64) -> f64 { x.ceil() }
+fn ge_round(x: f64) -> f64 { x.round() }
+fn ge_sin(x: f64) -> f64 { x.sin() }
+fn ge_cos(x: f64) -> f64 { x.cos() }
+fn ge_tan(x: f64) -> f64 { x.tan() }
+fn ge_log(x: f64) -> f64 { x.ln() }
+fn ge_exp(x: f64) -> f64 { x.exp() }
+''',
+    "cpp": '''
+// GE Math runtime (C++)
+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); }
+double ge_round(double x) { return std::round(x); }
+double ge_sin(double x) { return std::sin(x); }
+double ge_cos(double x) { return std::cos(x); }
+double ge_tan(double x) { return std::tan(x); }
+double ge_log(double x) { return std::log(x); }
+double ge_exp(double x) { return std::exp(x); }
+''',
+    "csharp": '''
+// GE Math runtime (C#)
+static double GeSqrt(double x) { return System.Math.Sqrt(x); }
+static double GeFloor(double x) { return System.Math.Floor(x); }
+static double GeCeil(double x) { return System.Math.Ceiling(x); }
+static double GeRound(double x) { return System.Math.Round(x); }
+static double GeSin(double x) { return System.Math.Sin(x); }
+static double GeCos(double x) { return System.Math.Cos(x); }
+static double GeTan(double x) { return System.Math.Tan(x); }
+static double GeLog(double x) { return System.Math.Log(x); }
+static double GeExp(double x) { return System.Math.Exp(x); }
+''',
+    "go": '''
+// GE Math runtime (Go)
+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) }
+func geRound(x float64) float64 { return math.Round(x) }
+func geSin(x float64) float64 { return math.Sin(x) }
+func geCos(x float64) float64 { return math.Cos(x) }
+func geTan(x float64) float64 { return math.Tan(x) }
+func geLog(x float64) float64 { return math.Log(x) }
+func geExp(x float64) float64 { return math.Exp(x) }
+''',
+    "kotlin": '''
+// GE Math runtime (Kotlin)
+import kotlin.math.*
+fun ge_sqrt(x: Double): Double = sqrt(x)
+fun ge_floor(x: Double): Double = floor(x)
+fun ge_ceil(x: Double): Double = ceil(x)
+fun ge_round(x: Double): Double = round(x)
+fun ge_sin(x: Double): Double = sin(x)
+fun ge_cos(x: Double): Double = cos(x)
+fun ge_tan(x: Double): Double = tan(x)
+fun ge_log(x: Double): Double = ln(x)
+fun ge_exp(x: Double): Double = exp(x)
+''',
+    "zig": '''
+// GE Math runtime (Zig)
+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); }
+fn ge_round(x: f64) f64 { return @round(x); }
+fn ge_sin(x: f64) f64 { return std.math.sin(x); }
+fn ge_cos(x: f64) f64 { return std.math.cos(x); }
+fn ge_tan(x: f64) f64 { return std.math.tan(x); }
+fn ge_log(x: f64) f64 { return @log(x); }
+fn ge_exp(x: f64) f64 { return @exp(x); }
+''',
+}
+
+
+def get_runtime(backend: str, include_math: bool = True) -> str:
+    """Get the standard library runtime code for a backend.
+
+    Args:
+        backend: one of rust, cpp, csharp, zig, go, kotlin
+        include_math: whether to include math functions
+
+    Returns:
+        Backend-specific runtime code as a string.
+    """
+    parts = []
+    if backend in FILE_IO_RUNTIME:
+        parts.append(FILE_IO_RUNTIME[backend])
+    if include_math and backend in MATH_RUNTIME:
+        parts.append(MATH_RUNTIME[backend])
+    return "\n".join(parts)
+
+
+def get_file_io_runtime(backend: str) -> str:
+    """Get just the file I/O runtime for a backend."""
+    return FILE_IO_RUNTIME.get(backend, "")
+
+
+def get_math_runtime(backend: str) -> str:
+    """Get just the math runtime for a backend."""
+    return MATH_RUNTIME.get(backend, "")

package/python/pyeffic/styling.py

@@ -0,0 +1,220 @@
+"""GE styling: a CSS-like style DSL that emits to multiple native targets.
+
+One syntax, many backends. Write:
+    style="fontSize:20; bold:true; color:#2196F3; padding:16; radius:12"
+
+The parser turns it into a target-agnostic dict:
+    {"fontSize": 20, "bold": True, "color": "#2196F3", "padding": 16, "radius": 12}
+
+Emitters then convert that dict to target-native code:
+  - style_to_flutter() -> TextStyle / EdgeInsets / BoxDecoration / Color
+  - style_to_slint()   -> Slint property blocks (Rust/C++ GUI)  [stub for later]
+
+This is the same pattern Slint (HTML/CSS-like DSL for Rust) and Wind (Tailwind
+for Flutter) use, but unified under GE's single-source model.
+"""
+from __future__ import annotations
+
+import re
+
+# ---- named style shortcuts (backward-compatible with the old style="headline") ----
+NAMED_STYLES: dict[str, str] = {
+    "headline":  "fontSize:28; bold:true",
+    "title":     "fontSize:20; bold:true",
+    "subtitle":  "fontSize:16; color:grey700",
+    "body":      "fontSize:16",
+    "caption":   "fontSize:13; color:grey600",
+    "button":    "fontSize:16; bold:true; color:white",
+}
+
+# named colors -> Flutter Colors.xxx (None = use hex Color(0xFF...))
+NAMED_COLORS: dict[str, str] = {
+    "red": "Colors.red", "blue": "Colors.blue", "green": "Colors.green",
+    "white": "Colors.white", "black": "Colors.black", "grey": "Colors.grey",
+    "orange": "Colors.orange", "yellow": "Colors.yellow", "purple": "Colors.purple",
+    "pink": "Colors.pink", "teal": "Colors.teal", "cyan": "Colors.cyan",
+    "indigo": "Colors.indigo", "lime": "Colors.lime", "amber": "Colors.amber",
+    "brown": "Colors.brown",
+}
+
+# grey shade tokens like "grey700" -> Colors.grey[700]
+def _grey_shade(token: str) -> str | None:
+    m = re.fullmatch(r"grey(\d+)", token)
+    if m:
+        return f"Colors.grey[{m.group(1)}]"
+    return None
+
+
+def parse_style(style_str: str) -> dict:
+    """Parse a CSS-like style string into a dict. Handles named shortcuts."""
+    if not style_str:
+        return {}
+    s = style_str.strip()
+    # named shortcut?
+    if s in NAMED_STYLES:
+        return parse_style(NAMED_STYLES[s])
+    # also allow "headline; color:blue" (named + overrides)
+    parts = [p.strip() for p in s.split(";") if p.strip()]
+    result: dict = {}
+    for part in parts:
+        if part in NAMED_STYLES:
+            result.update(parse_style(NAMED_STYLES[part]))
+            continue
+        if ":" not in part:
+            continue
+        key, val = part.split(":", 1)
+        key = key.strip()
+        val = val.strip()
+        result[key] = _parse_value(key, val)
+    return result
+
+
+def _parse_value(key: str, val: str):
+    """Convert a string value to the right Python type per property."""
+    if key in ("bold", "italic", "underline"):
+        return val.lower() in ("true", "yes", "1")
+    if key in ("fontSize", "padding", "margin", "radius", "width", "height",
+               "letterSpacing", "border", "gap", "spacing"):
+        try:
+            return int(val)
+        except ValueError:
+            try:
+                return float(val)
+            except ValueError:
+                return val
+    # color / bg / border color: keep as string
+    return val
+
+
+# ---- Flutter emitter ----
+
+def _flutter_color(val: str) -> str:
+    """Convert a color value to a Flutter Dart expression."""
+    if not isinstance(val, str):
+        val = str(val)
+    if val.startswith("#"):
+        hexv = val[1:]
+        if len(hexv) == 3:
+            hexv = "".join(c * 2 for c in hexv)
+        return f"Color(0xFF{hexv})"
+    grey = _grey_shade(val)
+    if grey:
+        return grey
+    # shade tokens like "blue.shade50"
+    if ".shade" in val:
+        name, shade = val.split(".shade")
+        if name in NAMED_COLORS:
+            return f"{NAMED_COLORS[name]}.shade{shade}"
+    if val in NAMED_COLORS:
+        return NAMED_COLORS[val]
+    # fallback: treat as hex without #
+    return f"Color(0xFF{val})"
+
+
+def style_to_flutter_text(d: dict) -> str:
+    """Emit a Flutter TextStyle from a style dict (text-related props)."""
+    if not d:
+        return "TextStyle(fontSize: 16)"
+    parts = []
+    if "fontSize" in d:
+        parts.append(f"fontSize: {d['fontSize']}")
+    if d.get("bold"):
+        parts.append("fontWeight: FontWeight.bold")
+    if d.get("italic"):
+        parts.append("fontStyle: FontStyle.italic")
+    if "color" in d:
+        parts.append(f"color: {_flutter_color(d['color'])}")
+    if "letterSpacing" in d:
+        parts.append(f"letterSpacing: {d['letterSpacing']}")
+    if not parts:
+        return "TextStyle(fontSize: 16)"
+    return f"TextStyle({', '.join(parts)})"
+
+
+def style_to_flutter_padding(d: dict, key: str = "padding") -> str:
+    """Emit Flutter EdgeInsets from padding/margin."""
+    if key not in d:
+        return "EdgeInsets.all(0)"
+    v = d[key]
+    return f"EdgeInsets.all({v})"
+
+
+def style_to_flutter_box(d: dict) -> str:
+    """Emit a Flutter BoxDecoration from bg/radius/border props."""
+    decs = []
+    if "bg" in d:
+        decs.append(f"color: {_flutter_color(d['bg'])}")
+    if "radius" in d:
+        decs.append(f"borderRadius: BorderRadius.circular({d['radius']})")
+    if "border" in d:
+        bval = d["border"]
+        if isinstance(bval, (int, float)):
+            decs.append(f"border: Border.all(width: {bval})")
+        elif isinstance(bval, str) and "," in bval:
+            w, col = bval.split(",", 1)
+            decs.append(
+                f"border: Border.all(color: {_flutter_color(col.strip())}, width: {w.strip()})")
+    if not decs:
+        return ""
+    return f"BoxDecoration({', '.join(decs)})"
+
+
+def style_to_flutter_main_align(d: dict) -> str:
+    """MainAxisAlignment from align prop."""
+    a = d.get("align", "center")
+    mapping = {"center": "center", "start": "start", "end": "end",
+               "spaceBetween": "spaceBetween", "spaceEvenly": "spaceEvenly",
+               "spaceAround": "spaceAround"}
+    return f"MainAxisAlignment.{mapping.get(a, 'center')}"
+
+
+# ---- Slint emitter (stub — proves the same dict targets Rust/C++ GUI later) ----
+
+SLINT_TYPE_MAP = {
+    "fontSize": "font-size", "bold": "font-weight", "color": "color",
+    "padding": "padding", "bg": "background", "radius": "border-radius",
+    "width": "width", "height": "height", "border": "border-width",
+}
+
+
+def style_to_slint(d: dict, indent: int = 2) -> str:
+    """Emit Slint property assignments from the same style dict.
+
+    Slint is a declarative GUI DSL for Rust/C++ with CSS-like properties.
+    This stub shows the SAME dict that emits Flutter Dart above can emit
+    Slint properties — proving multi-target UI from one style syntax.
+    """
+    pad = " " * indent
+    lines = []
+    for key, slint_key in SLINT_TYPE_MAP.items():
+        if key not in d:
+            continue
+        v = d[key]
+        if key == "bold":
+            v = "700" if v else "400"
+        if key == "border" and isinstance(v, str) and "," in v:
+            w, col = v.split(",", 1)
+            lines.append(f"{pad}border-width: {w.strip()};")
+            lines.append(f"{pad}border-color: {col.strip()};")
+            continue
+        if key in ("color", "bg") and isinstance(v, str):
+            if not v.startswith("#"):
+                v = "#000000"  # fallback
+        lines.append(f"{pad}{slint_key}: {v};")
+    return "\n".join(lines)
+
+
+def style_to_rust_egui(d: dict) -> str:
+    """Emit egui (Rust immediate-mode GUI) style calls from the same dict.
+
+    Another target proving the dict is portable. egui is a popular Rust GUI lib.
+    """
+    parts = []
+    if "fontSize" in d:
+        parts.append(f".font_size({d['fontSize']} as f32)")
+    if d.get("bold"):
+        parts.append(".strong()")
+    if "color" in d and isinstance(d["color"], str) and d["color"].startswith("#"):
+        hexv = d["color"][1:]
+        parts.append(f".color(Color32::from_rgb(0x{hexv[0:2]}, 0x{hexv[2:4]}, 0x{hexv[4:6]}))")
+    return "".join(parts) if parts else ""

package/python/pyeffic/templates/desktop_gui/README.md

@@ -0,0 +1,106 @@
+# {app_name}
+
+Native desktop application built with the GE programming language.
+
+## Architecture
+
+```
+{app_name}/
+  app/
+    memory/     Rust — bounded state, buffers, limits
+      limits.ge.py    input bounds + clamping
+      buffer.ge.py    fixed-size buffer capacities
+      state.ge.py     initial state + operation cycling
+    core/       C++  — computation, one function per file
+      add.ge.py  multiply.ge.py  factorial.ge.py
+      fibonacci.ge.py  is_prime.ge.py  gcd.ge.py  power.ge.py
+    ui/         C++  — design, one concern per file
+      theme.ge.py     colors, font sizes, spacing
+      layout.ge.py    geometry math
+      widgets.ge.py   drawing primitives
+      render.ge.py    frame orchestrator
+    main.ge.py  aggregator (single import surface)
+  desktop/
+    main.ge.py  Rust shell — window, event loop, input
+  tests/        unit tests for all three layers
+```
+
+### Layer responsibilities
+
+| Layer | Language | Responsibility | Why |
+|-------|----------|----------------|-----|
+| Shell | Rust | window, message loop, input, state | memory safety — no leaks, no use-after-free |
+| Core | C++ | computation (factorial, fibonacci, gcd, ...) | raw speed for hot math |
+| UI | C++ | theme, layout, widgets, rendering | native GDI, no runtime, small binary |
+
+The Rust shell holds **fixed-size scalar state only**. Nothing grows at
+runtime, so memory use is constant no matter how long the app runs.
+
+### Data flow
+
+```
+keyboard -> Rust wnd_proc -> mem_step_up / run_op
+                              |            |
+                              |            +-> C++ core  (factorial, ...)
+                              +-> bounded state (G_INPUT, G_RESULT, G_OP)
+                                        |
+                              WM_PAINT  v
+                        Rust calls ui_draw_frame(hdc, w, h, ...)
+                                        |
+                              C++ UI draws: bg -> grid -> sidebar -> card
+```
+
+## Build
+
+```bash
+ge build desktop/main.ge.py --run     # one command: C++ object + Rust exe
+ge build desktop/main.ge.py -o out    # custom output dir
+```
+
+`ge build` detects that the program mixes backends and links them itself:
+it emits the C++ functions in library mode (`extern "C"`), compiles them to
+an object file, emits the Rust shell with matching `extern "C"` declarations,
+and links one executable. No project build script is needed.
+
+## Test
+
+```bash
+python -m unittest discover tests
+```
+
+## Controls
+
+| Key | Action |
+|-----|--------|
+| Up / Down | change input (clamped by memory layer) |
+| Enter | run the selected operation (C++ core) |
+| F / P / G | fibonacci / is_prime / gcd |
+| Esc | quit |
+
+## Adding a core function
+
+1. Create `app/core/my_func.ge.py`:
+
+   ```python
+   from pyeffic.backends import cpp
+
+   @cpp
+   def my_func(x: int) -> int:
+       return x * 2
+   ```
+
+2. Re-export it in `app/main.ge.py`.
+3. Declare it in the FFI block of `desktop/main.ge.py`:
+
+   ```rust
+   fn my_func(x: i64) -> i64;
+   ```
+
+4. Call it from the Rust shell and add a test.
+
+## Adding a UI element
+
+1. Add tokens to `app/ui/theme.ge.py` if you need new colors/sizes.
+2. Add geometry to `app/ui/layout.ge.py`.
+3. Add a drawing primitive to `app/ui/widgets.ge.py`.
+4. Compose it in `app/ui/render.ge.py`.

package/python/pyeffic/templates/desktop_gui/app/core/add.ge.py

@@ -0,0 +1,13 @@
+"""Core function: add. Compiled to C++ for performance.
+
+One function per file (C++ Core Guidelines SF.1-SF.5): each function is a
+separate compilation unit with a clear dependency list.
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+
+
+@cpp
+def add(a: int, b: int) -> int:
+    """Add two integers."""
+    return a + b

package/python/pyeffic/templates/desktop_gui/app/core/factorial.ge.py

@@ -0,0 +1,20 @@
+"""Core function: factorial. Compiled to C++ for performance.
+
+One function per file (C++ Core Guidelines SF.1-SF.5): each function is a
+separate compilation unit with a clear dependency list.
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+
+
+@cpp
+def factorial(n: int) -> int:
+    """Compute factorial of n."""
+    if n <= 1:
+        return 1
+    result: int = 1
+    i: int = 2
+    while i <= n:
+        result = result * i
+        i = i + 1
+    return result

package/python/pyeffic/templates/desktop_gui/app/core/fibonacci.ge.py

@@ -0,0 +1,25 @@
+"""Core function: fibonacci. Compiled to C++ for performance.
+
+One function per file (C++ Core Guidelines SF.1-SF.5): each function is a
+separate compilation unit with a clear dependency list.
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+
+
+@cpp
+def fibonacci(n: int) -> int:
+    """Compute the nth Fibonacci number iteratively."""
+    if n <= 0:
+        return 0
+    if n == 1:
+        return 1
+    a: int = 0
+    b: int = 1
+    i: int = 2
+    while i <= n:
+        temp: int = a + b
+        a = b
+        b = temp
+        i = i + 1
+    return b

package/python/pyeffic/templates/desktop_gui/app/core/gcd.ge.py

@@ -0,0 +1,19 @@
+"""Core function: gcd. Compiled to C++ for performance.
+
+One function per file (C++ Core Guidelines SF.1-SF.5): each function is a
+separate compilation unit with a clear dependency list.
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+
+
+@cpp
+def gcd(a: int, b: int) -> int:
+    """Greatest common divisor (Euclidean algorithm)."""
+    while b != 0:
+        temp: int = b
+        b = a % b
+        a = temp
+    if a < 0:
+        a = -a
+    return a

package/python/pyeffic/templates/desktop_gui/app/core/is_prime.ge.py

@@ -0,0 +1,24 @@
+"""Core function: is_prime. Compiled to C++ for performance.
+
+One function per file (C++ Core Guidelines SF.1-SF.5): each function is a
+separate compilation unit with a clear dependency list.
+"""
+from __future__ import annotations
+from pyeffic.backends import cpp
+
+
+@cpp
+def is_prime(n: int) -> int:
+    """Return 1 if n is prime, 0 otherwise."""
+    if n < 2:
+        return 0
+    if n == 2:
+        return 1
+    if n % 2 == 0:
+        return 0
+    i: int = 3
+    while i * i <= n:
+        if n % i == 0:
+            return 0
+        i = i + 2
+    return 1