gelang 0.1.0

package/python/pyeffic/templates/desktop_gui/desktop/main.ge.py

@@ -0,0 +1,258 @@
+"""Desktop entry point for {app_name} — thin Rust shell.
+
+The shell owns only the window and the message loop. All rendering is
+delegated to the C++ UI layer; all computation to the C++ core layer.
+
+  Rust  — window, event loop, bounded state, input handling
+  C++   — ui_draw_frame(...) rendering, factorial/fibonacci/... compute
+
+Memory model (Rust): fixed-size scalar state, no collections that grow,
+no per-frame heap allocation, ownership handles all cleanup.
+
+Build:  python build.py --run
+"""
+from __future__ import annotations
+from app.main import (
+    mem_clamp_input, mem_step_up, mem_step_down, mem_normalize_input,
+    mem_initial_input, mem_initial_result, mem_initial_op, mem_next_op,
+    factorial, fibonacci, is_prime, gcd,
+)
+
+# File-scope Win32 FFI declarations for the Rust shell.
+ge_preamble("rust", """
+// Note: warnings are suppressed by the build (rustc -A warnings) because
+// this file is generated; inner attributes cannot appear mid-file.
+
+// === Win32 type aliases ===
+type HWND = *mut std::ffi::c_void;
+type HDC = *mut std::ffi::c_void;
+type HINSTANCE = *mut std::ffi::c_void;
+type HMENU = *mut std::ffi::c_void;
+type HCURSOR = *mut std::ffi::c_void;
+type HICON = *mut std::ffi::c_void;
+type WPARAM = usize;
+type LPARAM = isize;
+type LRESULT = isize;
+type UINT = u32;
+type DWORD = u32;
+type LONG = i32;
+type BOOL = i32;
+type BYTE = u8;
+type ATOM = u16;
+
+#[repr(C)]
+struct RECT { left: LONG, top: LONG, right: LONG, bottom: LONG }
+#[repr(C)]
+struct POINT { x: LONG, y: LONG }
+#[repr(C)]
+struct MSG {
+    hwnd: HWND,
+    message: UINT,
+    wParam: WPARAM,
+    lParam: LPARAM,
+    time: DWORD,
+    pt: POINT,
+}
+#[repr(C)]
+struct PAINTSTRUCT {
+    hdc: HDC,
+    fErase: BOOL,
+    rcPaint: RECT,
+    fRestore: BOOL,
+    fIncUpdate: BOOL,
+    rgbReserved: [BYTE; 32],
+}
+#[repr(C)]
+struct WNDCLASSEXA {
+    cbSize: UINT,
+    style: UINT,
+    lpfnWndProc: Option<unsafe extern "system" fn(HWND, UINT, WPARAM, LPARAM) -> LRESULT>,
+    cbClsExtra: i32,
+    cbWndExtra: i32,
+    hInstance: HINSTANCE,
+    hIcon: HICON,
+    hCursor: HCURSOR,
+    hbrBackground: *mut std::ffi::c_void,
+    lpszMenuName: *const u8,
+    lpszClassName: *const u8,
+    hIconSm: HICON,
+}
+
+// === Win32 constants ===
+const CS_HREDRAW: u32 = 2;
+const CS_VREDRAW: u32 = 1;
+const CW_USEDEFAULT: i32 = -2147483648;
+const SW_SHOWDEFAULT: i32 = 10;
+const WM_PAINT: u32 = 15;
+const WM_DESTROY: u32 = 2;
+const WM_KEYDOWN: u32 = 256;
+const WM_CLOSE: u32 = 16;
+const WM_ERASEBKGND: u32 = 20;
+const VK_ESCAPE: i32 = 27;
+const VK_RETURN: i32 = 13;
+const VK_UP: i32 = 0x26;
+const VK_DOWN: i32 = 0x28;
+const VK_F: i32 = 0x46;
+const VK_P: i32 = 0x50;
+const VK_G: i32 = 0x47;
+const WS_OVERLAPPEDWINDOW: u32 = 13565952;
+
+// === Win32 FFI ===
+extern "system" {
+    fn BeginPaint(hwnd: HWND, lpPaint: *mut PAINTSTRUCT) -> HDC;
+    fn EndPaint(hwnd: HWND, lpPaint: *const PAINTSTRUCT) -> BOOL;
+    fn GetClientRect(hwnd: HWND, lpRect: *mut RECT) -> BOOL;
+    fn InvalidateRect(hwnd: HWND, lpRect: *const RECT, bErase: BOOL) -> BOOL;
+    fn RegisterClassExA(lpwcx: *const WNDCLASSEXA) -> ATOM;
+    fn CreateWindowExA(dwExStyle: u32, lpClassName: *const u8, lpWindowName: *const u8,
+                       dwStyle: u32, x: i32, y: i32, nWidth: i32, nHeight: i32,
+                       hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE,
+                       lpParam: *mut std::ffi::c_void) -> HWND;
+    fn ShowWindow(hwnd: HWND, nCmdShow: i32) -> BOOL;
+    fn UpdateWindow(hwnd: HWND) -> BOOL;
+    fn GetMessageA(lpMsg: *mut MSG, hwnd: HWND, wMsgFilterMin: u32, wMsgFilterMax: u32) -> BOOL;
+    fn TranslateMessage(lpMsg: *const MSG) -> BOOL;
+    fn DispatchMessageA(lpMsg: *const MSG) -> LRESULT;
+    fn DefWindowProcA(hwnd: HWND, msg: u32, wParam: WPARAM, lParam: LPARAM) -> LRESULT;
+    fn PostQuitMessage(nExitCode: i32);
+    fn DestroyWindow(hwnd: HWND) -> BOOL;
+    fn GetModuleHandleA(lpModuleName: *const u8) -> HINSTANCE;
+    fn LoadCursorA(hInstance: HINSTANCE, lpCursorName: *const u8) -> HCURSOR;
+    fn LoadIconA(hInstance: HINSTANCE, lpIconName: *const u8) -> HICON;
+}
+
+// The C++ functions this shell calls are declared automatically by
+// `ge build` (mixed-backend link step), so no hand-written extern block
+// is needed here.
+
+// === Bounded state ===
+static mut G_HWND: HWND = std::ptr::null_mut();
+static mut G_INPUT: i64 = 10;
+static mut G_RESULT: i64 = 0;
+static mut G_OP: i64 = 0;
+
+fn run_op(op: i64, input: i64) -> i64 {
+    unsafe {
+        match op {
+            0 => factorial(input),
+            1 => fibonacci(input),
+            2 => is_prime(input),
+            3 => gcd(input, input / 2 + 1),
+            _ => 0,
+        }
+    }
+}
+
+unsafe extern "system" fn wnd_proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+    unsafe {
+        match msg {
+            WM_PAINT => {
+                let mut ps: PAINTSTRUCT = std::mem::zeroed();
+                let hdc = BeginPaint(hwnd, &mut ps);
+                let mut rc: RECT = std::mem::zeroed();
+                GetClientRect(hwnd, &mut rc);
+                let w = (rc.right - rc.left) as i64;
+                let h = (rc.bottom - rc.top) as i64;
+                ui_draw_frame(hdc as i64, w, h, G_INPUT, G_RESULT, G_OP);
+                EndPaint(hwnd, &ps);
+                0
+            }
+            WM_ERASEBKGND => 1,
+            WM_KEYDOWN => {
+                let k = wparam as i32;
+                if k == VK_ESCAPE {
+                    DestroyWindow(hwnd);
+                } else if k == VK_RETURN {
+                    G_RESULT = run_op(G_OP, G_INPUT);
+                    InvalidateRect(hwnd, std::ptr::null(), 0);
+                } else if k == VK_UP {
+                    G_INPUT = mem_step_up(G_INPUT);
+                    InvalidateRect(hwnd, std::ptr::null(), 0);
+                } else if k == VK_DOWN {
+                    G_INPUT = mem_step_down(G_INPUT);
+                    InvalidateRect(hwnd, std::ptr::null(), 0);
+                } else if k == VK_F {
+                    G_OP = 1;
+                    G_RESULT = run_op(1, G_INPUT);
+                    InvalidateRect(hwnd, std::ptr::null(), 0);
+                } else if k == VK_P {
+                    G_OP = 2;
+                    G_RESULT = run_op(2, G_INPUT);
+                    InvalidateRect(hwnd, std::ptr::null(), 0);
+                } else if k == VK_G {
+                    G_OP = 3;
+                    G_RESULT = run_op(3, G_INPUT);
+                    InvalidateRect(hwnd, std::ptr::null(), 0);
+                }
+                0
+            }
+            WM_CLOSE => { DestroyWindow(hwnd); 0 }
+            WM_DESTROY => { PostQuitMessage(0); 0 }
+            _ => DefWindowProcA(hwnd, msg, wparam, lparam),
+        }
+    }
+}
+""")
+
+
+@rust
+def desktop_bootstrap() -> int:
+    """Initialize bounded state from the memory layer."""
+    ge_inline("rust", """
+    unsafe {
+        G_INPUT = mem_normalize_input(mem_initial_input());
+        G_RESULT = mem_initial_result();
+        G_OP = mem_initial_op();
+    }
+    return 0;
+    """)
+    return 0
+
+
+@rust
+def desktop_run() -> int:
+    """Create the window and run the message loop."""
+    ge_inline("rust", """
+    unsafe {
+    let class_name = b"GEAppWnd\0".as_ptr();
+    let hinst = GetModuleHandleA(std::ptr::null());
+    let wc = WNDCLASSEXA {
+        cbSize: std::mem::size_of::<WNDCLASSEXA>() as u32,
+        style: CS_HREDRAW | CS_VREDRAW,
+        lpfnWndProc: Some(wnd_proc),
+        cbClsExtra: 0,
+        cbWndExtra: 0,
+        hInstance: hinst,
+        hIcon: LoadIconA(std::ptr::null_mut(), std::ptr::null()),
+        hCursor: LoadCursorA(std::ptr::null_mut(), std::ptr::null()),
+        hbrBackground: std::ptr::null_mut(),
+        lpszMenuName: std::ptr::null(),
+        lpszClassName: class_name,
+        hIconSm: std::ptr::null_mut(),
+    };
+    if RegisterClassExA(&wc) == 0 { return 1; }
+
+    let title = b"{app_name} - Rust + C++ Desktop\0".as_ptr();
+    G_HWND = CreateWindowExA(0, class_name, title,
+        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 1040, 680,
+        std::ptr::null_mut(), std::ptr::null_mut(), hinst, std::ptr::null_mut());
+    if G_HWND.is_null() { return 1; }
+
+    ShowWindow(G_HWND, SW_SHOWDEFAULT);
+    UpdateWindow(G_HWND);
+
+    let mut msg: MSG = std::mem::zeroed();
+    while GetMessageA(&mut msg, std::ptr::null_mut(), 0, 0) > 0 {
+        TranslateMessage(&msg);
+        DispatchMessageA(&msg);
+    }
+    msg.wParam as i64
+    }
+    """)
+    return 0
+
+
+def main() -> int:
+    """Entry point: bootstrap state, then run the window loop."""
+    desktop_bootstrap()
+    return desktop_run()

