Minimal name-mangling in Ruby backend. Demo "Parse, don't validate".

README.md

@@ -1123,34 +1123,77 @@ you can in actuality create recursive, but finite, data structures.
 
 You may want to use helper functions to hide this ugliness.
 
-    /| struct list {
-    /|   value: string;
-    /|   next: list|void;
-    /| }
-    /| fun singleton(v: string) {
-    /|   make list(value:v, next:null as list|void)
-    /| }
-    /| fun cons(v: string, l: list) {
-    /|   make list(value:v, next:l as list|void)
-    /| }
-    /| fun nth(n, l: list) {
-    /|   u = l as list|void;
-    /|   v = u;
-    /|   k = n;
-    /|   while k > 1 {
-    /|     typecase u is void { break; }
-    /|     typecase u is list { v = u.next; }
-    /|     u = v;
-    /|     k = k - 1;
-    /|   }
-    /|   return u
-    /| }
-    /| main = fun() {
-    /|   l = cons("first", singleton("second"));
-    /|   g = nth(2, l);
-    /|   typecase g is list { print(g.value); }
-    /| }
-    /= second
+    | struct list {
+    |   value: string;
+    |   next: list|void;
+    | }
+    | 
+    | fun empty() {
+    |   return null as list|void
+    | }
+    | 
+    | fun cons(v: string, l: list|void) {
+    |   make list(value:v, next:l) as list|void
+    | }
+    | 
+    | fun nth(n, l: list|void) {
+    |   u = l;
+    |   v = u;
+    |   k = n;
+    |   while k > 1 {
+    |     typecase u is void { break; }
+    |     typecase u is list { v = u.next; }
+    |     u = v;
+    |     k = k - 1;
+    |   }
+    |   return u
+    | }
+    | 
+    | main = fun() {
+    |   l = cons("first", cons("second", cons("third", empty())));
+    |   h = nth(2, l);
+    |   typecase h is list { print(h.value); }
+    | }
+    = second
+
+And in fact, you can restrict the union types to smaller sets to
+better indicate the allowable types of the functions.  For example,
+`cons` always returns a list, so that should be its return type,
+not `list|void`.  Likewise, `nth` requires a list.  In this way we
+can implement some of the "Parse, don't Validate" approach.
+
+    | struct list {
+    |   value: string;
+    |   next: list|void;
+    | }
+    | 
+    | fun cons(v: string, l: list) {
+    |   make list(value:v, next:l as list|void)
+    | }
+    | 
+    | fun singleton(v: string) {
+    |   make list(value:v, next:null as list|void)
+    | }
+    | 
+    | fun nth(n, l: list) {
+    |   u = l as list|void;
+    |   v = u;
+    |   k = n;
+    |   while k > 1 {
+    |     typecase u is void { break; }
+    |     typecase u is list { v = u.next; }
+    |     u = v;
+    |     k = k - 1;
+    |   }
+    |   return u
+    | }
+    | 
+    | main = fun() {
+    |   l = cons("first", cons("second", singleton("third")));
+    |   h = nth(2, l);
+    |   typecase h is list { print(h.value); }
+    | }
+    = second
 
 Structs may be empty.
 

src/castile/backends/ruby.py

@@ -83,6 +83,11 @@ def write_indent(self, x):
         self.out.write('  ' * self.indent)
         self.out.write(x)
 
+    def mangle(self, ident):
+        if ident.startswith('next'):
+            return '{}_'.format(ident)
+        return ident
+
     def compile(self, ast):
         if ast.tag == 'Program':
             self.write(PRELUDE)
@@ -117,7 +122,7 @@ def compile(self, ast):
             for child in ast.children:
                 self.compile(child)
         elif ast.tag == 'VarDecl':
-            self.write_indent('%s = nil;\n' % ast.value)
+            self.write_indent('%s = nil;\n' % self.mangle(ast.value))
         elif ast.tag == 'Block':
             for child in ast.children:
                 self.compile(child)
@@ -137,7 +142,7 @@ def compile(self, ast):
             self.compile(ast.children[1])
             self.write(')')
         elif ast.tag == 'VarRef':
-            self.write(ast.value)
+            self.write(self.mangle(ast.value))
         elif ast.tag == 'FunCall':
             self.compile(ast.children[0])
             self.write('.call(')