gelang 0.1.3 → 0.1.5

package/python/pyeffic/emitters/csharp.py

@@ -14,9 +14,18 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="csharp",
     types={"int": "long", "float": "double", "bool": "bool", "str": "string", "None": "void"},
-    list_type="List<long>",
+    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})",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi}).Step({step})",
@@ -27,6 +36,7 @@ SPEC = Spec(
     print_str='Console.WriteLine({v})',
     print_bool='Console.WriteLine({v})',
     print_generic='Console.WriteLine({v})',
+    print_list='Console.WriteLine("[" + string.Join(", ", {v}) + "]")',
     int_cast="(long)({x})",
     float_cast="(double)({x})",
     float_div="((double)({l}) / (double)({r}))",
@@ -34,9 +44,13 @@ SPEC = Spec(
     sum_call="{it}.Sum()",
     abs_int="Math.Abs({x})",
     abs_float="Math.Abs({x})",
+    min2_call="Math.Min({a}, {b})",
+    max2_call="Math.Max({a}, {b})",
     min_call="{it}.Min()",
     max_call="{it}.Max()",
     pow_call="Math.Pow({l}, {r})",
+    pow_int="(long)Math.Pow({l}, {r})",
+    pow_float="Math.Pow({l}, {r})",
     append_call="{x}.Add({v})",
     index_call="{x}[(int)({i})]",
     comment="//",
@@ -57,8 +71,10 @@ SPEC = Spec(
     struct_field_template="    public {type} {name};",
     struct_new_template="static {name} {name}_New({params}) {{\n{body}\n}}",
     dict_type="Dictionary<string, {V}>",
+    set_type="HashSet<long>",
     dict_get="{d}[{k}]",
     dict_set="{d}[{k}] = {v}",
+    dict_keys="{x}.Keys",
     dict_contains="{d}.ContainsKey({k})",
     tuple_type="({T}, {T})",
     tuple_get="{t}.Item{i1}",
@@ -108,8 +124,12 @@ class CSharpEmitter(Emitter):
             self.lines.append(f"{ind}for (long {var} = {lo}; {var} < {hi}; {var}++) {{")
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "long"
-            self.lines.append(f"{ind}foreach (var {var} in {iter_s}) {{")
+            if self.infer_type(it) == "dict":
+                self.var_types[var] = "str"
+                self.lines.append(f"{ind}foreach (var {var} in {iter_s}.Keys) {{")
+            else:
+                self.var_types[var] = "long"
+                self.lines.append(f"{ind}foreach (var {var} in {iter_s}) {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -133,9 +153,15 @@ class CSharpEmitter(Emitter):
     def stmt(self, node):  # type: ignore[override]
         # escape C# keywords in variable declarations
         if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+            # bare `list` gets its element type from the value
+            _ann = self._ann_type(node.annotation)
+            _elem = (self._list_elem_of_value(node.value)
+                     if (_ann == "list" and node.value is not None) else "")
             name = self._esc(node.target.id)
             ann_type = self._ann_type(node.annotation)
             nt = self.py_to_native(ann_type)
+            if _elem and _elem != self.spec.list_elem_type:
+                nt = self.spec.list_type.format(T=_elem)
             if node.value is not None:
                 val = self.expr(node.value)
                 self.lines.append(f"{self.spec.indent * self.indent_lvl}{nt} {name} = {val};")
@@ -227,6 +253,11 @@ def emit_csharp(units: list[FuncUnit], entry: str | None,
     extern_fns: functions from other backends that this C# code calls.
     """
     emitter = CSharpEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
     emitted: dict[str, str] = {}
@@ -317,6 +348,9 @@ def emit_csharp(units: list[FuncUnit], entry: str | None,
             for line in fn.split("\n"):
                 indented_fns.append("    " + line)
         indented_fns.append(wrapper.rstrip())
+    elif not fns:
+        # entry rejected during emission; see the pipeline diagnostic
+        return prelude, emitted
     else:
         # rename main to Main for C# entry point
         # C# Main must return void or int (32-bit), not long

package/python/pyeffic/emitters/go.py

@@ -13,9 +13,18 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="go",
     types={"int": "int64", "float": "float64", "bool": "bool", "str": "string", "None": ""},
-    list_type="[]int64",
+    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}...)",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi})",
@@ -24,18 +33,25 @@ SPEC = Spec(
     print_int='fmt.Println({v})',
     print_float='fmt.Println({v})',
     print_str='fmt.Println({v})',
-    print_bool='fmt.Println({v})',
+    print_bool='fmt.Println(geBoolStr({v}))',
     print_generic='fmt.Println({v})',
-    int_cast="int64({x})",
+    print_list='fmt.Println(geListStr({v}))',
+    # 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})",
     sum_call="func() int64 {{ var s int64; for _, v := range {it} {{ s += v }}; return s }}()",
-    abs_int="abs({x})",
+    abs_int="geAbsInt({x})",
     abs_float="math.Abs({x})",
+    min2_call="geMin2({a}, {b})",
+    max2_call="geMax2({a}, {b})",
     min_call="func() int64 {{ var m int64; for i, v := range {it} {{ if i == 0 || v < m {{ m = v }} }}; return m }}()",
     max_call="func() int64 {{ var m int64; for i, v := range {it} {{ if i == 0 || v > m {{ m = v }} }}; return m }}()",
     pow_call="int64(math.Pow(float64({l}), float64({r})))",
+    pow_int="int64(math.Pow(float64({l}), float64({r})))",
+    pow_float="math.Pow({l}, {r})",
     append_call="{x} = append({x}, {v})",
     index_call="{x}[{i}]",
     comment="//",
@@ -58,8 +74,11 @@ SPEC = Spec(
     struct_field_template="\t{type} {name}",
     struct_new_template="func {name}_New({params}) {name} {{\n{body}\n}}",
     dict_type="map[string]{V}",
+    set_type="map[int64]bool",
     dict_get="{d}[{k}]",
     dict_set="{d}[{k}] = {v}",
+    dict_keys="{x}",
+    foreach_dict_template="for {var} := range {iter}",
     dict_contains="dictContains({d}, {k})",
     tuple_type="struct {{ a {T}; b {T} }}",
     tuple_get="{t}.{field}",
@@ -157,8 +176,13 @@ class GoEmitter(Emitter):
             self.lines.append(f"{ind}    {var_a} := {it_a}[__i]; {var_b} := {it_b}[__i]")
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "long"
-            self.lines.append(f"{ind}for _, {var} := range {iter_s} {{")
+            if self.infer_type(it) == "dict":
+                # range over a map yields keys
+                self.var_types[var] = "str"
+                self.lines.append(f"{ind}for {var} := range {iter_s} {{")
+            else:
+                self.var_types[var] = "long"
+                self.lines.append(f"{ind}for _, {var} := range {iter_s} {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -186,6 +210,10 @@ class GoEmitter(Emitter):
             name = node.target.id
             ann_type = self._ann_type(node.annotation)
             nt = self.py_to_native(ann_type)
+            if ann_type == "list" and node.value is not None:
+                elem = self._list_elem_of_value(node.value)
+                if elem and elem != self.spec.list_elem_type:
+                    nt = self.spec.list_type.format(T=elem)
             if node.value is not None:
                 val = self.expr(node.value)
                 self.lines.append(f"{self.spec.indent * self.indent_lvl}var {name} {nt} = {val}")
@@ -211,7 +239,8 @@ class GoEmitter(Emitter):
     def _ann_type(self, node: ast.AST) -> str:
         if isinstance(node, ast.Name):
             t = node.id
-            if t in ("int", "float", "bool", "str", "list", "dict", "tuple"):
+            if t in ("int", "float", "bool", "str", "list", "dict",
+                     "tuple", "set"):
                 return t
             if t in self.class_names:
                 return t
@@ -276,6 +305,11 @@ def emit_go(units: list[FuncUnit], entry: str | None,
     extern_fns: functions from other backends that this Go code calls.
     """
     emitter = GoEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
     emitted: dict[str, str] = {}
@@ -294,6 +328,7 @@ def emit_go(units: list[FuncUnit], entry: str | None,
         "package main\n\n"
         'import "fmt"\n'
         'import "strings"\n'
+        'import "strconv"\n'
         'import "sort"\n'
         'import "os"\n'
         'import "math"\n'
@@ -369,6 +404,10 @@ def emit_go(units: list[FuncUnit], entry: str | None,
         else:
             wrapper = f"func main() {{\n\t_ = {entry_u.name}()\n}}\n"
         fns.append(wrapper)
+    elif not fns:
+        # the entry function was rejected during emission; the pipeline
+        # already holds the reason, so return what we have
+        return prelude + "\n".join(fns), emitted
     else:
         # Go main() must have no arguments and no return values
         # Rename the user's main() to __ge_main() and add a wrapper

package/python/pyeffic/emitters/kotlin.py

@@ -14,9 +14,18 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="kotlin",
     types={"int": "Long", "float": "Double", "bool": "Boolean", "str": "String", "None": "Unit"},
-    list_type="MutableList<Long>",
+    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()",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi} step {step})",
@@ -25,8 +34,9 @@ SPEC = Spec(
     print_int='println({v})',
     print_float='println({v})',
     print_str='println({v})',
-    print_bool='println({v})',
+    print_bool='println(if ({v}) "True" else "False")',
     print_generic='println({v})',
+    print_list='println({v}.joinToString(", ", "[", "]"))',
     int_cast="{x}.toLong()",
     float_cast="{x}.toDouble()",
     float_div="({l}.toDouble() / {r}.toDouble())",
@@ -34,9 +44,13 @@ SPEC = Spec(
     sum_call="{it}.sum()",
     abs_int="abs({x})",
     abs_float="abs({x})",
+    min2_call="minOf({a}, {b})",
+    max2_call="maxOf({a}, {b})",
     min_call="{it}.minOrNull()!!",
     max_call="{it}.maxOrNull()!!",
-    pow_call="Math.pow({l}.toDouble(), {r}.toDouble()).toLong()",
+    pow_call="{l}.toDouble().pow({r}.toDouble()).toLong()",
+    pow_int="{l}.toDouble().pow({r}.toDouble()).toLong()",
+    pow_float="{l}.pow({r})",
     append_call="{x}.add({v})",
     index_call="{x}[{i}.toInt()]",
     comment="//",
@@ -58,8 +72,10 @@ SPEC = Spec(
     struct_field_template="    val {type}: {name},",
     struct_new_template="fun {name}_new({params}): {name} {{\n{body}\n}}",
     dict_type="HashMap<String, {V}>",
-    dict_get="{d}[{k}]",
+    set_type="MutableSet<Long>",
+    dict_get="{d}[{k}]!!",
     dict_set="{d}[{k}] = {v}",
+    dict_keys="{x}.keys",
     dict_contains="{d}.containsKey({k})",
     tuple_type="Pair<{T}, {T}>",
     tuple_get="{t}.{field}",
@@ -146,8 +162,12 @@ class KotlinEmitter(Emitter):
             self.lines.append(f"{ind}for ({var} in {lo} until {hi}) {{")
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "long"
-            self.lines.append(f"{ind}for ({var} in {iter_s}) {{")
+            if self.infer_type(it) == "dict":
+                self.var_types[var] = "str"
+                self.lines.append(f"{ind}for ({var} in {iter_s}.keys) {{")
+            else:
+                self.var_types[var] = "long"
+                self.lines.append(f"{ind}for ({var} in {iter_s}) {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -217,6 +237,11 @@ def emit_kotlin(units: list[FuncUnit], entry: str | None,
     extern_fns: functions from other backends that this Kotlin code calls.
     """
     emitter = KotlinEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
     emitted: dict[str, str] = {}
@@ -295,6 +320,9 @@ def emit_kotlin(units: list[FuncUnit], entry: str | None,
         else:
             wrapper = f"fun main() {{\n    {entry_u.name}()\n}}\n"
         fns.append(wrapper)
+    elif not fns:
+        # entry rejected during emission; see the pipeline diagnostic
+        return prelude + "\n".join(fns), emitted
     else:
         # Kotlin main() must return Unit (void)
         # Rename the user's main() to __ge_main() and add a wrapper

package/python/pyeffic/emitters/rust.py

@@ -12,6 +12,15 @@ 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()",
     borrow_list_arg=True,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi}).step_by({step} as usize)",
@@ -20,25 +29,32 @@ SPEC = Spec(
     print_int='println!("{{}}", {v})',
     print_float='println!("{{}}", {v})',
     print_str='println!("{{}}", {v})',
-    print_bool='println!("{{}}", {v})',
+    print_bool='println!("{{}}", if {v} {{ "True" }} else {{ "False" }})',
     print_generic='println!("{{:?}}", {v})',
+    print_list='println!("{{:?}}", {v})',
     int_cast="{x} as i64",
     float_cast="{x} as f64",
     float_div="({l} as f64 / {r} as f64)",
     floor_div="({l} / {r})",
     sum_call="{it}.iter().sum::<i64>()",
-    abs_int="{x}.abs()",
+    abs_int="i64::abs({x})",
     abs_float="{x}.abs()",
+    min2_call="std::cmp::min({a}, {b})",
+    max2_call="std::cmp::max({a}, {b})",
     min_call="{it}.iter().min().unwrap()",
     max_call="{it}.iter().max().unwrap()",
     pow_call="{l}.pow({r} as u32)",
+    pow_int="i64::pow({l}, {r} as u32)",
+    pow_float="f64::powf({l}, {r})",
     append_call="{x}.push({v})",
     index_call="{x}[{i} as usize]",
     comment="//",
     fn_template="{sig} {{\n{body}\n}}",
     main_template="",
     ffi_prefix="#[no_mangle]\npub extern \"C\" ",
-    str_concat="{l} + &{r}",
+    # `String + &String` is not Add in Rust and `a + b` moves `a`, so a
+    # format! is used instead — always correct, and it accepts &str too.
+    str_concat="format!(\"{{}}{{}}\", {l}, {r})",
     str_len="{x}.len() as i64",
     str_index="{x}.as_bytes()[{i} as usize] as i64",
     str_slice="{x}[{start}..{end}].to_string()",
@@ -46,14 +62,19 @@ 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},",
     struct_new_template="fn {name}_new({params}) -> {name} {{\n{body}\n}}",
     dict_type="std::collections::HashMap<String, {V}>",
+    set_type="std::collections::HashSet<i64>",
     dict_get="{d}.get(&{k}).copied().unwrap_or(0)",
     dict_set="{d}.insert({k}, {v})",
+    dict_keys="{x}.keys().cloned().collect::<Vec<String>>()",
+    foreach_dict_template="for {var} in {iter}",
     dict_contains="{d}.contains_key(&{k})",
     tuple_type="({T}, {T})",
     tuple_get="{t}.{i}",
@@ -188,6 +209,11 @@ def emit_rust(units: list[FuncUnit], entry: str | None,
     constants: module-level constants to inline (name -> value).
     """
     emitter = RustEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.export_names = set(export_fns) if export_fns else set()
     emitter.constants = constants or {}