package/python/pyeffic/templates/desktop_gui/ge.toml

@@ -0,0 +1,16 @@
+# GE project configuration for {app_name}
+[project]
+name = "{app_name}"
+version = "0.1.0"
+description = "Native desktop app — Rust shell + C++ core + C++ UI"
+template = "desktop-gui"
+
+[build]
+platforms = ["desktop"]
+languages = ["rust", "cpp"]
+
+[layers]
+memory = "app/memory"   # Rust
+core = "app/core"       # C++
+ui = "app/ui"           # C++
+entry = "desktop/main.ge.py"

package/python/pyeffic/templates/desktop_gui/tests/ge_loader.py

@@ -0,0 +1,76 @@
+"""Import hook for .ge.py modules.
+
+Python cannot import `app/core/add.ge.py` as `app.core.add`, so this
+module installs a meta path finder that maps dotted names onto .ge.py
+files. After install(), normal imports just work, with Python handling
+ordering, caching, and circular-import semantics:
+
+    from ge_loader import install
+    install()
+    from app.core.factorial import factorial
+"""
+import importlib.abc
+import importlib.util
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).parent.parent
+_installed = False
+
+
+def _stub_preamble(backend, code):  # noqa: ARG001
+    """No-op stand-in for the GE ge_preamble intrinsic."""
+    return None
+
+
+def _stub_value(*args, **kwargs):  # noqa: ARG001
+    """No-op stand-in for ge_inline / ge_raw; returns int 0."""
+    return 0
+
+
+class GeFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    """Resolve `pkg.mod` to `pkg/mod.ge.py` under the project root."""
+
+    @staticmethod
+    def _ge_path(parts: list[str]) -> Path:
+        return ROOT.joinpath(*parts[:-1]) / (parts[-1] + ".ge.py")
+
+    def find_spec(self, fullname, path=None, target=None):
+        parts = fullname.split(".")
+        ge_path = self._ge_path(parts)
+        if ge_path.is_file():
+            return importlib.util.spec_from_loader(fullname, self)
+        pkg_dir = ROOT.joinpath(*parts)
+        init = pkg_dir / "__init__.py"
+        if init.is_file():
+            return importlib.util.spec_from_file_location(
+                fullname, init, submodule_search_locations=[str(pkg_dir)])
+        return None
+
+    def create_module(self, spec):
+        return None
+
+    def exec_module(self, module):
+        parts = module.__name__.split(".")
+        ge_path = self._ge_path(parts)
+        code = ge_path.read_text(encoding="utf-8")
+        # GE compiler intrinsics are not Python builtins; provide no-op
+        # stubs so the module can be imported for unit testing.
+        ns = module.__dict__
+        ns.setdefault("ge_preamble", _stub_preamble)
+        ns.setdefault("ge_inline", _stub_value)
+        ns.setdefault("ge_raw", _stub_value)
+        exec(compile(code, str(ge_path), "exec"), ns)
+
+
+def install() -> None:
+    """Install the .ge.py import hook (idempotent)."""
+    global _installed
+    if _installed:
+        return
+    if not any(isinstance(f, GeFinder) for f in sys.meta_path):
+        sys.meta_path.insert(0, GeFinder())
+    root = str(ROOT)
+    if root not in sys.path:
+        sys.path.insert(0, root)
+    _installed = True

