gelang 0.1.3 → 0.1.5

package/python/pyeffic/stdlib.py

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

package/python/pyeffic/typecheck.py

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