sutra-dev 0.9.3__tar.gz → 0.9.4__tar.gz

{sutra_dev-0.9.3/sutra_dev.egg-info → sutra_dev-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sutra-dev
-Version: 0.9.3
+Version: 0.9.4
 Summary: Compiler for the Sutra programming language — tensor ops on frozen-LLM embedding vectors.
 Author: Emma Leonhart
 License-Expression: AGPL-3.0-only

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sutra-dev"
-version = "0.9.3"
+version = "0.9.4"
 description = "Compiler for the Sutra programming language — tensor ops on frozen-LLM embedding vectors."
 readme = "README.md"
 requires-python = ">=3.11"

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/sutra_compiler/__init__.py

@@ -28,7 +28,7 @@ The compiler is intentionally liberal where the spec is still open
 forms and flags the clearly-forbidden ones.
 """
 
-__version__ = "0.9.3"
+__version__ = "0.9.4"
 
 from .diagnostics import Diagnostic, DiagnosticLevel, DiagnosticBag
 from .lexer import Lexer, Token, TokenKind

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/sutra_compiler/codegen.py

@@ -246,6 +246,18 @@ class Codegen(BaseCodegen):
         meaningful signal there.
         """
         assert op in ("eq", "neq")
+        # Number-family operands (int/number, incl. arithmetic results
+        # like `n % 3`) route through the exact relu indicator (Emma
+        # 2026-07-08): cosine is degenerate at the zero vector, so a
+        # runtime zero could never == anything — zero-testing was
+        # unreachable. Torch-runtime only (the deprecated numpy backend
+        # keeps its old routing).
+        if (getattr(self, "supports_cast_lowering", False)
+                and self._CAST_FAMILY.get(
+                    self._infer_cast_operand_type(expr.left)) == "number"
+                and self._CAST_FAMILY.get(
+                    self._infer_cast_operand_type(expr.right)) == "number"):
+            return f"_VSA.num_{op}({left_src}, {right_src})"
         if (self._is_synthetic_axis_expr(expr.left)
                 and self._is_synthetic_axis_expr(expr.right)):
             return f"_VSA.{op}_synthetic({left_src}, {right_src})"

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/sutra_compiler/codegen_base.py

@@ -702,6 +702,19 @@ class BaseCodegen:
     def translate(self, module: ast.Module) -> str:
         self._emit_prelude()
         self._emit()
+        # Pre-pass 0: record every top-level user function's declared
+        # return type, so expression-type checks (e.g. the text-concat
+        # dispatch asking "does f(x) return a string?") can resolve
+        # FORWARD references — a call site is often translated before
+        # its callee. _resolved_return_type only knows class methods and
+        # the stdlib; without this map, `f(1) + " "` with a user
+        # `function string f` fell to the numeric path and crashed at
+        # runtime (round-23 audit).
+        self._user_fn_return_types: dict[str, str] = {}
+        for item in module.items:
+            if (isinstance(item, ast.FunctionDecl)
+                    and item.return_type is not None):
+                self._user_fn_return_types[item.name] = item.return_type.name
         # Pre-pass A: pull in stdlib class intrinsics (e.g.
         # `Tensor.MatrixMul`, `Tensor.matmul`, etc.) so namespaced
         # stdlib calls dispatch to `_VSA.<name>` even though the
@@ -2634,10 +2647,21 @@ class BaseCodegen:
                 f"unroll by hand.",
             )
         if isinstance(stmt, ast.IfStmt):
+            # Design commitment, not a gap (control-flow.md § "`if` /
+            # `else` is parsed but rejected at codegen"): Sutra
+            # conditionals are weighted superpositions, not discrete
+            # branches. The message must hand the newcomer the actual
+            # rewrite, not just the philosophy (round-23 audit).
             raise CodegenNotSupported(
                 stmt,
-                "if/else is not supported by the V1 codegen — the whole "
-                "point is to compile it away into a prototype-table lookup",
+                "`if`/`else` never compiles — by design, Sutra "
+                "conditionals are weighted superpositions, not discrete "
+                "branches. Write `select([score_a, score_b, ...], "
+                "[result_a, result_b, ...])`: the highest score's result "
+                "dominates the output. A boolean two-way branch is "
+                "`select([is_true(cond), is_true(!cond)], [then_value, "
+                "else_value])`. See the control-flow docs and "
+                "examples/fuzzy_dispatch.su for the idiom.",
             )
         if isinstance(stmt, ast.TryStmt):
             self._translate_try_catch(stmt)