package/python/pyeffic/templates/desktop_gui/tests/test_app.py

@@ -0,0 +1,173 @@
+"""{app_name} test suite.
+
+Run with:
+
+    python -m unittest discover tests
+"""
+import sys
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).parent.parent
+sys.path.insert(0, str(ROOT / "tests"))
+
+from ge_loader import install  # noqa: E402
+
+install()
+
+# .ge.py modules are importable now.
+from app.core.add import add  # noqa: E402
+from app.core.multiply import multiply  # noqa: E402
+from app.core.factorial import factorial  # noqa: E402
+from app.core.fibonacci import fibonacci  # noqa: E402
+from app.core.is_prime import is_prime  # noqa: E402
+from app.core.gcd import gcd  # noqa: E402
+from app.core.power import power  # noqa: E402
+from app.memory.limits import (  # noqa: E402
+    mem_input_min, mem_input_max, mem_clamp_input, mem_step_up, mem_step_down,
+)
+from app.memory.buffer import (  # noqa: E402
+    mem_buffer_capacity, mem_digits_capacity, mem_state_slots,
+)
+from app.memory.state import (  # noqa: E402
+    mem_initial_input, mem_initial_result, mem_initial_op,
+    mem_op_count, mem_next_op, mem_normalize_input,
+)
+from app.ui.theme import ui_color_bg, ui_color_accent, ui_font_body, ui_radius  # noqa: E402
+from app.ui.layout import (  # noqa: E402
+    ui_card_width, ui_card_height, ui_sidebar_width, ui_content_x,
+    ui_center_x, ui_row_y,
+)
+
+
+class TestCoreFunctions(unittest.TestCase):
+    """C++ core layer - computation."""
+
+    def test_add(self):
+        self.assertEqual(add(3, 4), 7)
+        self.assertEqual(add(-1, 1), 0)
+
+    def test_multiply(self):
+        self.assertEqual(multiply(3, 4), 12)
+        self.assertEqual(multiply(0, 5), 0)
+
+    def test_factorial(self):
+        self.assertEqual(factorial(0), 1)
+        self.assertEqual(factorial(5), 120)
+        self.assertEqual(factorial(10), 3628800)
+
+    def test_fibonacci(self):
+        self.assertEqual(fibonacci(0), 0)
+        self.assertEqual(fibonacci(1), 1)
+        self.assertEqual(fibonacci(10), 55)
+
+    def test_is_prime(self):
+        self.assertEqual(is_prime(2), 1)
+        self.assertEqual(is_prime(3), 1)
+        self.assertEqual(is_prime(4), 0)
+        self.assertEqual(is_prime(17), 1)
+        self.assertEqual(is_prime(100), 0)
+
+    def test_gcd(self):
+        self.assertEqual(gcd(12, 8), 4)
+        self.assertEqual(gcd(17, 5), 1)
+        self.assertEqual(gcd(100, 50), 50)
+
+    def test_power(self):
+        self.assertEqual(power(2, 0), 1)
+        self.assertEqual(power(2, 10), 1024)
+        self.assertEqual(power(3, 3), 27)
+
+
+class TestMemoryLayer(unittest.TestCase):
+    """Rust memory layer - bounds and state."""
+
+    def test_clamp_input(self):
+        self.assertEqual(mem_clamp_input(-5), mem_input_min())
+        self.assertEqual(mem_clamp_input(999), mem_input_max())
+        self.assertEqual(mem_clamp_input(7), 7)
+
+    def test_step_up_down(self):
+        self.assertEqual(mem_step_up(1), 2)
+        self.assertEqual(mem_step_down(1), 0)
+        self.assertEqual(mem_step_up(mem_input_max()),
+                         mem_input_max())
+        self.assertEqual(mem_step_down(mem_input_min()),
+                         mem_input_min())
+
+    def test_factorial_fits_in_i64(self):
+        # mem_input_max() must keep factorial within i64 range
+        self.assertLess(factorial(mem_input_max()),
+                        2 ** 63)
+
+    def test_state_defaults(self):
+        self.assertEqual(mem_initial_result(), 0)
+        self.assertEqual(mem_initial_op(), 0)
+        self.assertIsInstance(mem_initial_input(), int)
+
+    def test_op_cycle(self):
+        self.assertEqual(mem_next_op(mem_op_count() - 1), 0)
+        self.assertEqual(mem_next_op(0), 1)
+
+    def test_normalize(self):
+        self.assertEqual(mem_normalize_input(999), mem_input_max())
+
+    def test_buffers_bounded(self):
+        self.assertGreater(mem_buffer_capacity(),
+                           mem_digits_capacity())
+        self.assertGreater(mem_state_slots(), 0)
+
+
+class TestUILayer(unittest.TestCase):
+    """C++ UI layer - design tokens and layout math."""
+
+    def test_theme_tokens(self):
+        self.assertIsInstance(ui_color_bg(), int)
+        self.assertIsInstance(ui_color_accent(), int)
+        self.assertGreater(ui_font_body(), 0)
+        self.assertGreater(ui_radius(), 0)
+
+    def test_layout_math(self):
+        self.assertGreater(ui_card_width(1200), 0)
+        self.assertGreater(ui_content_x(), ui_sidebar_width())
+        self.assertGreater(ui_card_height(800), 0)
+
+    def test_centering(self):
+        self.assertEqual(ui_center_x(0, 100, 20), 40)
+
+    def test_rows_increase(self):
+        self.assertGreater(ui_row_y(2), ui_row_y(1))
+
+
+class TestProjectStructure(unittest.TestCase):
+    """Layered architecture is present on disk."""
+
+    def test_layers_exist(self):
+        for layer in ["memory", "core", "ui"]:
+            self.assertTrue((ROOT / "app" / layer).is_dir(),
+                            "app/" + layer + "/ should exist")
+
+    def test_one_function_per_core_file(self):
+        core = ROOT / "app" / "core"
+        for f in ["add.ge.py", "multiply.ge.py", "factorial.ge.py",
+                  "fibonacci.ge.py", "is_prime.ge.py", "gcd.ge.py", "power.ge.py"]:
+            self.assertTrue((core / f).exists(), "app/core/" + f + " should exist")
+
+    def test_ui_files(self):
+        ui = ROOT / "app" / "ui"
+        for f in ["theme.ge.py", "layout.ge.py", "widgets.ge.py", "render.ge.py"]:
+            self.assertTrue((ui / f).exists(), "app/ui/" + f + " should exist")
+
+    def test_memory_files(self):
+        mem = ROOT / "app" / "memory"
+        for f in ["limits.ge.py", "buffer.ge.py", "state.ge.py"]:
+            self.assertTrue((mem / f).exists(), "app/memory/" + f + " should exist")
+
+    def test_entry_and_config(self):
+        # the build is `ge build desktop/main.ge.py` — no project build script
+        self.assertTrue((ROOT / "desktop" / "main.ge.py").exists())
+        self.assertTrue((ROOT / "ge.toml").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,115 @@
+# {app_name}
+
+Full-stack web application built with the GE programming language.
+
+## Architecture
+
+```
+{app_name}/
+  app/
+    memory/       Rust — request bounds, buffer capacities
+      limits.ge.py
+      buffer.ge.py
+    core/         Rust — computation, one function per file
+      add.ge.py  multiply.ge.py  factorial.ge.py
+      fibonacci.ge.py  is_prime.ge.py
+    main.ge.py    aggregator
+  web/
+    server.ge.py  Rust backend (HTTP API + static SPA)
+    frontend/     React 19 + TypeScript + Vite (generated, then yours)
+      src/App.tsx
+      src/api/client.ts
+      src/components/Ge*.tsx   one component per file
+  ui/
+    main.ge.ui    declarative UI — source of truth for the frontend
+  tests/
+```
+
+### Layers
+
+| Layer | Language | Responsibility |
+|-------|----------|----------------|
+| Frontend | React + TypeScript | UI, calls `/api/call` |
+| Backend | Rust | HTTP, dispatch, bounds enforcement |
+| Memory | Rust | clamp inputs, cap buffers |
+| Core | Rust | pure computation |
+
+### Data flow
+
+```
+browser -> POST /api/call {name, args}
+             |
+             v
+       Rust backend -> mem_clamp_arg(args) -> core function
+             |
+             v
+       JSON {ok, value} -> React state -> GeText/GeValue
+```
+
+## Build output layout
+
+Everything lands under `build/`, bucketed by platform so a multi-target
+project stays readable:
+
+```
+build/
+  desktop/    native desktop build
+    backend/    generated native sources
+    obj/        object files
+    bin/        executables
+  web/        web build
+    backend/    generated Rust backend
+    bin/        server executable
+  mobile/     Flutter project
+    backend/  ui/  lib/
+```
+
+## Build
+
+```bash
+ge build web/server.ge.py --run      # compile the Rust backend
+ge react ui/main.ge.ui --app-name {app_name}   # generate the React frontend
+cd web/frontend && npm install && npm run build   # bundle the SPA
+```
+
+`ge build` compiles the backend straight from the GE sources. `ge react`
+generates the frontend from the UI DSL, and only writes files that do not
+already exist unless you pass `--force`.
+
+## Frontend workflow
+
+`ui/main.ge.ui` is the source of truth for the layout:
+
+```bash
+ge react ui/main.ge.ui --app-name {app_name}   # regenerate (keeps edits)
+ge react ui/main.ge.ui --force                 # regenerate, overwrite
+cd web/frontend && npm run dev                 # dev server, proxies /api
+```
+
+Files under `web/frontend/src` are ordinary React/TypeScript. Edit them
+freely: regeneration only writes files that do not exist unless `--force`.
+
+## TypeScript source support
+
+Any module can be written in TypeScript flavour instead of Python flavour.
+Both lower to the same IR, so both compile to the same native code:
+
+```
+app/core/add.ge.py        Python flavour
+app/core/add.ts.ge.py     TypeScript flavour (same file name, .ts.ge)
+app/core/add.ge.ts        TypeScript flavour (alternate extension)
+```
+
+TypeScript flavour example:
+
+```typescript
+export function add(a: number, b: number): number {
+    return a + b;
+}
+```
+
+## Test
+
+```bash
+python -m unittest discover tests
+```

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

@@ -0,0 +1,9 @@
+"""Core function: add. Compiled to the selected native backend."""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+def add(a: int, b: int) -> int:
+    """Add two integers."""
+    return a + b

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

@@ -0,0 +1,16 @@
+"""Core function: factorial. Compiled to Rust."""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+def factorial(n: int) -> int:
+    """Compute factorial of n (n is clamped by the memory layer)."""
+    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/web_react/app/core/fibonacci.ge.py

@@ -0,0 +1,21 @@
+"""Core function: fibonacci. Compiled to Rust."""
+from __future__ import annotations
+from pyeffic.backends import rust
+
+
+@rust
+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