@@ -3042,6 +3066,10 @@ class BaseCodegen:
             return (self._is_text_expr(expr.left)
                     and self._is_text_expr(expr.right))
         if isinstance(expr, ast.Call):
+            if (isinstance(expr.callee, ast.Identifier)
+                    and getattr(self, "_user_fn_return_types", {}).get(
+                        expr.callee.name) in self._TEXT_TYPES):
+                return True
             return self._resolved_return_type(expr.callee) in self._TEXT_TYPES
         return False
 

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/sutra_compiler/codegen_pytorch.py

@@ -2910,12 +2910,17 @@ class PyTorchCodegen(Codegen):
         self._emit('was a host `for k in range`, `.item()`, host `if`, host')
         self._emit('`return k+1`). Gather the codepoint block, mark non-zero')
         self._emit('positions, take the highest 1-based position that is')
-        self._emit('non-zero: length = max((k+1) where cps[k] != 0). All tensor')
+        self._emit('non-zero: length = max((k+1) where cps[k] >= 0.5). All tensor')
         self._emit('ops; 0-d tensor out. Trailing-zero-as-sentinel preserved')
-        self._emit('(a 0 codepoint in the tail reads shorter, same as before)."""')
+        self._emit('(a 0 codepoint in the tail reads shorter, same as before).')
+        self._emit('The 0.5 threshold (was `!= 0`) makes decode robust to')
+        self._emit('superposition residue: a String coming out of select() carries')
+        self._emit('~1e-9 leakage from losing branches on higher codepoint axes,')
+        self._emit('which the exact-nonzero walk counted as characters (phantom')
+        self._emit('NULs). Real codepoints are >= 32; residue is << 1."""')
         self._emit("ax = self._str_axes()")
         self._emit("cps = v.index_select(0, ax)")
-        self._emit("nz = (cps != 0).to(self.dtype)")
+        self._emit("nz = (cps.abs() >= 0.5).to(self.dtype)")
         self._emit("pos = _torch.arange(1, ax.shape[0] + 1, dtype=self.dtype, device=self.device)")
         self._emit("return (pos * nz).max()")
         self._indent -= 1
@@ -3334,7 +3339,10 @@ class PyTorchCodegen(Codegen):
         self._emit("for i in range(n):")
         self._indent += 1
         self._emit("axis = self._string_axis(i)")
-        self._emit("chars.append(chr(int(v[self.semantic_dim + axis].item())))")
+        self._emit("# round(), not int(): a select() superposition leaves the")
+        self._emit("# winner's codepoints at ~(1-eps)*cp — int() truncated 101.9997")
+        self._emit("# to 101 and garbled every decoded character by one.")
+        self._emit("chars.append(chr(round(v[self.semantic_dim + axis].item())))")
         self._indent -= 1
         self._emit('return "".join(chars)')
         self._indent -= 1
@@ -3594,6 +3602,34 @@ class PyTorchCodegen(Codegen):
         self._emit("return out")
         self._indent -= 1
         self._emit()
+        # Number-family equality — the exact relu indicator (Emma
+        # 2026-07-08). Cosine eq is DEGENERATE at the zero vector
+        # (cos(0,v) is 0/0 → a runtime zero can never equal anything,
+        # including zero), which made zero-testing unreachable — see
+        # planning/findings/2026-07-08-zero-equality-reads-neutral-
+        # cosine-degenerate.md.
+        self._emit("def num_eq(self, a, b):")
+        self._indent += 1
+        self._emit('"""Number == number via the exact indicator:')
+        self._emit('truth = 2*relu(1 - |x - y|) - 1 — +1 at equal, -1 at')
+        self._emit('|diff| >= 1 (exact gap 2.0 at integer spacing, no residual;')
+        self._emit('the neural-Unix keystone on the truth convention). Fractional')
+        self._emit('nearness interpolates linearly (|d|=0.5 -> 0, neutral). The')
+        self._emit('unit width is a trainable-surface candidate (a gain k on |d|),')
+        self._emit('fixed at 1 today. All tensor ops; differentiable a.e."""')
+        self._emit("d = _torch.abs(self._scalar(a) - self._scalar(b))")
+        self._emit("truth = 2.0 * _torch.clamp(1.0 - d, min=0.0) - 1.0")
+        self._emit("out = _torch.zeros(self.dim, dtype=self.dtype, device=self.device)")
+        self._emit("out[self.semantic_dim + self.AXIS_TRUTH] = truth")
+        self._emit("return out")
+        self._indent -= 1
+        self._emit()
+        self._emit("def num_neq(self, a, b):")
+        self._indent += 1
+        self._emit('"""!= for number-family values — truth-axis negation of num_eq."""')
+        self._emit("return -self.num_eq(a, b)")
+        self._indent -= 1
+        self._emit()
         # Synthetic-axis equality — Euclidean distance + tanh
         # (2026-05-08 directive). For int / float / complex / char /
         # string operands; cosine doesn't distinguish well between

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/sutra_compiler/repl.py

@@ -45,7 +45,7 @@ _EVAL_WRAP_TYPES = {"string"}
 _BANNER = (
     "Sutra REPL - type an expression to evaluate it; end a line with ';' or '}' "
     "to add a declaration.\n"
-    "Commands: :help  :decls  :reset  :quit\n"
+    "Commands: :help  :ops  :decls  :reset  :quit\n"
 )
 _HELP = (
     "Sutra REPL help\n"
@@ -53,12 +53,54 @@ _HELP = (
     "                      (number -> real value; concept -> nearest known string)\n"
     "  <stmt>;             add a declaration/statement to the session (e.g. vector k = embed(\"king\");)\n"
     "  function ... { }    add a function to the session\n"
+    "  :ops                list the callable operations (builtins, stdlib, special forms)\n"
     "  :decls              print the accumulated session declarations\n"
     "  :reset              clear all session declarations\n"
     "  :help               this help\n"
     "  :quit  / :q         leave the REPL (Ctrl-D also works)\n"
 )
 
+
+def _ops_listing() -> str:
+    """The `:ops` discovery surface: every operation callable from REPL
+    source, grouped. Built from the live dispatch tables (BUILTINS + the
+    stdlib intrinsic registry) so it cannot drift from what actually
+    resolves — a hand-written list here would rot."""
+    from .codegen_base import BUILTINS
+    try:
+        from .stdlib_loader import stdlib_class_intrinsic_methods
+        stdlib = stdlib_class_intrinsic_methods()
+    except Exception:
+        stdlib = {}
+
+    def _columns(names, indent="    ", width=76):
+        lines, cur = [], indent
+        for n in names:
+            if len(cur) + len(n) + 2 > width and cur.strip():
+                lines.append(cur.rstrip())
+                cur = indent
+            cur += n + "  "
+        if cur.strip():
+            lines.append(cur.rstrip())
+        return "\n".join(lines)
+
+    parts = ["Operations callable from Sutra source in this REPL\n"]
+    parts.append("  builtins:\n" + _columns(sorted(BUILTINS.keys())) + "\n")
+    for cls in sorted(stdlib):
+        methods = sorted(stdlib[cls])
+        if not methods:
+            continue
+        parts.append(f"  {cls} (call bare or as {cls}.<name>):\n"
+                     + _columns(methods) + "\n")
+    parts.append(
+        "  special forms:\n"
+        "    embed(\"...\")   defuzzy(v)   unsafeCast<T>(v)   unsafeOverride(v)\n"
+        "    (Type) expr casts   $\"text {interpolant}\" interpolation\n"
+    )
+    parts.append(
+        "  full reference: https://sutra.topazcomputing.com/capabilities/\n")
+    return "".join(parts)
+
 _EVAL_FN = "__repl_eval__"
 
 
@@ -238,6 +280,8 @@ def run_repl(
             break
         if stripped == ":help":
             out.write(_HELP); out.flush(); continue
+        if stripped == ":ops":
+            out.write(_ops_listing()); out.flush(); continue
         if stripped == ":reset":
             decls.clear(); out.write("(session cleared)\n"); out.flush(); continue
         if stripped == ":decls":

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/sutra_compiler/stdlib/logic.su

@@ -129,16 +129,20 @@ function fuzzy lt(complex a, complex b) {
 }
 
 
-// ge / le — on the differentiable-tanh scheme, `>=` and `<=` collapse
-// to `>` and `<`: both give tanh(0) = 0 on exact ties. Programs that
-// need to distinguish strict from tie compose with `==` (cosine
-// similarity, crisp on identical operands).
-function fuzzy ge(complex a, complex b) {
-    return a > b;
+// ge / le — or(strict, ==) per Emma 2026-07-08 (the previous
+// collapse-to-strict gave tanh(0) = 0 on exact ties, so the standard
+// loop guard `i <= n` read NEUTRAL at the boundary — finding
+// 2026-07-06-le-ge-tie-returns-neutral). The params are number-typed
+// so the `==` component dispatches to the exact num_eq indicator:
+// ties read +1, and the false directions stay exactly -1
+// (max(-1, -1)) instead of softening through cosine. `||` is the
+// truth-axis max.
+function fuzzy ge(number a, number b) {
+    return (a > b) || (a == b);
 }
 
-function fuzzy le(complex a, complex b) {
-    return a < b;
+function fuzzy le(number a, number b) {
+    return (a < b) || (a == b);
 }
 
 

{sutra_dev-0.9.3 → sutra_dev-0.9.4/sutra_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sutra-dev
-Version: 0.9.3
+Version: 0.9.4
 Summary: Compiler for the Sutra programming language — tensor ops on frozen-LLM embedding vectors.
 Author: Emma Leonhart
 License-Expression: AGPL-3.0-only

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/sutra_dev.egg-info/SOURCES.txt

@@ -99,6 +99,7 @@ tests/test_int_dict.py
 tests/test_int_to_string.py
 tests/test_interp_string_codegen.py
 tests/test_jvm_core.py
+tests/test_le_ge_ties.py
 tests/test_lexer.py
 tests/test_list_ops.py
 tests/test_load_matrix.py
@@ -112,6 +113,7 @@ tests/test_multi_process_runtime.py
 tests/test_native_recursion.py
 tests/test_no_host_readout.py
 tests/test_ntm_ram.py
+tests/test_num_eq_indicator.py
 tests/test_optional_llm_model.py
 tests/test_parser.py
 tests/test_preeval.py

sutra_dev-0.9.4/tests/test_le_ge_ties.py

@@ -0,0 +1,59 @@
+"""`<=` / `>=` at exact ties (Emma decided 2026-07-08: adopt or(<, ==)).
+
+Before: stdlib le/ge collapsed to the strict ops — `2 <= 2` read
+tanh(0) = 0 (NEUTRAL), so the standard loop guard `i <= n` misbehaved
+at the boundary. Now `le = or(<, ==)` / `ge = or(>, ==)` with the ==
+component on the exact num_eq indicator: ties read +1, and both
+false directions stay exactly -1 (max(-1, -1)).
+"""
+from __future__ import annotations
+
+import unittest
+
+from sutra_compiler.lexer import Lexer
+from sutra_compiler.parser import Parser
+from sutra_compiler.codegen_pytorch import translate_module
+
+
+def _truth(expr: str, dim: int = 16) -> float:
+    src = f"function fuzzy main(){{ int x = 2; int y = 2; return {expr}; }}"
+    lx = Lexer(src, file="<t>")
+    ast = Parser(lx.tokenize(), file="<t>", diagnostics=lx.diagnostics).parse_module()
+    assert not lx.diagnostics.has_errors(), list(lx.diagnostics)
+    ns: dict = {}
+    exec(translate_module(ast, llm_model="none", runtime_dim=dim), ns)
+    r = ns["main"]()
+    v = ns["_VSA"]
+    if not hasattr(r, "ndim") or r.ndim == 0:
+        return float(r)
+    return float(r[v.semantic_dim + v.AXIS_TRUTH])
+
+
+class TestTies(unittest.TestCase):
+    def test_le_tie_true(self):
+        self.assertAlmostEqual(_truth("2 <= 2"), 1.0, places=4)
+
+    def test_ge_tie_true(self):
+        self.assertAlmostEqual(_truth("2 >= 2"), 1.0, places=4)
+
+    def test_var_tie(self):
+        self.assertAlmostEqual(_truth("x <= y"), 1.0, places=4)
+
+
+class TestStrictUnchanged(unittest.TestCase):
+    def test_le_true_direction(self):
+        self.assertAlmostEqual(_truth("2 <= 3"), 1.0, places=4)
+
+    def test_le_false_direction_stays_crisp(self):
+        self.assertAlmostEqual(_truth("3 <= 2"), -1.0, places=4)
+
+    def test_ge_false_direction_stays_crisp(self):
+        self.assertAlmostEqual(_truth("2 >= 3"), -1.0, places=4)
+
+    def test_strict_lt_tie_still_neutral(self):
+        # strict < at a tie is tanh(0) = 0 — deliberately unchanged.
+        self.assertAlmostEqual(_truth("2 < 2"), 0.0, places=4)
+
+
+if __name__ == "__main__":
+    unittest.main()

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/tests/test_no_host_readout.py

@@ -32,7 +32,9 @@ import pytest
 #   - _js_str_cmp — JS-interop carve-out (host string comparison).
 # GOAL: 0 for genuine introspection; the above are sanctioned I/O/JS/control
 # boundaries. Only ever lower this.
-BASELINE_ITEM_READOUTS = 18
+# 18 -> 17 on 2026-07-08: retiring the dead is_char alias removed its
+# .item() flag-read (round-19). Progress toward 0.
+BASELINE_ITEM_READOUTS = 17
 
 
 def _generated_runtime_source() -> str:

sutra_dev-0.9.4/tests/test_num_eq_indicator.py

@@ -0,0 +1,96 @@
+"""Number-family `==` via the exact relu indicator (Emma 2026-07-08).
+
+Cosine `==` is degenerate at the zero vector — `(15 % 3) == 0` read
+NEUTRAL, making zero-testing (divisibility, emptiness, termination)
+unreachable (finding 2026-07-08-zero-equality-reads-neutral...).
+Emma's pick: number-family operands route through
+`truth = 2·relu(1 − |x−y|) − 1` — +1 at equal, −1 at |diff| ≥ 1,
+exact gap 2.0 at integer spacing, all tensor ops, differentiable a.e.
+Cosine `==` stays for vector/semantic operands; the Euclidean
+`eq_synthetic` stays for string/char/complex.
+"""
+from __future__ import annotations
+
+import unittest
+
+from sutra_compiler.lexer import Lexer
+from sutra_compiler.parser import Parser
+from sutra_compiler.codegen_pytorch import translate_module
+
+
+def _truth(src: str, dim: int = 16) -> float:
+    lx = Lexer(src, file="<t>")
+    ast = Parser(lx.tokenize(), file="<t>", diagnostics=lx.diagnostics).parse_module()
+    assert not lx.diagnostics.has_errors(), list(lx.diagnostics)
+    ns: dict = {}
+    exec(translate_module(ast, llm_model="none", runtime_dim=dim), ns)
+    r = ns["main"]()
+    v = ns["_VSA"]
+    if not hasattr(r, "ndim") or r.ndim == 0:
+        return float(r)
+    return float(r[v.semantic_dim + v.AXIS_TRUTH])
+
+
+class TestZeroEquality(unittest.TestCase):
+    def test_mod_zero_is_true(self):
+        # THE finding case: was 0.0 (neutral), must be +1.
+        self.assertAlmostEqual(_truth(
+            "function fuzzy main(){ return (15 % 3) == 0; }"), 1.0, places=4)
+
+    def test_mod_nonzero_is_false(self):
+        self.assertAlmostEqual(_truth(
+            "function fuzzy main(){ return (16 % 3) == 0; }"), -1.0, places=4)
+
+    def test_runtime_zero_vars(self):
+        self.assertAlmostEqual(_truth(
+            "function fuzzy main(){ number x = make_real(0.0); "
+            "return x == 0; }"), 1.0, places=4)
+
+
+class TestIntegerEquality(unittest.TestCase):
+    def test_equal_ints(self):
+        self.assertAlmostEqual(_truth(
+            "function fuzzy main(){ int a = 2; int b = 2; return a == b; }"),
+            1.0, places=4)
+
+    def test_unequal_ints(self):
+        self.assertAlmostEqual(_truth(
+            "function fuzzy main(){ int a = 2; int b = 3; return a == b; }"),
+            -1.0, places=4)
+
+    def test_neq(self):
+        self.assertAlmostEqual(_truth(
+            "function fuzzy main(){ int a = 2; int b = 3; return a != b; }"),
+            1.0, places=4)
+        self.assertAlmostEqual(_truth(
+            "function fuzzy main(){ int a = 2; int b = 2; return a != b; }"),
+            -1.0, places=4)
+
+
+class TestFizzBuzzEndToEnd(unittest.TestCase):
+    def test_fizzbuzz_via_select(self):
+        src = '''
+function string fizzbuzz(int n) {
+    number s3 = (number) ((n % 3) == 0);
+    number s5 = (number) ((n % 5) == 0);
+    return select(
+        [10 * (s3 + s5), 10 * (s3 - s5), 10 * (s5 - s3), 10 * (0 - s3 - s5)],
+        [make_string("fizzbuzz"), make_string("fizz"),
+         make_string("buzz"), int_to_string(n)]);
+}
+function string main() {
+    return fizzbuzz(15) + " " + fizzbuzz(3) + " " + fizzbuzz(5) + " " + fizzbuzz(7);
+}
+'''
+        lx = Lexer(src, file="<t>")
+        ast = Parser(lx.tokenize(), file="<t>",
+                     diagnostics=lx.diagnostics).parse_module()
+        assert not lx.diagnostics.has_errors()
+        ns: dict = {}
+        exec(translate_module(ast, llm_model="none", runtime_dim=64), ns)
+        got = ns["_VSA"].string_to_python(ns["main"]())
+        self.assertEqual(got, "fizzbuzz fizz buzz 7")
+
+
+if __name__ == "__main__":
+    unittest.main()

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/tests/test_repl.py

@@ -114,3 +114,19 @@ def test_scalar_tensor_result_shows_clean_number_not_repr():
     out = _decode_result(_Mod(), torch.tensor(0.6812))
     assert "tensor(" not in out and "device=" not in out
     assert out == "= 0.6812"
+
+
+def test_ops_lists_builtins_stdlib_and_special_forms():
+    # :ops is built from the LIVE dispatch tables, so it must show a
+    # builtin, a String intrinsic (incl. the new int_to_string), and
+    # the special forms — the REPL's stdlib-discovery surface
+    # (usability round 22).
+    out = _drive([":ops", ":quit"])
+    for needle in ("bundle", "argmax_cosine", "string_concat",
+                   "int_to_string", "embed(", "unsafeCast", "capabilities"):
+        assert needle in out, f"missing {needle!r} in :ops output"
+
+
+def test_help_mentions_ops():
+    out = _drive([":help", ":quit"])
+    assert ":ops" in out

{sutra_dev-0.9.3 → sutra_dev-0.9.4}/tests/test_string_plus_concat.py

@@ -80,5 +80,23 @@ class TestNumericPlusUntouched(unittest.TestCase):
             3.5, places=4)
 
 
+class TestUserFunctionReturnConcat(unittest.TestCase):
+    def test_user_string_function_plus_literal(self):
+        # Round-23 regression: `f(x) + " "` with a user-declared
+        # `function string f` crashed at runtime (Tensor + str) — the
+        # text dispatch only knew stdlib/class return types, so the
+        # literal stayed a host str on the numeric path.
+        self.assertEqual(_run_text(
+            'function string shout(string s){ return s + "!"; }\n'
+            'function string main(){ return shout("hi") + " there"; }'),
+            "hi! there")
+
+    def test_chained_user_calls(self):
+        self.assertEqual(_run_text(
+            'function string tag(int n){ return int_to_string(n); }\n'
+            'function string main(){ return tag(1) + "-" + tag(2); }'),
+            "1-2")
+
+
 if __name__ == "__main__":
     unittest.main()