diff --git a/Makefile b/Makefile
index caedaae..f94f27b 100644
--- a/Makefile
+++ b/Makefile
@@ -27,7 +27,7 @@ LDLIBS=-lgc -lcord -lm -lunistring
 BUILTIN_OBJS=builtins/array.o builtins/bool.o builtins/color.o builtins/nums.o builtins/functions.o builtins/integers.o \
 						 builtins/pointer.o builtins/memory.o builtins/text.o builtins/table.o builtins/types.o builtins/util.o builtins/files.o
 
-all: libtomo.so tomo
+all: libtomo.so tomo repl.o
 
 tomo: tomo.c SipHash/halfsiphash.o ast.o parse.o environment.o types.o typecheck.o structs.o enums.o compile.o $(BUILTIN_OBJS)
 
diff --git a/ast.c b/ast.c
index e0354f5..e47ba57 100644
--- a/ast.c
+++ b/ast.c
@@ -26,9 +26,9 @@ static CORD optional_tagged_type(const char *tag, type_ast_t *ast);
 
 CORD xml_escape(CORD text)
 {
-    text = Text__replace(text, "&", "&", INT64_MAX);
-    text = Text__replace(text, "<", "&lt;", INT64_MAX);
-    text = Text__replace(text, ">", "&gt;", INT64_MAX);
+    text = Text$replace(text, "&", "&amp;", INT64_MAX);
+    text = Text$replace(text, "<", "&lt;", INT64_MAX);
+    text = Text$replace(text, ">", "&gt;", INT64_MAX);
     return text;
 }
 
diff --git a/builtins/array.c b/builtins/array.c
index 6ebc642..8b50dbc 100644
--- a/builtins/array.c
+++ b/builtins/array.c
@@ -22,7 +22,7 @@ static inline size_t get_item_size(const TypeInfo *info)
 
 // Replace the array's .data pointer with a new pointer to a copy of the
 // data that is compacted and has a stride of exactly `item_size`
-public void Array__compact(array_t *arr, const TypeInfo *type)
+public void Array$compact(array_t *arr, const TypeInfo *type)
 {
     void *copy = NULL;
     int64_t item_size = get_item_size(type);
@@ -43,7 +43,7 @@ public void Array__compact(array_t *arr, const TypeInfo *type)
     };
 }
 
-public void Array__insert(array_t *arr, const void *item, int64_t index, const TypeInfo *type)
+public void Array$insert(array_t *arr, const void *item, int64_t index, const TypeInfo *type)
 {
     if (index <= 0) index = arr->length + index + 1;
 
@@ -75,7 +75,7 @@ public void Array__insert(array_t *arr, const void *item, int64_t index, const T
     memcpy((void*)arr->data + (index-1)*item_size, item, item_size);
 }
 
-public void Array__insert_all(array_t *arr, array_t to_insert, int64_t index, const TypeInfo *type)
+public void Array$insert_all(array_t *arr, array_t to_insert, int64_t index, const TypeInfo *type)
 {
     if (index < 1) index = arr->length + index + 1;
 
@@ -105,7 +105,7 @@ public void Array__insert_all(array_t *arr, array_t to_insert, int64_t index, co
         memcpy((void*)arr->data + (index-1 + i)*item_size, to_insert.data + i*to_insert.stride, item_size);
 }
 
-public void Array__remove(array_t *arr, int64_t index, int64_t count, const TypeInfo *type)
+public void Array$remove(array_t *arr, int64_t index, int64_t count, const TypeInfo *type)
 {
     if (index < 1) index = arr->length + index + 1;
 
@@ -138,7 +138,7 @@ public void Array__remove(array_t *arr, int64_t index, int64_t count, const Type
     arr->length -= count;
 }
 
-public void Array__sort(array_t *arr, const TypeInfo *type)
+public void Array$sort(array_t *arr, const TypeInfo *type)
 {
     const TypeInfo *item_type = type->ArrayInfo.item;
     int64_t item_size = item_type->size;
@@ -146,16 +146,16 @@ public void Array__sort(array_t *arr, const TypeInfo *type)
         item_size += item_type->align - (item_size % item_type->align); // padding
 
     if (arr->data_refcount || (int64_t)arr->stride != item_size)
-        Array__compact(arr, type);
+        Array$compact(arr, type);
 
     qsort_r(arr->data, arr->length, item_size, (void*)generic_compare, (void*)item_type);
 }
 
-public void Array__shuffle(array_t *arr, const TypeInfo *type)
+public void Array$shuffle(array_t *arr, const TypeInfo *type)
 {
     int64_t item_size = get_item_size(type);
     if (arr->data_refcount || (int64_t)arr->stride != item_size)
-        Array__compact(arr, type);
+        Array$compact(arr, type);
 
     char tmp[item_size];
     for (int64_t i = arr->length-1; i > 1; i--) {
@@ -166,7 +166,7 @@ public void Array__shuffle(array_t *arr, const TypeInfo *type)
     }
 }
 
-public void *Array__random(array_t arr)
+public void *Array$random(array_t arr)
 {
     if (arr.length == 0)
         return NULL; // fail("Cannot get a random item from an empty array!");
@@ -174,7 +174,7 @@ public void *Array__random(array_t arr)
     return arr.data + arr.stride*index;
 }
 
-public array_t Array__slice(array_t *array, int64_t first, int64_t length, int64_t stride, const TypeInfo *type)
+public array_t Array$slice(array_t *array, int64_t first, int64_t length, int64_t stride, const TypeInfo *type)
 {
     if (stride > MAX_STRIDE || stride < MIN_STRIDE)
         fail("Stride is too big: %ld", stride);
@@ -223,7 +223,7 @@ public array_t Array__slice(array_t *array, int64_t first, int64_t length, int64
     };
 }
 
-public array_t Array__reversed(array_t array)
+public array_t Array$reversed(array_t array)
 {
     array_t reversed = array;
     reversed.stride = -array.stride;
@@ -231,7 +231,7 @@ public array_t Array__reversed(array_t array)
     return reversed;
 }
 
-public array_t Array__concat(array_t x, array_t y, const TypeInfo *type)
+public array_t Array$concat(array_t x, array_t y, const TypeInfo *type)
 {
     int64_t item_size = get_item_size(type);
     void *data = x.atomic ? GC_MALLOC_ATOMIC(item_size*(x.length + y.length)) : GC_MALLOC(item_size*(x.length + y.length));
@@ -257,7 +257,7 @@ public array_t Array__concat(array_t x, array_t y, const TypeInfo *type)
     };
 }
 
-public bool Array__contains(array_t array, void *item, const TypeInfo *type)
+public bool Array$contains(array_t array, void *item, const TypeInfo *type)
 {
     const TypeInfo *item_type = type->ArrayInfo.item;
     for (int64_t i = 0; i < array.length; i++)
@@ -266,12 +266,12 @@ public bool Array__contains(array_t array, void *item, const TypeInfo *type)
     return false;
 }
 
-public void Array__clear(array_t *array)
+public void Array$clear(array_t *array)
 {
     *array = (array_t){.data=0, .length=0};
 }
 
-public int32_t Array__compare(const array_t *x, const array_t *y, const TypeInfo *type)
+public int32_t Array$compare(const array_t *x, const array_t *y, const TypeInfo *type)
 {
     // Early out for arrays with the same data, e.g. two copies of the same array:
     if (x->data == y->data && x->stride == y->stride)
@@ -298,12 +298,12 @@ public int32_t Array__compare(const array_t *x, const array_t *y, const TypeInfo
     return (x->length > y->length) - (x->length < y->length);
 }
 
-public bool Array__equal(const array_t *x, const array_t *y, const TypeInfo *type)
+public bool Array$equal(const array_t *x, const array_t *y, const TypeInfo *type)
 {
-    return (Array__compare(x, y, type) == 0);
+    return (Array$compare(x, y, type) == 0);
 }
 
-public CORD Array__as_text(const array_t *arr, bool colorize, const TypeInfo *type)
+public CORD Array$as_text(const array_t *arr, bool colorize, const TypeInfo *type)
 {
     if (!arr)
         return CORD_all("[", generic_as_text(NULL, false, type->ArrayInfo.item), "]");
@@ -320,7 +320,7 @@ public CORD Array__as_text(const array_t *arr, bool colorize, const TypeInfo *ty
     return c;
 }
 
-public uint32_t Array__hash(const array_t *arr, const TypeInfo *type)
+public uint32_t Array$hash(const array_t *arr, const TypeInfo *type)
 {
     // Array hash is calculated as a rolling, compacting hash of the length of the array, followed by
     // the hashes of its items (or the items themselves if they're small plain data)
diff --git a/builtins/array.h b/builtins/array.h
index dad72b7..9863822 100644
--- a/builtins/array.h
+++ b/builtins/array.h
@@ -15,15 +15,15 @@
     const array_t $arr = arr_expr; int64_t $index = (int64_t)(index_expr); \
     int64_t $off = $index + ($index < 0) * ($arr.length + 1) - 1; \
     if (__builtin_expect($off < 0 || $off >= $arr.length, 0)) \
-        fail_source(filename, start, end, "Invalid array index: %r (array has length %ld)\n", Int__as_text(&$index, USE_COLOR, NULL), $arr.length); \
+        fail_source(filename, start, end, "Invalid array index: %r (array has length %ld)\n", Int$as_text(&$index, USE_COLOR, NULL), $arr.length); \
     (item_type*)($arr.data + $arr.stride * $off);})
 #define $Array_lvalue(item_type, arr_expr, index_expr, typeinfo, filename, start, end) { \
     array_t *$arr = arr_expr; int64_t $index = (int64_t)(index_expr); \
     int64_t $off = $index + ($index < 0) * ($arr->length + 1) - 1; \
     if (__builtin_expect($off < 0 || $off >= $arr->length, 0)) \
-        fail_source(filename, start, end, "Invalid array index: %r (array has length %ld)\n", Int__as_text(&$index, USE_COLOR, NULL), $arr->length); \
+        fail_source(filename, start, end, "Invalid array index: %r (array has length %ld)\n", Int$as_text(&$index, USE_COLOR, NULL), $arr->length); \
     if ($arr->data_refcount > 0) \
-        Array__compact($arr, typeinfo); \
+        Array$compact($arr, typeinfo); \
     *(item_type*)($arr->data + $arr->stride * $off); }
 #define $Array_set(item_type, arr, index, value, typeinfo, filename, start, end) \
     $Array_lvalue(item_type, arr_expr, index, typeinfo, filename, start, end) = value
@@ -52,22 +52,22 @@
 #define $ARRAY_INCREF(arr) (arr).data_refcount |= ((arr).data_refcount << 1) | 1
 #define $ARRAY_DECREF(arr) (arr).data_refcount &= 2
 
-#define Array__insert_value(arr, item_expr, index, type) ({ __typeof(item_expr) $item = item_expr; Array__insert(arr, &$item, index, type); })
-void Array__insert(array_t *arr, const void *item, int64_t index, const TypeInfo *type);
-void Array__insert_all(array_t *arr, array_t to_insert, int64_t index, const TypeInfo *type);
-void Array__remove(array_t *arr, int64_t index, int64_t count, const TypeInfo *type);
-void Array__sort(array_t *arr, const TypeInfo *type);
-void Array__shuffle(array_t *arr, const TypeInfo *type);
-void *Array__random(array_t arr);
-void Array__clear(array_t *array);
-void Array__compact(array_t *arr, const TypeInfo *type);
-bool Array__contains(array_t array, void *item, const TypeInfo *type);
-array_t Array__slice(array_t *array, int64_t first, int64_t length, int64_t stride, const TypeInfo *type);
-array_t Array__reversed(array_t array);
-array_t Array__concat(array_t x, array_t y, const TypeInfo *type);
-uint32_t Array__hash(const array_t *arr, const TypeInfo *type);
-int32_t Array__compare(const array_t *x, const array_t *y, const TypeInfo *type);
-bool Array__equal(const array_t *x, const array_t *y, const TypeInfo *type);
-CORD Array__as_text(const array_t *arr, bool colorize, const TypeInfo *type);
+#define Array$insert_value(arr, item_expr, index, type) ({ __typeof(item_expr) $item = item_expr; Array$insert(arr, &$item, index, type); })
+void Array$insert(array_t *arr, const void *item, int64_t index, const TypeInfo *type);
+void Array$insert_all(array_t *arr, array_t to_insert, int64_t index, const TypeInfo *type);
+void Array$remove(array_t *arr, int64_t index, int64_t count, const TypeInfo *type);
+void Array$sort(array_t *arr, const TypeInfo *type);
+void Array$shuffle(array_t *arr, const TypeInfo *type);
+void *Array$random(array_t arr);
+void Array$clear(array_t *array);
+void Array$compact(array_t *arr, const TypeInfo *type);
+bool Array$contains(array_t array, void *item, const TypeInfo *type);
+array_t Array$slice(array_t *array, int64_t first, int64_t length, int64_t stride, const TypeInfo *type);
+array_t Array$reversed(array_t array);
+array_t Array$concat(array_t x, array_t y, const TypeInfo *type);
+uint32_t Array$hash(const array_t *arr, const TypeInfo *type);
+int32_t Array$compare(const array_t *x, const array_t *y, const TypeInfo *type);
+bool Array$equal(const array_t *x, const array_t *y, const TypeInfo *type);
+CORD Array$as_text(const array_t *arr, bool colorize, const TypeInfo *type);
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/bool.c b/builtins/bool.c
index 7a34073..cced807 100644
--- a/builtins/bool.c
+++ b/builtins/bool.c
@@ -12,7 +12,7 @@
 #include "bool.h"
 #include "types.h"
 
-public CORD Bool__as_text(const bool *b, bool colorize, const TypeInfo *type)
+public CORD Bool$as_text(const bool *b, bool colorize, const TypeInfo *type)
 {
     (void)type;
     if (!b) return "Bool";
@@ -22,11 +22,11 @@ public CORD Bool__as_text(const bool *b, bool colorize, const TypeInfo *type)
         return *b ? "yes" : "no";
 }
 
-public const TypeInfo Bool = {
+public const TypeInfo $Bool = {
     .size=sizeof(bool),
     .align=__alignof__(bool),
     .tag=CustomInfo,
-    .CustomInfo={.as_text=(void*)Bool__as_text},
+    .CustomInfo={.as_text=(void*)Bool$as_text},
 };
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/bool.h b/builtins/bool.h
index 1462e7d..d5f4b70 100644
--- a/builtins/bool.h
+++ b/builtins/bool.h
@@ -12,8 +12,8 @@
 #define yes (Bool_t)true
 #define no (Bool_t)false
 
-CORD Bool__as_text(const bool *b, bool colorize, const TypeInfo *type);
+CORD Bool$as_text(const bool *b, bool colorize, const TypeInfo *type);
 
-extern const TypeInfo Bool;
+extern const TypeInfo $Bool;
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/functions.c b/builtins/functions.c
index 71fbfd6..53c4db0 100644
--- a/builtins/functions.c
+++ b/builtins/functions.c
@@ -57,10 +57,10 @@ public void fail_source(const char *filename, int64_t start, int64_t end, CORD f
 public uint32_t generic_hash(const void *obj, const TypeInfo *type)
 {
     switch (type->tag) {
-    case PointerInfo: case FunctionInfo: return Pointer__hash(obj, type);
-    case TextInfo: return Text__hash(obj);
-    case ArrayInfo: return Array__hash(obj, type);
-    case TableInfo: return Table_hash(obj, type);
+    case PointerInfo: case FunctionInfo: return Pointer$hash(obj, type);
+    case TextInfo: return Text$hash(obj);
+    case ArrayInfo: return Array$hash(obj, type);
+    case TableInfo: return Table$hash(obj, type);
     case CustomInfo:
         if (!type->CustomInfo.hash)
             goto hash_data;
@@ -77,10 +77,10 @@ public uint32_t generic_hash(const void *obj, const TypeInfo *type)
 public int32_t generic_compare(const void *x, const void *y, const TypeInfo *type)
 {
     switch (type->tag) {
-    case PointerInfo: case FunctionInfo: return Pointer__compare(x, y, type);
-    case TextInfo: return Text__compare(x, y);
-    case ArrayInfo: return Array__compare(x, y, type);
-    case TableInfo: return Table_compare(x, y, type);
+    case PointerInfo: case FunctionInfo: return Pointer$compare(x, y, type);
+    case TextInfo: return Text$compare(x, y);
+    case ArrayInfo: return Array$compare(x, y, type);
+    case TableInfo: return Table$compare(x, y, type);
     case CustomInfo:
         if (!type->CustomInfo.compare)
             goto compare_data;
@@ -94,10 +94,10 @@ public int32_t generic_compare(const void *x, const void *y, const TypeInfo *typ
 public bool generic_equal(const void *x, const void *y, const TypeInfo *type)
 {
     switch (type->tag) {
-    case PointerInfo: case FunctionInfo: return Pointer__equal(x, y, type);
-    case TextInfo: return Text__equal(x, y);
-    case ArrayInfo: return Array__equal(x, y, type);
-    case TableInfo: return Table_equal(x, y, type);
+    case PointerInfo: case FunctionInfo: return Pointer$equal(x, y, type);
+    case TextInfo: return Text$equal(x, y);
+    case ArrayInfo: return Array$equal(x, y, type);
+    case TableInfo: return Table$equal(x, y, type);
     case CustomInfo:
         if (!type->CustomInfo.equal)
             goto use_generic_compare;
@@ -111,12 +111,12 @@ public bool generic_equal(const void *x, const void *y, const TypeInfo *type)
 public CORD generic_as_text(const void *obj, bool colorize, const TypeInfo *type)
 {
     switch (type->tag) {
-    case PointerInfo: return Pointer__as_text(obj, colorize, type);
-    case FunctionInfo: return Func__as_text(obj, colorize, type);
-    case TextInfo: return Text__as_text(obj, colorize, type);
-    case ArrayInfo: return Array__as_text(obj, colorize, type);
-    case TableInfo: return Table_as_text(obj, colorize, type);
-    case TypeInfoInfo: return Type__as_text(obj, colorize, type);
+    case PointerInfo: return Pointer$as_text(obj, colorize, type);
+    case FunctionInfo: return Func$as_text(obj, colorize, type);
+    case TextInfo: return Text$as_text(obj, colorize, type);
+    case ArrayInfo: return Array$as_text(obj, colorize, type);
+    case TableInfo: return Table$as_text(obj, colorize, type);
+    case TypeInfoInfo: return Type$as_text(obj, colorize, type);
     case CustomInfo:
         if (!type->CustomInfo.as_text)
             fail("No cord function provided for type!\n");
@@ -156,10 +156,10 @@ public void $test(void *expr, const TypeInfo *type, CORD expected, const char *f
         CORD_fprintf(stderr, USE_COLOR ? "\x1b[2m=\x1b[0m %r \x1b[2m: %r\x1b[m\n" : "= %r : %r\n", expr_normalized, type_name);
         if (expected) {
             CORD expr_plain = USE_COLOR ? generic_as_text(expr, false, type) : expr_normalized;
-            bool success = Text__equal(&expr_plain, &expected);
+            bool success = Text$equal(&expr_plain, &expected);
             if (!success && CORD_chr(expected, 0, ':')) {
                 CORD with_type = CORD_catn(3, expr_plain, " : ", type_name);
-                success = Text__equal(&with_type, &expected);
+                success = Text$equal(&with_type, &expected);
             }
 
             if (!success) {
diff --git a/builtins/integers.c b/builtins/integers.c
index 159220a..86c1d5e 100644
--- a/builtins/integers.c
+++ b/builtins/integers.c
@@ -15,7 +15,7 @@
 #define str(a) #a
 
 #define DEFINE_INT_TYPE(c_type, KindOfInt, fmt, min_val, max_val)\
-    public CORD KindOfInt ## __as_text(const c_type *i, bool colorize, const TypeInfo *type) { \
+    public CORD KindOfInt ## $as_text(const c_type *i, bool colorize, const TypeInfo *type) { \
         (void)type; \
         if (!i) return #KindOfInt; \
         CORD c; \
@@ -23,26 +23,26 @@
         else CORD_sprintf(&c, "%"fmt, *i); \
         return c; \
     } \
-    public int32_t KindOfInt ## __compare(const c_type *x, const c_type *y, const TypeInfo *type) { \
+    public int32_t KindOfInt ## $compare(const c_type *x, const c_type *y, const TypeInfo *type) { \
         (void)type; \
         return (*x > *y) - (*x < *y); \
     } \
-    public bool KindOfInt ## __equal(const c_type *x, const c_type *y, const TypeInfo *type) { \
+    public bool KindOfInt ## $equal(const c_type *x, const c_type *y, const TypeInfo *type) { \
         (void)type; \
         return *x == *y; \
     } \
-    public CORD KindOfInt ## __format(c_type i, int64_t digits) { \
+    public CORD KindOfInt ## $format(c_type i, int64_t digits) { \
         return CORD_asprintf("%0*" fmt, (int)digits, i); \
     } \
-    public CORD KindOfInt ## __hex(c_type i, int64_t digits, bool uppercase, bool prefix) { \
+    public CORD KindOfInt ## $hex(c_type i, int64_t digits, bool uppercase, bool prefix) { \
         const char *hex_fmt = uppercase ? (prefix ? "0x%0.*lX" : "%0.*lX") : (prefix ? "0x%0.*lx" : "%0.*lx"); \
         return CORD_asprintf(hex_fmt, (int)digits, (uint64_t)i); \
     } \
-    public CORD KindOfInt ## __octal(c_type i, int64_t digits, bool prefix) { \
+    public CORD KindOfInt ## $octal(c_type i, int64_t digits, bool prefix) { \
         const char *octal_fmt = prefix ? "0o%0.*lo" : "%0.*lo"; \
         return CORD_asprintf(octal_fmt, (int)digits, (uint64_t)i); \
     } \
-    public array_t KindOfInt ## __bits(c_type x) { \
+    public array_t KindOfInt ## $bits(c_type x) { \
         array_t bit_array = (array_t){.data=GC_MALLOC_ATOMIC(sizeof(bool)*8*sizeof(c_type)), .atomic=1, .stride=sizeof(bool), .length=8*sizeof(c_type)}; \
         bool *bits = bit_array.data + sizeof(c_type)*8; \
         for (size_t i = 0; i < 8*sizeof(c_type); i++) { \
@@ -51,7 +51,7 @@
         } \
         return bit_array; \
     } \
-    public c_type KindOfInt ## __random(int64_t min, int64_t max) { \
+    public c_type KindOfInt ## $random(int64_t min, int64_t max) { \
         if (min > max) fail("Random min (%ld) is larger than max (%ld)", min, max); \
         if (min < (int64_t)min_val) fail("Random min (%ld) is smaller than the minimum "#KindOfInt" value", min); \
         if (max > (int64_t)max_val) fail("Random max (%ld) is smaller than the maximum "#KindOfInt" value", max); \
@@ -60,13 +60,13 @@
         uint32_t r = arc4random_uniform((uint32_t)range); \
         return min + (c_type)r; \
     } \
-    public const c_type KindOfInt##__min = min_val; \
-    public const c_type KindOfInt##__max = max_val; \
-    public const TypeInfo KindOfInt = { \
+    public const c_type KindOfInt##$min = min_val; \
+    public const c_type KindOfInt##$max = max_val; \
+    public const TypeInfo $ ## KindOfInt = { \
         .size=sizeof(c_type), \
         .align=__alignof__(c_type), \
         .tag=CustomInfo, \
-        .CustomInfo={.compare=(void*)KindOfInt##__compare, .as_text=(void*)KindOfInt##__as_text}, \
+        .CustomInfo={.compare=(void*)KindOfInt##$compare, .as_text=(void*)KindOfInt##$as_text}, \
     };
 
 DEFINE_INT_TYPE(int64_t,  Int,    "ld",     INT64_MIN, INT64_MAX);
diff --git a/builtins/integers.h b/builtins/integers.h
index b6b41d6..8ee7878 100644
--- a/builtins/integers.h
+++ b/builtins/integers.h
@@ -19,26 +19,26 @@
 #define I8(x) ((int8_t)x)
 
 #define DEFINE_INT_TYPE(c_type, type_name) \
-    CORD type_name ## __as_text(const c_type *i, bool colorize, const TypeInfo *type); \
-    int32_t type_name ## __compare(const c_type *x, const c_type *y, const TypeInfo *type); \
-    bool type_name ## __equal(const c_type *x, const c_type *y, const TypeInfo *type); \
-    CORD type_name ## __format(c_type i, int64_t digits); \
-    CORD type_name ## __hex(c_type i, int64_t digits, bool uppercase, bool prefix); \
-    CORD type_name ## __octal(c_type i, int64_t digits, bool prefix); \
-    array_t type_name ## __bits(c_type x); \
-    c_type type_name ## __random(int64_t min, int64_t max); \
-    extern const c_type type_name ## __min, type_name##__max; \
-    extern const TypeInfo type_name;
+    CORD type_name ## $as_text(const c_type *i, bool colorize, const TypeInfo *type); \
+    int32_t type_name ## $compare(const c_type *x, const c_type *y, const TypeInfo *type); \
+    bool type_name ## $equal(const c_type *x, const c_type *y, const TypeInfo *type); \
+    CORD type_name ## $format(c_type i, int64_t digits); \
+    CORD type_name ## $hex(c_type i, int64_t digits, bool uppercase, bool prefix); \
+    CORD type_name ## $octal(c_type i, int64_t digits, bool prefix); \
+    array_t type_name ## $bits(c_type x); \
+    c_type type_name ## $random(int64_t min, int64_t max); \
+    extern const c_type type_name ## $min, type_name##$max; \
+    extern const TypeInfo $ ## type_name;
 
-DEFINE_INT_TYPE(int64_t,  Int);
-DEFINE_INT_TYPE(int32_t,  Int32);
-DEFINE_INT_TYPE(int16_t,  Int16);
-DEFINE_INT_TYPE(int8_t,   Int8);
+DEFINE_INT_TYPE(int64_t, Int);
+DEFINE_INT_TYPE(int32_t, Int32);
+DEFINE_INT_TYPE(int16_t, Int16);
+DEFINE_INT_TYPE(int8_t,  Int8);
 #undef DEFINE_INT_TYPE
 
-#define Int__abs(...) I64(labs(__VA_ARGS__))
-#define Int32__abs(...) I32(abs(__VA_ARGS__))
-#define Int16__abs(...) I16(abs(__VA_ARGS__))
-#define Int8__abs(...) I8(abs(__VA_ARGS__))
+#define Int$abs(...) I64(labs(__VA_ARGS__))
+#define Int32$abs(...) I32(abs(__VA_ARGS__))
+#define Int16$abs(...) I16(abs(__VA_ARGS__))
+#define Int8$abs(...) I8(abs(__VA_ARGS__))
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/memory.c b/builtins/memory.c
index 290a6f1..5b9f39a 100644
--- a/builtins/memory.c
+++ b/builtins/memory.c
@@ -21,7 +21,7 @@ public CORD Memory__as_text(const void *p, bool colorize, const TypeInfo *type)
     return cord;
 }
 
-public const TypeInfo Memory = {
+public const TypeInfo $Memory = {
     .size=0,
     .align=0,
     .tag=CustomInfo,
diff --git a/builtins/memory.h b/builtins/memory.h
index b551902..48a2daf 100644
--- a/builtins/memory.h
+++ b/builtins/memory.h
@@ -8,7 +8,7 @@
 
 #include "types.h"
 
-extern const TypeInfo Memory;
-CORD Memory__as_text(const void *p, bool colorize, const TypeInfo *type);
+extern const TypeInfo $Memory;
+CORD Memory$as_text(const void *p, bool colorize, const TypeInfo *type);
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/nums.c b/builtins/nums.c
index 7d20314..0bb604e 100644
--- a/builtins/nums.c
+++ b/builtins/nums.c
@@ -13,7 +13,7 @@
 #include "string.h"
 #include "types.h"
 
-public CORD Num__as_text(const double *f, bool colorize, const TypeInfo *type) { 
+public CORD Num$as_text(const double *f, bool colorize, const TypeInfo *type) { 
     (void)type;
     if (!f) return "Num";
     CORD c;
@@ -22,17 +22,17 @@ public CORD Num__as_text(const double *f, bool colorize, const TypeInfo *type) {
     return c; 
 } 
 
-public int32_t Num__compare(const double *x, const double *y, const TypeInfo *type) { 
+public int32_t Num$compare(const double *x, const double *y, const TypeInfo *type) { 
     (void)type;
     return (*x > *y) - (*x < *y);
 } 
 
-public bool Num__equal(const double *x, const double *y, const TypeInfo *type) { 
+public bool Num$equal(const double *x, const double *y, const TypeInfo *type) { 
     (void)type;
     return *x == *y;
 } 
 
-public bool Num__near(double a, double b, double ratio, double absolute) {
+public bool Num$near(double a, double b, double ratio, double absolute) {
     if (ratio < 0) ratio = 0;
     else if (ratio > 0) ratio = 1;
 
@@ -47,43 +47,43 @@ public bool Num__near(double a, double b, double ratio, double absolute) {
     return (diff < epsilon);
 }
 
-public CORD Num__format(double f, int64_t precision) { 
+public CORD Num$format(double f, int64_t precision) { 
     return CORD_asprintf("%.*f", (int)precision, f);
 }
 
-public CORD Num__scientific(double f, int64_t precision) { 
+public CORD Num$scientific(double f, int64_t precision) { 
     return CORD_asprintf("%.*e", (int)precision, f); 
 }
 
-public double Num__mod(double num, double modulus) { 
+public double Num$mod(double num, double modulus) { 
     double result = fmod(num, modulus); 
     return (result < 0) != (modulus < 0) ? result + modulus : result; 
 }
 
-public double Num__random(void) { 
+public double Num$random(void) { 
     return drand48(); 
 }
 
-public double Num__nan(CORD tag) {
+public double Num$nan(CORD tag) {
     return nan(CORD_to_const_char_star(tag));
 }
 
-public bool Num__isinf(double n) { return !!isinf(n); }
-public bool Num__finite(double n) { return !!finite(n); }
-public bool Num__isnan(double n) { return !!isnan(n); }
+public bool Num$isinf(double n) { return !!isinf(n); }
+public bool Num$finite(double n) { return !!finite(n); }
+public bool Num$isnan(double n) { return !!isnan(n); }
 
-public const TypeInfo Num = {
+public const TypeInfo $Num = {
     .size=sizeof(double),
     .align=__alignof__(double),
     .tag=CustomInfo,
     .CustomInfo={
-        .compare=(void*)Num__compare,
-        .equal=(void*)Num__equal,
-        .as_text=(void*)Num__as_text,
+        .compare=(void*)Num$compare,
+        .equal=(void*)Num$equal,
+        .as_text=(void*)Num$as_text,
     },
 };
 
-public CORD Num32__as_text(const float *f, bool colorize, const TypeInfo *type) { 
+public CORD Num32$as_text(const float *f, bool colorize, const TypeInfo *type) { 
     (void)type;
     if (!f) return "Num32";
     CORD c;
@@ -92,17 +92,17 @@ public CORD Num32__as_text(const float *f, bool colorize, const TypeInfo *type)
     return c;
 }
 
-public int32_t Num32__compare(const float *x, const float *y, const TypeInfo *type) { 
+public int32_t Num32$compare(const float *x, const float *y, const TypeInfo *type) { 
     (void)type;
     return (*x > *y) - (*x < *y);
 } 
 
-public bool Num32__equal(const float *x, const float *y, const TypeInfo *type) { 
+public bool Num32$equal(const float *x, const float *y, const TypeInfo *type) { 
     (void)type;
     return *x == *y;
 }
 
-public bool Num32__near(float a, float b, float ratio, float absolute) {
+public bool Num32$near(float a, float b, float ratio, float absolute) {
     if (ratio < 0) ratio = 0;
     else if (ratio > 0) ratio = 1;
 
@@ -117,39 +117,39 @@ public bool Num32__near(float a, float b, float ratio, float absolute) {
     return (diff < epsilon);
 }
 
-public CORD Num32__format(float f, int64_t precision) { 
+public CORD Num32$format(float f, int64_t precision) { 
     return CORD_asprintf("%.*f", (int)precision, f); 
 }
 
-public CORD Num32__scientific(float f, int64_t precision) { 
+public CORD Num32$scientific(float f, int64_t precision) { 
     return CORD_asprintf("%.*e", (int)precision, f); 
 }
 
-public float Num32__mod(float num, float modulus) { 
+public float Num32$mod(float num, float modulus) { 
     float result = fmodf(num, modulus); 
     return (result < 0) != (modulus < 0) ? result + modulus : result; 
 }
 
-public float Num32__random(void) { 
+public float Num32$random(void) { 
     return (float)drand48(); 
 }
 
-public float Num32__nan(CORD tag) {
+public float Num32$nan(CORD tag) {
     return nanf(CORD_to_const_char_star(tag));
 }
 
-public bool Num32__isinf(float n) { return isinf(n); }
-public bool Num32__finite(float n) { return finite(n); }
-public bool Num32__isnan(float n) { return isnan(n); }
+public bool Num32$isinf(float n) { return isinf(n); }
+public bool Num32$finite(float n) { return finite(n); }
+public bool Num32$isnan(float n) { return isnan(n); }
 
-public const TypeInfo Num32 = {
+public const TypeInfo $Num32 = {
     .size=sizeof(float),
     .align=__alignof__(float),
     .tag=CustomInfo,
     .CustomInfo={
-        .compare=(void*)Num32__compare,
-        .equal=(void*)Num32__equal,
-        .as_text=(void*)Num32__as_text,
+        .compare=(void*)Num32$compare,
+        .equal=(void*)Num32$equal,
+        .as_text=(void*)Num32$as_text,
     },
 };
 
diff --git a/builtins/nums.h b/builtins/nums.h
index 97d72c5..0d9f2e9 100644
--- a/builtins/nums.h
+++ b/builtins/nums.h
@@ -12,32 +12,32 @@
 #define Num_t double
 #define Num32_t float
 
-CORD Num__as_text(const double *f, bool colorize, const TypeInfo *type);
-int32_t Num__compare(const double *x, const double *y, const TypeInfo *type);
-bool Num__equal(const double *x, const double *y, const TypeInfo *type);
-bool Num__near(double a, double b, double ratio, double absolute);
-CORD Num__format(double f, int64_t precision);
-CORD Num__scientific(double f, int64_t precision);
-double Num__mod(double num, double modulus);
-bool Num__isinf(double n);
-bool Num__finite(double n);
-bool Num__isnan(double n);
-double Num__nan(CORD tag);
-double Num__random(void);
-extern const TypeInfo Num;
+CORD Num$as_text(const double *f, bool colorize, const TypeInfo *type);
+int32_t Num$compare(const double *x, const double *y, const TypeInfo *type);
+bool Num$equal(const double *x, const double *y, const TypeInfo *type);
+bool Num$near(double a, double b, double ratio, double absolute);
+CORD Num$format(double f, int64_t precision);
+CORD Num$scientific(double f, int64_t precision);
+double Num$mod(double num, double modulus);
+bool Num$isinf(double n);
+bool Num$finite(double n);
+bool Num$isnan(double n);
+double Num$nan(CORD tag);
+double Num$random(void);
+extern const TypeInfo $Num;
 
-CORD Num32__as_text(const float *f, bool colorize, const TypeInfo *type);
-int32_t Num32__compare(const float *x, const float *y, const TypeInfo *type);
-bool Num32__equal(const float *x, const float *y, const TypeInfo *type);
-bool Num32__near(float a, float b, float ratio, float absolute);
-CORD Num32__format(float f, int64_t precision);
-CORD Num32__scientific(float f, int64_t precision);
-float Num32__mod(float num, float modulus);
-bool Num32__isinf(float n);
-bool Num32__finite(float n);
-bool Num32__isnan(float n);
-float Num32__random(void);
-float Num32__nan(CORD tag);
-extern const TypeInfo Num32;
+CORD Num32$as_text(const float *f, bool colorize, const TypeInfo *type);
+int32_t Num32$compare(const float *x, const float *y, const TypeInfo *type);
+bool Num32$equal(const float *x, const float *y, const TypeInfo *type);
+bool Num32$near(float a, float b, float ratio, float absolute);
+CORD Num32$format(float f, int64_t precision);
+CORD Num32$scientific(float f, int64_t precision);
+float Num32$mod(float num, float modulus);
+bool Num32$isinf(float n);
+bool Num32$finite(float n);
+bool Num32$isnan(float n);
+float Num32$random(void);
+float Num32$nan(CORD tag);
+extern const TypeInfo $Num32;
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/pointer.c b/builtins/pointer.c
index a894e6a..271bb6c 100644
--- a/builtins/pointer.c
+++ b/builtins/pointer.c
@@ -18,7 +18,7 @@ typedef struct recursion_s {
     struct recursion_s *next;
 } recursion_t;
 
-public CORD Pointer__as_text(const void *x, bool colorize, const TypeInfo *type) {
+public CORD Pointer$as_text(const void *x, bool colorize, const TypeInfo *type) {
     auto ptr_info = type->PointerInfo;
     if (!x) {
         CORD typename = generic_as_text(NULL, false, ptr_info.pointed);
@@ -50,19 +50,19 @@ public CORD Pointer__as_text(const void *x, bool colorize, const TypeInfo *type)
     return colorize ? CORD_asprintf("\x1b[34;1m%s\x1b[m%r", ptr_info.sigil, pointed) : CORD_cat(ptr_info.sigil, pointed);
 }
 
-public int32_t Pointer__compare(const void *x, const void *y, const TypeInfo *type) {
+public int32_t Pointer$compare(const void *x, const void *y, const TypeInfo *type) {
     (void)type;
     const void *xp = *(const void**)x, *yp = *(const void**)y;
     return (xp > yp) - (xp < yp);
 }
 
-public bool Pointer__equal(const void *x, const void *y, const TypeInfo *type) {
+public bool Pointer$equal(const void *x, const void *y, const TypeInfo *type) {
     (void)type;
     const void *xp = *(const void**)x, *yp = *(const void**)y;
     return xp == yp;
 }
 
-public uint32_t Pointer__hash(const void *x, const TypeInfo *type) {
+public uint32_t Pointer$hash(const void *x, const TypeInfo *type) {
     (void)type;
     uint32_t hash;
     halfsiphash(x, sizeof(void*), SSS_HASH_VECTOR, (uint8_t*)&hash, sizeof(hash));
diff --git a/builtins/pointer.h b/builtins/pointer.h
index edaaaa2..e5705d2 100644
--- a/builtins/pointer.h
+++ b/builtins/pointer.h
@@ -8,10 +8,10 @@
 
 #include "types.h"
 
-CORD Pointer__as_text(const void *x, bool colorize, const TypeInfo *type);
-int32_t Pointer__compare(const void *x, const void *y, const TypeInfo *type);
-bool Pointer__equal(const void *x, const void *y, const TypeInfo *type);
-uint32_t Pointer__hash(const void *x, const TypeInfo *type);
+CORD Pointer$as_text(const void *x, bool colorize, const TypeInfo *type);
+int32_t Pointer$compare(const void *x, const void *y, const TypeInfo *type);
+bool Pointer$equal(const void *x, const void *y, const TypeInfo *type);
+uint32_t Pointer$hash(const void *x, const TypeInfo *type);
 
 #define $Null(t) (t*)NULL
 #define POINTER_TYPE(_sigil, _pointed) (&(TypeInfo){\
diff --git a/builtins/table.c b/builtins/table.c
index 03f3e6b..32bf685 100644
--- a/builtins/table.c
+++ b/builtins/table.c
@@ -41,13 +41,13 @@
 #define GET_ENTRY(t, i) ((t).entries.data + (t).entries.stride*(i))
 #define ENTRIES_TYPE(type) (&(TypeInfo){.size=sizeof(array_t), .align=__alignof__(array_t), .tag=ArrayInfo, .ArrayInfo.item=(&(TypeInfo){.size=entry_size(type), .align=entry_align(type), .tag=OpaqueInfo})})
 
-const TypeInfo MemoryPointer = {
+static const TypeInfo MemoryPointer = {
     .size=sizeof(void*),
     .align=__alignof__(void*),
     .tag=PointerInfo,
     .PointerInfo={
         .sigil="@",
-        .pointed=&Memory,
+        .pointed=&$Memory,
     },
 };
 
@@ -55,7 +55,7 @@ const TypeInfo StrToVoidStarTable = {
     .size=sizeof(table_t),
     .align=__alignof__(table_t),
     .tag=TableInfo,
-    .TableInfo={.key=&Text, .value=&MemoryPointer},
+    .TableInfo={.key=&$Text, .value=&MemoryPointer},
 };
 
 static inline size_t entry_size(const TypeInfo *info)
@@ -82,7 +82,6 @@ static inline size_t value_offset(const TypeInfo *info)
     return offset;
 }
 
-
 static inline void hshow(const table_t *t)
 {
     hdebug("{");
@@ -99,7 +98,7 @@ static inline void hshow(const table_t *t)
 static void maybe_copy_on_write(table_t *t, const TypeInfo *type)
 {
     if (t->entries.data_refcount) {
-        Array__compact(&t->entries, ENTRIES_TYPE(type));
+        Array$compact(&t->entries, ENTRIES_TYPE(type));
     }
 
     if (t->bucket_info && t->bucket_info->data_refcount) {
@@ -109,14 +108,14 @@ static void maybe_copy_on_write(table_t *t, const TypeInfo *type)
     }
 }
 
-public void Table_mark_copy_on_write(table_t *t)
+public void Table$mark_copy_on_write(table_t *t)
 {
     t->entries.data_refcount = 3;
     if (t->bucket_info) t->bucket_info->data_refcount = 3;
 }
 
 // Return address of value or NULL
-public void *Table_get_raw(table_t t, const void *key, const TypeInfo *type)
+public void *Table$get_raw(table_t t, const void *key, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
     if (!key || !t.bucket_info) return NULL;
@@ -138,11 +137,11 @@ public void *Table_get_raw(table_t t, const void *key, const TypeInfo *type)
     return NULL;
 }
 
-public void *Table_get(table_t t, const void *key, const TypeInfo *type)
+public void *Table$get(table_t t, const void *key, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
     for (const table_t *iter = &t; iter; iter = iter->fallback) {
-        void *ret = Table_get_raw(*iter, key, type);
+        void *ret = Table$get_raw(*iter, key, type);
         if (ret) return ret;
     }
     for (const table_t *iter = &t; iter; iter = iter->fallback) {
@@ -151,7 +150,7 @@ public void *Table_get(table_t t, const void *key, const TypeInfo *type)
     return NULL;
 }
 
-static void Table_set_bucket(table_t *t, const void *entry, int32_t index, const TypeInfo *type)
+static void Table$set_bucket(table_t *t, const void *entry, int32_t index, const TypeInfo *type)
 {
     assert(t->bucket_info);
     hshow(t);
@@ -215,9 +214,9 @@ static void hashmap_resize_buckets(table_t *t, uint32_t new_capacity, const Type
     t->bucket_info->count = new_capacity;
     t->bucket_info->last_free = new_capacity-1;
     // Rehash:
-    for (int64_t i = 0; i < Table_length(*t); i++) {
+    for (int64_t i = 0; i < Table$length(*t); i++) {
         hdebug("Rehashing %u\n", i);
-        Table_set_bucket(t, GET_ENTRY(*t, i), i, type);
+        Table$set_bucket(t, GET_ENTRY(*t, i), i, type);
     }
 
     hshow(t);
@@ -225,7 +224,7 @@ static void hashmap_resize_buckets(table_t *t, uint32_t new_capacity, const Type
 }
 
 // Return address of value
-public void *Table_reserve(table_t *t, const void *key, const void *value, const TypeInfo *type)
+public void *Table$reserve(table_t *t, const void *key, const void *value, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
     if (!t || !key) return NULL;
@@ -237,7 +236,7 @@ public void *Table_reserve(table_t *t, const void *key, const void *value, const
         hashmap_resize_buckets(t, 4, type);
     } else {
         // Check if we are clobbering a value:
-        void *value_home = Table_get_raw(*t, key, type);
+        void *value_home = Table$get_raw(*t, key, type);
         if (value_home) { // Update existing slot
             // Ensure that `value_home` is still inside t->entries, even if COW occurs
             ptrdiff_t offset = value_home - t->entries.data;
@@ -260,7 +259,7 @@ public void *Table_reserve(table_t *t, const void *key, const void *value, const
 
     if (!value && value_size > 0) {
         for (table_t *iter = t->fallback; iter; iter = iter->fallback) {
-            value = Table_get_raw(*iter, key, type);
+            value = Table$get_raw(*iter, key, type);
             if (value) break;
         }
         for (table_t *iter = t; !value && iter; iter = iter->fallback) {
@@ -277,24 +276,24 @@ public void *Table_reserve(table_t *t, const void *key, const void *value, const
         memcpy(buf + value_offset(type), value, value_size);
     else
         memset(buf + value_offset(type), 0, value_size);
-    Array__insert(&t->entries, buf, 0, ENTRIES_TYPE(type));
+    Array$insert(&t->entries, buf, 0, ENTRIES_TYPE(type));
 
     int64_t entry_index = t->entries.length-1;
     void *entry = GET_ENTRY(*t, entry_index);
-    Table_set_bucket(t, entry, entry_index, type);
+    Table$set_bucket(t, entry, entry_index, type);
     return entry + value_offset(type);
 }
 
-public void Table_set(table_t *t, const void *key, const void *value, const TypeInfo *type)
+public void Table$set(table_t *t, const void *key, const void *value, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
-    (void)Table_reserve(t, key, value, type);
+    (void)Table$reserve(t, key, value, type);
 }
 
-public void Table_remove(table_t *t, const void *key, const TypeInfo *type)
+public void Table$remove(table_t *t, const void *key, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
-    if (!t || Table_length(*t) == 0) return;
+    if (!t || Table$length(*t) == 0) return;
 
     // TODO: this work doesn't need to be done if the key is already missing
     maybe_copy_on_write(t, type);
@@ -363,7 +362,7 @@ public void Table_remove(table_t *t, const void *key, const TypeInfo *type)
     // Last entry is being removed, so clear it out to be safe:
     memset(GET_ENTRY(*t, last_entry), 0, entry_size(type));
 
-    Array__remove(&t->entries, t->entries.length, 1, ENTRIES_TYPE(type));
+    Array$remove(&t->entries, t->entries.length, 1, ENTRIES_TYPE(type));
 
     int64_t bucket_to_clear;
     if (prev) { // Middle (or end) of a chain
@@ -386,22 +385,22 @@ public void Table_remove(table_t *t, const void *key, const TypeInfo *type)
     hshow(t);
 }
 
-public void *Table_entry(table_t t, int64_t n)
+public void *Table$entry(table_t t, int64_t n)
 {
-    if (n < 1 || n > Table_length(t))
+    if (n < 1 || n > Table$length(t))
         return NULL;
     return GET_ENTRY(t, n-1);
 }
 
-public void Table_clear(table_t *t)
+public void Table$clear(table_t *t)
 {
     memset(t, 0, sizeof(table_t));
 }
 
-public bool Table_equal(const table_t *x, const table_t *y, const TypeInfo *type)
+public bool Table$equal(const table_t *x, const table_t *y, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
-    if (Table_length(*x) != Table_length(*y))
+    if (Table$length(*x) != Table$length(*y))
         return false;
     
     if ((x->default_value != NULL) != (y->default_value != NULL))
@@ -411,10 +410,10 @@ public bool Table_equal(const table_t *x, const table_t *y, const TypeInfo *type
         return false;
 
     const TypeInfo *value_type = type->TableInfo.value;
-    for (int64_t i = 0, length = Table_length(*x); i < length; i++) {
+    for (int64_t i = 0, length = Table$length(*x); i < length; i++) {
         void *x_key = GET_ENTRY(*x, i);
         void *x_value = x_key + value_offset(type);
-        void *y_value = Table_get_raw(*y, x_key, type);
+        void *y_value = Table$get_raw(*y, x_key, type);
         if (!y_value)
             return false;
         if (!generic_equal(x_value, y_value, value_type))
@@ -426,13 +425,13 @@ public bool Table_equal(const table_t *x, const table_t *y, const TypeInfo *type
         return false;
 
     if (x->fallback && y->fallback
-        && !Table_equal(x->fallback, y->fallback, type))
+        && !Table$equal(x->fallback, y->fallback, type))
         return false;
     
     return true;
 }
 
-public int32_t Table_compare(const table_t *x, const table_t *y, const TypeInfo *type)
+public int32_t Table$compare(const table_t *x, const table_t *y, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
     auto table = type->TableInfo;
@@ -442,8 +441,8 @@ public int32_t Table_compare(const table_t *x, const table_t *y, const TypeInfo
         return (x->entries.length > y->entries.length) - (x->entries.length < y->entries.length);
 
     array_t x_entries = x->entries, y_entries = y->entries;
-    Array__sort(&x_entries, table.key);
-    Array__sort(&y_entries, table.key);
+    Array$sort(&x_entries, table.key);
+    Array$sort(&y_entries, table.key);
     for (int64_t i = 0; i < x_entries.length; i++) {
         void *x_key = x_entries.data + x_entries.stride * i;
         void *y_key = y_entries.data + y_entries.stride * i;
@@ -471,7 +470,7 @@ public int32_t Table_compare(const table_t *x, const table_t *y, const TypeInfo
     return 0;
 }
 
-public uint32_t Table_hash(const table_t *t, const TypeInfo *type)
+public uint32_t Table$hash(const table_t *t, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
     // Table hashes are computed as:
@@ -481,20 +480,20 @@ public uint32_t Table_hash(const table_t *t, const TypeInfo *type)
     int64_t val_off = value_offset(type);
 
     uint32_t key_hashes = 0, value_hashes = 0, fallback_hash = 0, default_hash = 0;
-    for (int64_t i = 0, length = Table_length(*t); i < length; i++) {
+    for (int64_t i = 0, length = Table$length(*t); i < length; i++) {
         void *entry = GET_ENTRY(*t, i);
         key_hashes ^= generic_hash(entry, table.key);
         value_hashes ^= generic_hash(entry + val_off, table.value);
     }
 
     if (t->fallback)
-        fallback_hash = Table_hash(t->fallback, type);
+        fallback_hash = Table$hash(t->fallback, type);
 
     if (t->default_value)
         default_hash = generic_hash(t->default_value, table.value);
 
     struct { int64_t len; uint32_t k, v, f, d; } components = {
-        Table_length(*t),
+        Table$length(*t),
         key_hashes,
         value_hashes,
         fallback_hash,
@@ -505,7 +504,7 @@ public uint32_t Table_hash(const table_t *t, const TypeInfo *type)
     return hash;
 }
 
-public CORD Table_as_text(const table_t *t, bool colorize, const TypeInfo *type)
+public CORD Table$as_text(const table_t *t, bool colorize, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
     auto table = type->TableInfo;
@@ -515,7 +514,7 @@ public CORD Table_as_text(const table_t *t, bool colorize, const TypeInfo *type)
 
     int64_t val_off = value_offset(type);
     CORD c = "{";
-    for (int64_t i = 0, length = Table_length(*t); i < length; i++) {
+    for (int64_t i = 0, length = Table$length(*t); i < length; i++) {
         if (i > 0)
             c = CORD_cat(c, ", ");
         void *entry = GET_ENTRY(*t, i);
@@ -526,7 +525,7 @@ public CORD Table_as_text(const table_t *t, bool colorize, const TypeInfo *type)
 
     if (t->fallback) {
         c = CORD_cat(c, "; fallback=");
-        c = CORD_cat(c, Table_as_text(t->fallback, colorize, type));
+        c = CORD_cat(c, Table$as_text(t->fallback, colorize, type));
     }
 
     if (t->default_value) {
@@ -538,7 +537,7 @@ public CORD Table_as_text(const table_t *t, bool colorize, const TypeInfo *type)
     return c;
 }
 
-public table_t Table_from_entries(array_t entries, const TypeInfo *type)
+public table_t Table$from_entries(array_t entries, const TypeInfo *type)
 {
     assert(type->tag == TableInfo);
     table_t t = {.entries=entries};
@@ -546,36 +545,36 @@ public table_t Table_from_entries(array_t entries, const TypeInfo *type)
     return t;
 }
 
-void *Table_str_get(table_t t, const char *key)
+public void *Table$str_get(table_t t, const char *key)
 {
-    void **ret = Table_get(t, &key, &StrToVoidStarTable);
+    void **ret = Table$get(t, &key, &StrToVoidStarTable);
     return ret ? *ret : NULL;
 }
 
-void *Table_str_get_raw(table_t t, const char *key)
+public void *Table$str_get_raw(table_t t, const char *key)
 {
-    void **ret = Table_get_raw(t, &key, &StrToVoidStarTable);
+    void **ret = Table$get_raw(t, &key, &StrToVoidStarTable);
     return ret ? *ret : NULL;
 }
 
-void *Table_str_reserve(table_t *t, const char *key, const void *value)
+public void *Table$str_reserve(table_t *t, const char *key, const void *value)
 {
-    return Table_reserve(t, &key, &value, &StrToVoidStarTable);
+    return Table$reserve(t, &key, &value, &StrToVoidStarTable);
 }
 
-void Table_str_set(table_t *t, const char *key, const void *value)
+public void Table$str_set(table_t *t, const char *key, const void *value)
 {
-    Table_set(t, &key, &value, &StrToVoidStarTable);
+    Table$set(t, &key, &value, &StrToVoidStarTable);
 }
 
-void Table_str_remove(table_t *t, const char *key)
+public void Table$str_remove(table_t *t, const char *key)
 {
-    return Table_remove(t, &key, &StrToVoidStarTable);
+    return Table$remove(t, &key, &StrToVoidStarTable);
 }
 
-void *Table_str_entry(table_t t, int64_t n)
+public void *Table$str_entry(table_t t, int64_t n)
 {
-    return Table_entry(t, n);
+    return Table$entry(t, n);
 }
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1
diff --git a/builtins/table.h b/builtins/table.h
index 38c6642..fdde32a 100644
--- a/builtins/table.h
+++ b/builtins/table.h
@@ -12,7 +12,7 @@
 
 #define $Table(key_t, val_t, key_info, value_info, fb, def, N, ...)  ({ \
     struct { key_t k; val_t v; } $ents[N] = {__VA_ARGS__}; \
-    table_t $table = Table_from_entries((array_t){ \
+    table_t $table = Table$from_entries((array_t){ \
                        .data=memcpy(GC_MALLOC(sizeof($ents)), $ents, sizeof($ents)), \
                        .length=sizeof($ents)/sizeof($ents[0]), \
                        .stride=(void*)&$ents[1] - (void*)&$ents[0], \
@@ -22,36 +22,36 @@
     $table; })
 #define $Table_get(table_expr, key_t, val_t, key_expr, info_expr, filename, start, end) ({ \
     const table_t $t = table_expr; key_t $k = key_expr; const TypeInfo* $info = info_expr; \
-    const val_t *$v = Table_get($t, &$k, $info); \
+    const val_t *$v = Table$get($t, &$k, $info); \
     if (__builtin_expect($v == NULL, 0)) \
         fail_source(filename, start, end, "The key %r is not in this table\n", generic_as_text(&$k, USE_COLOR, $info->TableInfo.key)); \
     *$v; })
 
-table_t Table_from_entries(array_t entries, const TypeInfo *type);
-void *Table_get(table_t t, const void *key, const TypeInfo *type);
-void *Table_get_raw(table_t t, const void *key, const TypeInfo *type);
-void *Table_entry(table_t t, int64_t n);
-void *Table_reserve(table_t *t, const void *key, const void *value, const TypeInfo *type);
-void Table_set(table_t *t, const void *key, const void *value, const TypeInfo *type);
-#define Table_set_value(t, key_expr, value_expr, type) ({ __typeof(key_expr) $k = key_expr; __typeof(value_expr) $v = value_expr; \
-                                                        Table_set(t, &$k, &$v, type); })
-#define Table_reserve_value(t, key_expr, type) ({ __typeof(key_expr) $k = key_expr; Table_reserve(t, &$k, NULL, type); })
-void Table_remove(table_t *t, const void *key, const TypeInfo *type);
-void Table_clear(table_t *t);
-void Table_mark_copy_on_write(table_t *t);
-int32_t Table_compare(const table_t *x, const table_t *y, const TypeInfo *type);
-bool Table_equal(const table_t *x, const table_t *y, const TypeInfo *type);
-uint32_t Table_hash(const table_t *t, const TypeInfo *type);
-CORD Table_as_text(const table_t *t, bool colorize, const TypeInfo *type);
+table_t Table$from_entries(array_t entries, const TypeInfo *type);
+void *Table$get(table_t t, const void *key, const TypeInfo *type);
+void *Table$get_raw(table_t t, const void *key, const TypeInfo *type);
+void *Table$entry(table_t t, int64_t n);
+void *Table$reserve(table_t *t, const void *key, const void *value, const TypeInfo *type);
+void Table$set(table_t *t, const void *key, const void *value, const TypeInfo *type);
+#define Table$set_value(t, key_expr, value_expr, type) ({ __typeof(key_expr) $k = key_expr; __typeof(value_expr) $v = value_expr; \
+                                                        Table$set(t, &$k, &$v, type); })
+#define Table$reserve_value(t, key_expr, type) ({ __typeof(key_expr) $k = key_expr; Table$reserve(t, &$k, NULL, type); })
+void Table$remove(table_t *t, const void *key, const TypeInfo *type);
+void Table$clear(table_t *t);
+void Table$mark_copy_on_write(table_t *t);
+int32_t Table$compare(const table_t *x, const table_t *y, const TypeInfo *type);
+bool Table$equal(const table_t *x, const table_t *y, const TypeInfo *type);
+uint32_t Table$hash(const table_t *t, const TypeInfo *type);
+CORD Table$as_text(const table_t *t, bool colorize, const TypeInfo *type);
 
-void *Table_str_entry(table_t t, int64_t n);
-void *Table_str_get(table_t t, const char *key);
-void *Table_str_get_raw(table_t t, const char *key);
-void Table_str_set(table_t *t, const char *key, const void *value);
-void *Table_str_reserve(table_t *t, const char *key, const void *value);
-void Table_str_remove(table_t *t, const char *key);
+void *Table$str_entry(table_t t, int64_t n);
+void *Table$str_get(table_t t, const char *key);
+void *Table$str_get_raw(table_t t, const char *key);
+void Table$str_set(table_t *t, const char *key, const void *value);
+void *Table$str_reserve(table_t *t, const char *key, const void *value);
+void Table$str_remove(table_t *t, const char *key);
 
-#define Table_length(t) ((t).entries.length)
+#define Table$length(t) ((t).entries.length)
 
 extern const TypeInfo StrToVoidStarTable;
 
diff --git a/builtins/text.c b/builtins/text.c
index f2a7c2f..0450e9b 100644
--- a/builtins/text.c
+++ b/builtins/text.c
@@ -24,16 +24,16 @@
 
 #define CLAMP(x, lo, hi) MIN(hi, MAX(x,lo))
 
-public CORD Text__as_text(const void *text, bool colorize, const TypeInfo *info)
+public CORD Text$as_text(const void *text, bool colorize, const TypeInfo *info)
 {
     if (!text) return info->TextInfo.lang;
-    CORD ret = Text__quoted(*(CORD*)text, colorize);
+    CORD ret = Text$quoted(*(CORD*)text, colorize);
     if (!streq(info->TextInfo.lang, "Text"))
         ret = colorize ? CORD_all("\x1b[1m$", info->TextInfo.lang, "\x1b[m", ret) : CORD_all("$", info->TextInfo.lang, ret);
     return ret;
 }
 
-public CORD Text__quoted(CORD str, bool colorize)
+public CORD Text$quoted(CORD str, bool colorize)
 {
     // Note: it's important to have unicode strings not get broken up with
     // escapes, otherwise they won't print right.
@@ -92,7 +92,7 @@ public CORD Text__quoted(CORD str, bool colorize)
     }
 }
 
-public int Text__compare(const CORD *x, const CORD *y)
+public int Text$compare(const CORD *x, const CORD *y)
 {
     uint8_t *xx = (uint8_t*)CORD_to_const_char_star(*x);
     uint8_t *yy = (uint8_t*)CORD_to_const_char_star(*y);
@@ -102,12 +102,12 @@ public int Text__compare(const CORD *x, const CORD *y)
     return result;
 }
 
-public bool Text__equal(const CORD *x, const CORD *y)
+public bool Text$equal(const CORD *x, const CORD *y)
 {
-    return Text__compare(x, y) == 0;
+    return Text$compare(x, y) == 0;
 }
 
-public uint32_t Text__hash(const CORD *cord)
+public uint32_t Text$hash(const CORD *cord)
 {
     if (!*cord) return 0;
 
@@ -124,7 +124,7 @@ public uint32_t Text__hash(const CORD *cord)
     return hash;
 }
 
-public CORD Text__upper(CORD str)
+public CORD Text$upper(CORD str)
 {
     if (!str) return str;
     size_t len = strlen(str) + 1;
@@ -133,7 +133,7 @@ public CORD Text__upper(CORD str)
     return (CORD)u8_toupper((const uint8_t*)str, len-1, uc_locale_language(), NULL, dest, &len);
 }
 
-public CORD Text__lower(CORD str)
+public CORD Text$lower(CORD str)
 {
     if (!str) return str;
     size_t len = strlen(str) + 1;
@@ -142,7 +142,7 @@ public CORD Text__lower(CORD str)
     return (CORD)u8_tolower((const uint8_t*)str, len-1, uc_locale_language(), NULL, dest, &len);
 }
 
-public CORD Text__title(CORD str)
+public CORD Text$title(CORD str)
 {
     if (!str) return str;
     size_t len = strlen(str) + 1;
@@ -151,7 +151,7 @@ public CORD Text__title(CORD str)
     return (CORD)u8_totitle((const uint8_t*)str, len-1, uc_locale_language(), NULL, dest, &len);
 }
 
-public bool Text__has(CORD str, CORD target, where_e where)
+public bool Text$has(CORD str, CORD target, where_e where)
 {
     if (!target) return true;
     if (!str) return false;
@@ -168,7 +168,7 @@ public bool Text__has(CORD str, CORD target, where_e where)
     }
 }
 
-public CORD Text__without(CORD str, CORD target, where_e where)
+public CORD Text$without(CORD str, CORD target, where_e where)
 {
     if (!str || !target) return str;
 
@@ -187,7 +187,7 @@ public CORD Text__without(CORD str, CORD target, where_e where)
     }
 }
 
-public CORD Text__trimmed(CORD str, CORD skip, where_e where)
+public CORD Text$trimmed(CORD str, CORD skip, where_e where)
 {
     if (!str || !skip) return str;
     const uint8_t *ustr = (const uint8_t*)CORD_to_const_char_star(str);
@@ -213,14 +213,14 @@ public CORD Text__trimmed(CORD str, CORD skip, where_e where)
     }
 }
 
-public find_result_t Text__find(CORD str, CORD pat)
+public find_result_t Text$find(CORD str, CORD pat)
 {
     if (!pat) return (find_result_t){.status=FIND_SUCCESS, .index=1};
     size_t pos = CORD_str(str, 0, pat);
     return (pos == CORD_NOT_FOUND) ? (find_result_t){.status=FIND_FAILURE} : (find_result_t){.status=FIND_SUCCESS, .index=(int32_t)pos};
 }
 
-public CORD Text__replace(CORD text, CORD pat, CORD replacement, int64_t limit)
+public CORD Text$replace(CORD text, CORD pat, CORD replacement, int64_t limit)
 {
     if (!text || !pat) return text;
     CORD ret = CORD_EMPTY;
@@ -233,7 +233,7 @@ public CORD Text__replace(CORD text, CORD pat, CORD replacement, int64_t limit)
     return CORD_cat(ret, CORD_substr(text, pos, str_len - pos));
 }
 
-public array_t Text__split(CORD str, CORD split)
+public array_t Text$split(CORD str, CORD split)
 {
     if (!str) return (array_t){.data=GC_MALLOC(sizeof(CORD)), .atomic=1, .length=1, .stride=sizeof(CORD)};
     array_t strings = {.stride=sizeof(CORD), .atomic=1};
@@ -257,7 +257,7 @@ public array_t Text__split(CORD str, CORD split)
     return strings;
 }
 
-public CORD Text__join(CORD glue, array_t pieces)
+public CORD Text$join(CORD glue, array_t pieces)
 {
     if (pieces.length == 0) return CORD_EMPTY;
 
@@ -269,7 +269,7 @@ public CORD Text__join(CORD glue, array_t pieces)
     return ret;
 }
 
-public array_t Text__clusters(CORD text)
+public array_t Text$clusters(CORD text)
 {
     array_t clusters = {.atomic=1};
     const uint8_t *ustr = (const uint8_t*)CORD_to_const_char_star(text);
@@ -285,7 +285,7 @@ public array_t Text__clusters(CORD text)
         char cluster_buf[len+1];
         strlcpy(cluster_buf, (char*)pos, len+1);
         CORD cluster = CORD_from_char_star(cluster_buf);
-        Array__insert(&clusters, &cluster, 0, $ArrayInfo(&Text));
+        Array$insert(&clusters, &cluster, 0, $ArrayInfo(&$Text));
         pos = next;
     }
 
@@ -293,7 +293,7 @@ public array_t Text__clusters(CORD text)
     return clusters;
 }
 
-public array_t Text__codepoints(CORD text)
+public array_t Text$codepoints(CORD text)
 {
     const uint8_t *ustr = (const uint8_t*)CORD_to_const_char_star(text);
     uint8_t norm_buf[128] = {0};
@@ -316,7 +316,7 @@ public array_t Text__codepoints(CORD text)
     return ret;
 }
 
-public array_t Text__bytes(CORD text)
+public array_t Text$bytes(CORD text)
 {
     const uint8_t *ustr = (const uint8_t*)CORD_to_const_char_star(text);
     uint8_t norm_buf[128] = {0};
@@ -336,7 +336,7 @@ public array_t Text__bytes(CORD text)
     return ret;
 }
 
-public int64_t Text__num_clusters(CORD text)
+public int64_t Text$num_clusters(CORD text)
 {
     const uint8_t *ustr = (const uint8_t*)CORD_to_const_char_star(text);
     int64_t num_clusters = 0;
@@ -349,7 +349,7 @@ public int64_t Text__num_clusters(CORD text)
     return num_clusters;
 }
 
-public int64_t Text__num_codepoints(CORD text)
+public int64_t Text$num_codepoints(CORD text)
 {
     const uint8_t *ustr = (const uint8_t*)CORD_to_const_char_star(text);
     uint8_t buf[128] = {0};
@@ -361,7 +361,7 @@ public int64_t Text__num_codepoints(CORD text)
     return num_codepoints;
 }
 
-public int64_t Text__num_bytes(CORD text)
+public int64_t Text$num_bytes(CORD text)
 {
     const uint8_t *ustr = (const uint8_t*)CORD_to_const_char_star(text);
     uint8_t norm_buf[128] = {0};
@@ -373,9 +373,9 @@ public int64_t Text__num_bytes(CORD text)
     return norm_len;
 }
 
-public array_t Text__character_names(CORD text)
+public array_t Text$character_names(CORD text)
 {
-    array_t codepoints = Text__codepoints(text);
+    array_t codepoints = Text$codepoints(text);
     array_t ret = {.length=codepoints.length, .stride=sizeof(CORD), .data=GC_MALLOC(sizeof(CORD)*codepoints.length)};
     for (int64_t i = 0; i < codepoints.length; i++) {
         char buf[UNINAME_MAX];
@@ -385,7 +385,7 @@ public array_t Text__character_names(CORD text)
     return ret;
 }
 
-public const TypeInfo Text = {
+public const TypeInfo $Text = {
     .size=sizeof(CORD),
     .align=__alignof__(CORD),
     .tag=TextInfo,
diff --git a/builtins/text.h b/builtins/text.h
index edbd119..3cda9d7 100644
--- a/builtins/text.h
+++ b/builtins/text.h
@@ -18,29 +18,29 @@ typedef struct {
     int32_t index;
 } find_result_t;
 
-CORD Text__as_text(const void *str, bool colorize, const TypeInfo *info);
-CORD Text__quoted(CORD str, bool colorize);
-int Text__compare(const CORD *x, const CORD *y);
-bool Text__equal(const CORD *x, const CORD *y);
-uint32_t Text__hash(const CORD *cord);
-CORD Text__upper(CORD str);
-CORD Text__lower(CORD str);
-CORD Text__title(CORD str);
-bool Text__has(CORD str, CORD target, where_e where);
-CORD Text__without(CORD str, CORD target, where_e where);
-CORD Text__trimmed(CORD str, CORD skip, where_e where);
-find_result_t Text__find(CORD str, CORD pat);
-CORD Text__replace(CORD text, CORD pat, CORD replacement, int64_t limit);
-array_t Text__split(CORD str, CORD split);
-CORD Text__join(CORD glue, array_t pieces);
-array_t Text__clusters(CORD text);
-array_t Text__codepoints(CORD text);
-array_t Text__bytes(CORD text);
-int64_t Text__num_clusters(CORD text);
-int64_t Text__num_codepoints(CORD text);
-int64_t Text__num_bytes(CORD text);
-array_t Text__character_names(CORD text);
+CORD Text$as_text(const void *str, bool colorize, const TypeInfo *info);
+CORD Text$quoted(CORD str, bool colorize);
+int Text$compare(const CORD *x, const CORD *y);
+bool Text$equal(const CORD *x, const CORD *y);
+uint32_t Text$hash(const CORD *cord);
+CORD Text$upper(CORD str);
+CORD Text$lower(CORD str);
+CORD Text$title(CORD str);
+bool Text$has(CORD str, CORD target, where_e where);
+CORD Text$without(CORD str, CORD target, where_e where);
+CORD Text$trimmed(CORD str, CORD skip, where_e where);
+find_result_t Text$find(CORD str, CORD pat);
+CORD Text$replace(CORD text, CORD pat, CORD replacement, int64_t limit);
+array_t Text$split(CORD str, CORD split);
+CORD Text$join(CORD glue, array_t pieces);
+array_t Text$clusters(CORD text);
+array_t Text$codepoints(CORD text);
+array_t Text$bytes(CORD text);
+int64_t Text$num_clusters(CORD text);
+int64_t Text$num_codepoints(CORD text);
+int64_t Text$num_bytes(CORD text);
+array_t Text$character_names(CORD text);
 
-extern const TypeInfo Text;
+extern const TypeInfo $Text;
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/types.c b/builtins/types.c
index cdf5873..355473e 100644
--- a/builtins/types.c
+++ b/builtins/types.c
@@ -11,7 +11,7 @@
 #include "table.h"
 #include "types.h"
 
-public CORD Type__as_text(const void *typeinfo, bool colorize, const TypeInfo *type)
+public CORD Type$as_text(const void *typeinfo, bool colorize, const TypeInfo *type)
 {
     if (!typeinfo) return "TypeInfo";
 
@@ -22,17 +22,17 @@ public CORD Type__as_text(const void *typeinfo, bool colorize, const TypeInfo *t
     return c;
 }
 
-public const TypeInfo TypeInfo_info = {
+public const TypeInfo $TypeInfo = {
     .size=sizeof(TypeInfo),
     .align=__alignof__(TypeInfo),
     .tag=CustomInfo,
     .TypeInfoInfo.type_str="TypeInfo",
 };
 
-public const TypeInfo Void = {.size=0, .align=0};
-public const TypeInfo Abort = {.size=0, .align=0};
+public const TypeInfo $Void = {.size=0, .align=0};
+public const TypeInfo $Abort = {.size=0, .align=0};
 
-public CORD Func__as_text(const void *fn, bool colorize, const TypeInfo *type)
+public CORD Func$as_text(const void *fn, bool colorize, const TypeInfo *type)
 {
     (void)fn;
     CORD c = type->FunctionInfo.type_str;
diff --git a/builtins/types.h b/builtins/types.h
index bf94b52..ee49d9a 100644
--- a/builtins/types.h
+++ b/builtins/types.h
@@ -63,12 +63,12 @@ typedef struct TypeInfo {
 #define $TypeInfoInfo(typestr) &((TypeInfo){.size=sizeof(TypeInfo), .align=__alignof__(TypeInfo), \
                                  .tag=TypeInfoInfo, .TypeInfoInfo.type_str=typestr})
 
-extern const TypeInfo TypeInfo_info;
-extern const TypeInfo Void;
-extern const TypeInfo Abort;
+extern const TypeInfo $TypeInfo;
+extern const TypeInfo $Void;
+extern const TypeInfo $Abort;
 #define Void_t void
 
-CORD Type__as_text(const void *typeinfo, bool colorize, const TypeInfo *type);
-CORD Func__as_text(const void *fn, bool colorize, const TypeInfo *type);
+CORD Type$as_text(const void *typeinfo, bool colorize, const TypeInfo *type);
+CORD Func$as_text(const void *fn, bool colorize, const TypeInfo *type);
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/util.h b/builtins/util.h
index 9c8d8e9..5344a7c 100644
--- a/builtins/util.h
+++ b/builtins/util.h
@@ -47,15 +47,15 @@ CORD CORD_asprintf(CORD fmt, ...);
 } while(0)
 
 #define LIST_MAP(src, var, ...) ({\
-    __typeof(src) __mapped = NULL; \
-    __typeof(src) *__next = &__mapped; \
+    __typeof(src) $mapped = NULL; \
+    __typeof(src) *$next = &$mapped; \
     for (__typeof(src) var = src; var; var = var->next) { \
-        *__next = GC_MALLOC(sizeof(__typeof(*(src)))); \
-        **__next = *var; \
-        **__next = (__typeof(*(src))){__VA_ARGS__}; \
-        __next = &((*__next)->next); \
+        *$next = GC_MALLOC(sizeof(__typeof(*(src)))); \
+        **$next = *var; \
+        **$next = (__typeof(*(src))){__VA_ARGS__}; \
+        $next = &((*$next)->next); \
     } \
-    __mapped; })
+    $mapped; })
 
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/compile.c b/compile.c
index 6af4bf1..3e88739 100644
--- a/compile.c
+++ b/compile.c
@@ -137,12 +137,12 @@ static CORD compile_lvalue(env_t *env, ast_t *ast)
             type_t *item_type = Match(container_t, ArrayType)->item_type;
             return CORD_all("$Array_lvalue(", compile_type(env, item_type), ", ", target_code, ", ", 
                             compile(env, index->index), ", ", compile_type_info(env, container_t),
-                            ", ", Text__quoted(ast->file->filename, false), ", ", heap_strf("%ld", ast->start - ast->file->text),
+                            ", ", Text$quoted(ast->file->filename, false), ", ", heap_strf("%ld", ast->start - ast->file->text),
                             ", ", heap_strf("%ld", ast->end - ast->file->text), ")");
         } else if (container_t->tag == TableType) {
             CORD target_code = compile_to_pointer_depth(env, index->indexed, 1, false);
             type_t *value_t = Match(container_t, TableType)->value_type;
-            return CORD_all("*(", compile_type(env, value_t), "*)Table_reserve_value(", target_code, ", ",
+            return CORD_all("*(", compile_type(env, value_t), "*)Table$reserve_value(", target_code, ", ",
                             compile(env, index->index),", ", compile_type_info(env, container_t), ")");
         } else {
             code_err(ast, "I don't know how to assign to this target");
@@ -376,15 +376,15 @@ CORD compile_statement(env_t *env, ast_t *ast)
                 if (promote(env, &rhs, rhs_t, Match(lhs_t, ArrayType)->item_type)) {
                     // arr ++= item
                     if (update->lhs->tag == Var)
-                        return CORD_all("Array__insert(&", lhs, ", $stack(", rhs, "), 0, ", compile_type_info(env, operand_t), ");");
+                        return CORD_all("Array$insert(&", lhs, ", $stack(", rhs, "), 0, ", compile_type_info(env, operand_t), ");");
                     else
-                        return CORD_all(lhs, "Array__concat(", lhs, ", $Array(", rhs, "), ", compile_type_info(env, operand_t), ");");
+                        return CORD_all(lhs, "Array$concat(", lhs, ", $Array(", rhs, "), ", compile_type_info(env, operand_t), ");");
                 } else {
                     // arr ++= [...]
                     if (update->lhs->tag == Var)
-                        return CORD_all("Array__insert_all(&", lhs, ", ", rhs, ", 0, ", compile_type_info(env, operand_t), ");");
+                        return CORD_all("Array$insert_all(&", lhs, ", ", rhs, ", 0, ", compile_type_info(env, operand_t), ");");
                     else
-                        return CORD_all(lhs, "Array__concat(", lhs, ", ", rhs, ", ", compile_type_info(env, operand_t), ");");
+                        return CORD_all(lhs, "Array$concat(", lhs, ", ", rhs, ", ", compile_type_info(env, operand_t), ");");
                 }
             } else {
                 code_err(ast, "'++=' is not implemented for %T types", operand_t);
@@ -408,7 +408,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
         CORD_appendf(&env->code->typedefs, "extern const TypeInfo %r%s;\n", env->file_prefix, def->name);
         CORD_appendf(&env->code->typeinfos, "public const TypeInfo %r%s = {%zu, %zu, {.tag=TextInfo, .TextInfo={%r}}};\n",
                      env->file_prefix, def->name, sizeof(CORD), __alignof__(CORD),
-                     Text__quoted(def->name, false));
+                     Text$quoted(def->name, false));
         compile_namespace(env, def->name, def->namespace);
         return CORD_EMPTY;
     }
@@ -466,7 +466,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
             ast_t *args_def = FakeAST(StructDef, .name=arg_type_name, .fields=fndef->args);
             bind_statement(env, args_def);
             (void)compile_statement(env, args_def);
-            type_t *args_t = Table_str_get(*env->types, arg_type_name);
+            type_t *args_t = Table$str_get(*env->types, arg_type_name);
             assert(args_t);
 
             CORD all_args = CORD_EMPTY;
@@ -475,8 +475,8 @@ CORD compile_statement(env_t *env, ast_t *ast)
 
             CORD pop_code = CORD_EMPTY;
             if (fndef->cache->tag == Int && Match(fndef->cache, Int)->i < INT64_MAX) {
-                pop_code = CORD_all("if (Table_length($cache) > ", compile(body_scope, fndef->cache),
-                                    ") Table_remove(&$cache, NULL, $table_info);\n");
+                pop_code = CORD_all("if (Table$length($cache) > ", compile(body_scope, fndef->cache),
+                                    ") Table$remove(&$cache, NULL, $table_info);\n");
             }
 
             CORD wrapper = CORD_all(
@@ -484,11 +484,11 @@ CORD compile_statement(env_t *env, ast_t *ast)
                 "static table_t $cache = {};\n",
                 compile_type(env, args_t), " $args = {", all_args, "};\n"
                 "static const TypeInfo *$table_type = $TableInfo(", compile_type_info(env, args_t), ", ", compile_type_info(env, ret_t), ");\n",
-                ret_type_code, "*$cached = Table_get_raw($cache, &$args, $table_type);\n"
+                ret_type_code, "*$cached = Table$get_raw($cache, &$args, $table_type);\n"
                 "if ($cached) return *$cached;\n",
                 ret_type_code, " $ret = ", name, "$uncached(", all_args, ");\n",
                 pop_code,
-                "Table_set(&$cache, &$args, &$ret, $table_type);\n"
+                "Table$set(&$cache, &$args, &$ret, $table_type);\n"
                 "return $ret;\n"
                 "}\n");
             env->code->funcs = CORD_cat(env->code->funcs, wrapper);
@@ -783,24 +783,24 @@ CORD compile_statement(env_t *env, ast_t *ast)
 CORD expr_as_text(env_t *env, CORD expr, type_t *t, CORD color)
 {
     switch (t->tag) {
-    case MemoryType: return CORD_asprintf("Memory__as_text($stack(%r), %r, &Memory)", expr, color);
-    case BoolType: return CORD_asprintf("Bool__as_text($stack(%r), %r, &Bool)", expr, color);
+    case MemoryType: return CORD_asprintf("Memory$as_text($stack(%r), %r, &$Memory)", expr, color);
+    case BoolType: return CORD_asprintf("Bool$as_text($stack(%r), %r, &$Bool)", expr, color);
     case IntType: {
         CORD name = type_to_cord(t);
-        return CORD_asprintf("%r__as_text($stack(%r), %r, &%r)", name, expr, color, name);
+        return CORD_asprintf("%r$as_text($stack(%r), %r, &$%r)", name, expr, color, name);
     }
     case NumType: {
         CORD name = type_to_cord(t);
-        return CORD_asprintf("%r__as_text($stack(%r), %r, &Num%r)", name, expr, color, name);
+        return CORD_asprintf("%r$as_text($stack(%r), %r, &$Num%r)", name, expr, color, name);
     }
     case TextType: {
         const char *lang = Match(t, TextType)->lang;
-        return CORD_asprintf("Text__as_text($stack(%r), %r, &%s)", expr, color, lang ? lang : "Text");
+        return CORD_asprintf("Text$as_text($stack(%r), %r, &%s)", expr, color, lang ? lang : "$Text");
     }
-    case ArrayType: return CORD_asprintf("Array__as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
-    case TableType: return CORD_asprintf("Table_as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
-    case FunctionType: return CORD_asprintf("Func__as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
-    case PointerType: return CORD_asprintf("Pointer__as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+    case ArrayType: return CORD_asprintf("Array$as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+    case TableType: return CORD_asprintf("Table$as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+    case FunctionType: return CORD_asprintf("Func$as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+    case PointerType: return CORD_asprintf("Pointer$as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
     case StructType: case EnumType: return CORD_asprintf("(%r)->CustomInfo.as_text($stack(%r), %r, %r)",
                                                          compile_type_info(env, t), expr, color, compile_type_info(env, t));
     default: compiler_err(NULL, NULL, NULL, "Stringifying is not supported for %T", t);
@@ -865,7 +865,7 @@ static CORD compile_arguments(env_t *env, ast_t *call_ast, arg_t *spec_args, arg
                     CORD value = compile(env, call_arg->value);
                     if (!promote(env, &value, actual_t, spec_arg->type))
                         code_err(call_arg->value, "This argument is supposed to be a %T, but this value is a %T", spec_arg->type, actual_t);
-                    Table_str_set(&used_args, call_arg->name, call_arg);
+                    Table$str_set(&used_args, call_arg->name, call_arg);
                     if (code) code = CORD_cat(code, ", ");
                     code = CORD_cat(code, value);
                     goto found_it;
@@ -877,12 +877,12 @@ static CORD compile_arguments(env_t *env, ast_t *call_ast, arg_t *spec_args, arg
         for (arg_ast_t *call_arg = call_args; call_arg; call_arg = call_arg->next) {
             if (call_arg->name) continue;
             const char *pseudoname = heap_strf("%ld", i++);
-            if (!Table_str_get(used_args, pseudoname)) {
+            if (!Table$str_get(used_args, pseudoname)) {
                 type_t *actual_t = get_type(env, call_arg->value);
                 CORD value = compile(env, call_arg->value);
                 if (!promote(env, &value, actual_t, spec_arg->type))
                     code_err(call_arg->value, "This argument is supposed to be a %T, but this value is a %T", spec_arg->type, actual_t);
-                Table_str_set(&used_args, pseudoname, call_arg);
+                Table$str_set(&used_args, pseudoname, call_arg);
                 if (code) code = CORD_cat(code, ", ");
                 code = CORD_cat(code, value);
                 goto found_it;
@@ -903,11 +903,11 @@ static CORD compile_arguments(env_t *env, ast_t *call_ast, arg_t *spec_args, arg
     int64_t i = 1;
     for (arg_ast_t *call_arg = call_args; call_arg; call_arg = call_arg->next) {
         if (call_arg->name) {
-            if (!Table_str_get(used_args, call_arg->name))
+            if (!Table$str_get(used_args, call_arg->name))
                 code_err(call_arg->value, "There is no argument with the name '%s'", call_arg->name);
         } else {
             const char *pseudoname = heap_strf("%ld", i++);
-            if (!Table_str_get(used_args, pseudoname))
+            if (!Table$str_get(used_args, pseudoname))
                 code_err(call_arg->value, "This is one argument too many!");
         }
     }
@@ -939,7 +939,7 @@ CORD compile(env_t *env, ast_t *ast)
         switch (value_type(t)->tag) {
         case TextType: {
             CORD str = compile_to_pointer_depth(env, expr, 0, false);
-            return CORD_all("Text__num_clusters(", str, ")");
+            return CORD_all("Text$num_clusters(", str, ")");
         }
         case ArrayType: {
             if (t->tag == PointerType) {
@@ -1125,7 +1125,7 @@ CORD compile(env_t *env, ast_t *ast)
                 return CORD_all("CORD_cat(", lhs, ", ", rhs, ")");
             }
             case ArrayType: {
-                return CORD_all("Array__concat(", lhs, ", ", rhs, ", ", compile_type_info(env, operand_t), ")");
+                return CORD_all("Array$concat(", lhs, ", ", rhs, ", ", compile_type_info(env, operand_t), ")");
             }
             default:
                 code_err(ast, "Concatenation isn't supported for %T types", operand_t);
@@ -1165,7 +1165,7 @@ CORD compile(env_t *env, ast_t *ast)
     }
     case TextJoin: {
         const char *lang = Match(ast, TextJoin)->lang;
-        type_t *text_t = Table_str_get(*env->types, lang ? lang : "Text");
+        type_t *text_t = Table$str_get(*env->types, lang ? lang : "Text");
         if (!text_t || text_t->tag != TextType)
             code_err(ast, "%s is not a valid text language name", lang);
         env_t *lang_env = lang ? Match(get_binding(env, lang)->type, TypeInfoType)->env : NULL;
@@ -1186,8 +1186,8 @@ CORD compile(env_t *env, ast_t *ast)
                 } else if (lang && lang_env) {
                     // Get conversion function:
                     chunk_code = compile(env, chunk->ast);
-                    for (int64_t i = 1; i <= Table_length(*lang_env->locals); i++) {
-                        struct {const char *name; binding_t *b; } *entry = Table_entry(*lang_env->locals, i);
+                    for (int64_t i = 1; i <= Table$length(*lang_env->locals); i++) {
+                        struct {const char *name; binding_t *b; } *entry = Table$entry(*lang_env->locals, i);
                         if (entry->b->type->tag != FunctionType) continue;
                         if (!(streq(entry->name, "escape") || strncmp(entry->name, "escape_", strlen("escape_")) == 0))
                             continue;
@@ -1421,14 +1421,14 @@ CORD compile(env_t *env, ast_t *ast)
             (void)compile_statement(body_scope, stmt->ast);
 
         CORD userdata;
-        if (Table_length(*fn_ctx.closed_vars) == 0) {
+        if (Table$length(*fn_ctx.closed_vars) == 0) {
             code = CORD_cat(code, "void *$userdata)");
             userdata = "NULL";
         } else {
             CORD def = "typedef struct {";
             userdata = CORD_all("new(", name, "$userdata_t");
-            for (int64_t i = 1; i <= Table_length(*fn_ctx.closed_vars); i++) {
-                struct { const char *name; binding_t *b; } *entry = Table_entry(*fn_ctx.closed_vars, i);
+            for (int64_t i = 1; i <= Table$length(*fn_ctx.closed_vars); i++) {
+                struct { const char *name; binding_t *b; } *entry = Table$entry(*fn_ctx.closed_vars, i);
                 def = CORD_all(def, compile_declaration(env, entry->b->type, entry->name), "; ");
                 userdata = CORD_all(userdata, ", ", entry->b->code);
             }
@@ -1460,42 +1460,42 @@ CORD compile(env_t *env, ast_t *ast)
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
                 arg_t *arg_spec = new(arg_t, .name="item", .type=item_t,
                                       .next=new(arg_t, .name="at", .type=Type(IntType, .bits=64), .default_val=FakeAST(Int, .i=0, .bits=64)));
-                return CORD_all("Array__insert_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                return CORD_all("Array$insert_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "insert_all")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
                 arg_t *arg_spec = new(arg_t, .name="items", .type=self_value_t,
                                       .next=new(arg_t, .name="at", .type=Type(IntType, .bits=64), .default_val=FakeAST(Int, .i=0, .bits=64)));
-                return CORD_all("Array__insert_all(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                return CORD_all("Array$insert_all(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "remove")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
                 arg_t *arg_spec = new(arg_t, .name="index", .type=Type(IntType, .bits=64), .default_val=FakeAST(Int, .i=-1, .bits=64),
                                       .next=new(arg_t, .name="count", .type=Type(IntType, .bits=64), .default_val=FakeAST(Int, .i=1, .bits=64)));
-                return CORD_all("Array__remove(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                return CORD_all("Array$remove(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "random")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 0, false);
-                return CORD_all("Array__random(", self, ")");
+                return CORD_all("Array$random(", self, ")");
             } else if (streq(call->name, "shuffle")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
-                return CORD_all("Array__shuffle(", self, ", ", compile_type_info(env, self_value_t), ")");
+                return CORD_all("Array$shuffle(", self, ", ", compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "sort")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
-                return CORD_all("Array__sort(", self, ", ", compile_type_info(env, self_value_t), ")");
+                return CORD_all("Array$sort(", self, ", ", compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "clear")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
-                return CORD_all("Array__clear(", self, ")");
+                return CORD_all("Array$clear(", self, ")");
             } else if (streq(call->name, "slice")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
                 arg_t *arg_spec = new(arg_t, .name="first", .type=Type(IntType, .bits=64), .default_val=FakeAST(Int, .i=1, .bits=64),
                                       .next=new(arg_t, .name="length", .type=Type(IntType, .bits=64), .default_val=FakeAST(Int, .i=INT64_MAX, .bits=64),
                                                 .next=new(arg_t, .name="stride", .type=Type(IntType, .bits=64), .default_val=FakeAST(Int, .i=1, .bits=64))));
-                return CORD_all("Array__slice(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                return CORD_all("Array$slice(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "reversed")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 0, false);
-                return CORD_all("Array__reversed(", self, ")");
+                return CORD_all("Array$reversed(", self, ")");
             } else code_err(ast, "There is no '%s' method for arrays", call->name);
         }
         case TableType: {
@@ -1503,22 +1503,22 @@ CORD compile(env_t *env, ast_t *ast)
             if (streq(call->name, "get")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 0, false);
                 arg_t *arg_spec = new(arg_t, .name="key", .type=Type(PointerType, .pointed=table->key_type, .is_stack=true, .is_readonly=true));
-                return CORD_all("Table_get(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                return CORD_all("Table$get(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "set")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
                 arg_t *arg_spec = new(arg_t, .name="key", .type=table->key_type,
                                       .next=new(arg_t, .name="value", .type=table->value_type));
-                return CORD_all("Table_set_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                return CORD_all("Table$set_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "remove")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
                 arg_t *arg_spec = new(arg_t, .name="key", .type=Type(PointerType, .pointed=table->key_type, .is_stack=true, .is_readonly=true));
-                return CORD_all("Table_remove(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
+                return CORD_all("Table$remove(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ",
                                 compile_type_info(env, self_value_t), ")");
             } else if (streq(call->name, "clear")) {
                 CORD self = compile_to_pointer_depth(env, call->self, 1, false);
-                return CORD_all("Table_clear(", self, ")");
+                return CORD_all("Table$clear(", self, ")");
             } else code_err(ast, "There is no '%s' method for tables", call->name);
         }
         default: {
@@ -1634,7 +1634,7 @@ CORD compile(env_t *env, ast_t *ast)
             empty = FakeAST(
                 InlineCCode, 
                 CORD_asprintf("fail_source(%r, %ld, %ld, \"This collection was empty!\");\n",
-                              Text__quoted(ast->file->filename, false), (long)(reduction->iter->start - reduction->iter->file->text),
+                              Text$quoted(ast->file->filename, false), (long)(reduction->iter->start - reduction->iter->file->text),
                               (long)(reduction->iter->end - reduction->iter->file->text)));
         }
         ast_t *i = FakeAST(Var, "$i");
@@ -1705,7 +1705,7 @@ CORD compile(env_t *env, ast_t *ast)
         }
         case ModuleType: {
             const char *name = Match(value_t, ModuleType)->name;
-            env_t *module_env = Table_str_get(*env->imports, name);
+            env_t *module_env = Table$str_get(*env->imports, name);
             return compile(module_env, WrapAST(ast, Var, f->field));
         }
         default:
@@ -1722,7 +1722,7 @@ CORD compile(env_t *env, ast_t *ast)
             if (ptr->pointed->tag == ArrayType) {
                 return CORD_all("({ array_t *$arr = ", compile(env, indexing->indexed), "; $arr->data_refcount = 3; *$arr; })");
             } else if (ptr->pointed->tag == TableType) {
-                return CORD_all("({ table_t *$t = ", compile(env, indexing->indexed), "; Table_mark_copy_on_write($t); *$t; })");
+                return CORD_all("({ table_t *$t = ", compile(env, indexing->indexed), "; Table$mark_copy_on_write($t); *$t; })");
             } else {
                 return CORD_all("*(", compile(env, indexing->indexed), ")");
             }
@@ -1741,7 +1741,7 @@ CORD compile(env_t *env, ast_t *ast)
                 return CORD_all("$Array_get_unchecked", compile_type(env, item_type), ", ", arr, ", ", index, ")");
             else
                 return CORD_all("$Array_get(", compile_type(env, item_type), ", ", arr, ", ", index, ", ",
-                                Text__quoted(f->filename, false), ", ", CORD_asprintf("%ld", (int64_t)(indexing->index->start - f->text)), ", ",
+                                Text$quoted(f->filename, false), ", ", CORD_asprintf("%ld", (int64_t)(indexing->index->start - f->text)), ", ",
                                 CORD_asprintf("%ld", (int64_t)(indexing->index->end - f->text)),
                                 ")");
         }
@@ -1755,7 +1755,7 @@ CORD compile(env_t *env, ast_t *ast)
             file_t *f = indexing->index->file;
             return CORD_all("$Table_get(", table, ", ", compile_type(env, key_t), ", ", compile_type(env, value_t), ", ",
                             key, ", ", compile_type_info(env, container_t), ", ",
-                            Text__quoted(f->filename, false), ", ", CORD_asprintf("%ld", (int64_t)(indexing->index->start - f->text)), ", ",
+                            Text$quoted(f->filename, false), ", ", CORD_asprintf("%ld", (int64_t)(indexing->index->start - f->text)), ", ",
                             CORD_asprintf("%ld", (int64_t)(indexing->index->end - f->text)),
                             ")");
         }
@@ -1812,10 +1812,10 @@ void compile_namespace(env_t *env, const char *ns_name, ast_t *block)
 CORD compile_type_info(env_t *env, type_t *t)
 {
     switch (t->tag) {
-    case BoolType: case IntType: case NumType: return CORD_asprintf("&%r", type_to_cord(t));
+    case BoolType: case IntType: case NumType: return CORD_asprintf("&$%r", type_to_cord(t));
     case TextType: {
         auto text = Match(t, TextType);
-        return text->lang ? CORD_all("(&", text->env->file_prefix, text->lang, ")") : "&Text";
+        return text->lang ? CORD_all("(&", text->env->file_prefix, text->lang, ")") : "&$Text";
     }
     case StructType: {
         auto s = Match(t, StructType);
@@ -1838,15 +1838,15 @@ CORD compile_type_info(env_t *env, type_t *t)
         auto ptr = Match(t, PointerType);
         CORD sigil = ptr->is_stack ? "&" : (ptr->is_optional ? "?" : "@");
         if (ptr->is_readonly) sigil = CORD_cat(sigil, "(readonly)");
-        return CORD_asprintf("$PointerInfo(%r, %r)", Text__quoted(sigil, false), compile_type_info(env, ptr->pointed));
+        return CORD_asprintf("$PointerInfo(%r, %r)", Text$quoted(sigil, false), compile_type_info(env, ptr->pointed));
     }
     case FunctionType: {
-        return CORD_asprintf("$FunctionInfo(%r)", Text__quoted(type_to_cord(t), false));
+        return CORD_asprintf("$FunctionInfo(%r)", Text$quoted(type_to_cord(t), false));
     }
     case ClosureType: {
-        return CORD_asprintf("$ClosureInfo(%r)", Text__quoted(type_to_cord(t), false));
+        return CORD_asprintf("$ClosureInfo(%r)", Text$quoted(type_to_cord(t), false));
     }
-    case TypeInfoType: return "&TypeInfo_info";
+    case TypeInfoType: return "&$TypeInfo";
     default:
         compiler_err(NULL, 0, 0, "I couldn't convert to a type info: %T", t);
     }
@@ -1858,7 +1858,7 @@ module_code_t compile_file(ast_t *ast)
 
     const char *name = file_base_name(ast->file->filename);
     env->file_prefix = heap_strf("%s$", name);
-    Table_str_set(env->imports, name, env);
+    Table$str_set(env->imports, name, env);
 
     for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
         bind_statement(env, stmt->ast);
@@ -1871,7 +1871,7 @@ module_code_t compile_file(ast_t *ast)
         .module_name=name,
         .object_files=env->code->object_files,
         .header=CORD_all(
-            // CORD_asprintf("#line 0 %r\n", Text__quoted(ast->file->filename, false)),
+            // CORD_asprintf("#line 0 %r\n", Text$quoted(ast->file->filename, false)),
             "#include <tomo/tomo.h>\n",
             env->code->typedefs, "\n",
             env->code->typecode, "\n",
@@ -1879,7 +1879,7 @@ module_code_t compile_file(ast_t *ast)
             "public void ", env->file_prefix, "use(void);\n"
         ),
         .c_file=CORD_all(
-            // CORD_asprintf("#line 0 %r\n", Text__quoted(ast->file->filename, false)),
+            // CORD_asprintf("#line 0 %r\n", Text$quoted(ast->file->filename, false)),
             env->code->imports, "\n",
             env->code->staticdefs, "\n",
             env->code->funcs, "\n",
diff --git a/enums.c b/enums.c
index d6b4c05..689c751 100644
--- a/enums.c
+++ b/enums.c
@@ -58,7 +58,7 @@ static CORD compile_compare_method(env_t *env, ast_t *ast)
                              "switch (x->$tag) {\n");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
         if (tag->fields) {
-            type_t *tag_type = Table_str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
+            type_t *tag_type = Table$str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
             cmp_func = CORD_all(cmp_func, "\tcase $tag$", full_name, "$", tag->name, ": "
                                 "return generic_compare(&x->", tag->name, ", &y->", tag->name, ", ", compile_type_info(env, tag_type), ");\n");
         } else {
@@ -80,7 +80,7 @@ static CORD compile_equals_method(env_t *env, ast_t *ast)
                              "switch (x->$tag) {\n");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
         if (tag->fields) {
-            type_t *tag_type = Table_str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
+            type_t *tag_type = Table$str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
             eq_func = CORD_all(eq_func, "\tcase $tag$", full_name, "$", tag->name, ": "
                                 "return generic_equal(&x->", tag->name, ", &y->", tag->name, ", ", compile_type_info(env, tag_type), ");\n");
         } else {
@@ -101,7 +101,7 @@ static CORD compile_hash_method(env_t *env, ast_t *ast)
                               "switch (obj->$tag) {\n");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
         if (tag->fields) {
-            type_t *tag_type = Table_str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
+            type_t *tag_type = Table$str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
             hash_func = CORD_all(hash_func, "\tcase $tag$", full_name, "$", tag->name, ": "
                                  "hashes[1] = generic_hash(&obj->", tag->name, ", ", compile_type_info(env, tag_type), ");\n"
                                  "break;\n");
@@ -163,7 +163,7 @@ void compile_enum_def(env_t *env, ast_t *ast)
     enum_def = CORD_cat(enum_def, "};\n};\n");
     env->code->typecode = CORD_cat(env->code->typecode, enum_def);
 
-    type_t *t = Table_str_get(*env->types, def->name);
+    type_t *t = Table$str_get(*env->types, def->name);
     CORD typeinfo = CORD_asprintf("public const TypeInfo %s = {%zu, %zu, {.tag=CustomInfo, .CustomInfo={",
                                   full_name, type_size(t), type_align(t));
 
diff --git a/environment.c b/environment.c
index b96d51e..6de8fb2 100644
--- a/environment.c
+++ b/environment.c
@@ -35,7 +35,7 @@ env_t *new_compilation_unit(void)
     for (size_t i = 0; i < sizeof(global_vars)/sizeof(global_vars[0]); i++) {
         binding_t *b = new(binding_t);
         *b = global_vars[i].binding;
-        Table_str_set(env->globals, global_vars[i].name, b);
+        Table$str_set(env->globals, global_vars[i].name, b);
     }
 
     typedef struct {
@@ -49,63 +49,63 @@ env_t *new_compilation_unit(void)
         CORD struct_val;
         array_t namespace;
     } global_types[] = {
-        {"Bool", Type(BoolType), "Bool_t", "Bool", {}},
-        {"Int", Type(IntType, .bits=64), "Int_t", "Int", $TypedArray(ns_entry_t,
-            {"format", "Int__format", "func(i:Int, digits=0)->Text"},
-            {"hex", "Int__hex", "func(i:Int, digits=0, uppercase=yes, prefix=yes)->Text"},
-            {"octal", "Int__octal", "func(i:Int, digits=0, prefix=yes)->Text"},
-            {"random", "Int__random", "func(min=0, max=0xffffffff)->Int"},
-            {"bits", "Int__bits", "func(x:Int)->[Bool]"},
+        {"Bool", Type(BoolType), "Bool_t", "$Bool", {}},
+        {"Int", Type(IntType, .bits=64), "Int_t", "$Int", $TypedArray(ns_entry_t,
+            {"format", "Int$format", "func(i:Int, digits=0)->Text"},
+            {"hex", "Int$hex", "func(i:Int, digits=0, uppercase=yes, prefix=yes)->Text"},
+            {"octal", "Int$octal", "func(i:Int, digits=0, prefix=yes)->Text"},
+            {"random", "Int$random", "func(min=0, max=0xffffffff)->Int"},
+            {"bits", "Int$bits", "func(x:Int)->[Bool]"},
             {"abs", "labs", "func(i:Int)->Int"},
-            {"min", "Int__min", "Int"},
-            {"max", "Int__max", "Int"},
+            {"min", "Int$min", "Int"},
+            {"max", "Int$max", "Int"},
         )},
-        {"Int32", Type(IntType, .bits=32), "Int32_t", "Int32", $TypedArray(ns_entry_t,
-            {"format", "Int32__format", "func(i:Int32, digits=0)->Text"},
-            {"hex", "Int32__hex", "func(i:Int32, digits=0, uppercase=yes, prefix=yes)->Text"},
-            {"octal", "Int32__octal", "func(i:Int32, digits=0, prefix=yes)->Text"},
-            {"random", "Int32__random", "func(min=0, max=0xffffffff)->Int32"},
-            {"bits", "Int32__bits", "func(x:Int32)->[Bool]"},
+        {"Int32", Type(IntType, .bits=32), "Int32_t", "$Int32", $TypedArray(ns_entry_t,
+            {"format", "Int32$format", "func(i:Int32, digits=0)->Text"},
+            {"hex", "Int32$hex", "func(i:Int32, digits=0, uppercase=yes, prefix=yes)->Text"},
+            {"octal", "Int32$octal", "func(i:Int32, digits=0, prefix=yes)->Text"},
+            {"random", "Int32$random", "func(min=0, max=0xffffffff)->Int32"},
+            {"bits", "Int32$bits", "func(x:Int32)->[Bool]"},
             {"abs", "abs", "func(i:Int32)->Int32"},
-            {"min", "Int32__min", "Int32"},
-            {"max", "Int32__max", "Int32"},
+            {"min", "Int32$min", "Int32"},
+            {"max", "Int32$max", "Int32"},
         )},
-        {"Int16", Type(IntType, .bits=16), "Int16_t", "Int16", $TypedArray(ns_entry_t,
-            {"format", "Int16__format", "func(i:Int16, digits=0)->Text"},
-            {"hex", "Int16__hex", "func(i:Int16, digits=0, uppercase=yes, prefix=yes)->Text"},
-            {"octal", "Int16__octal", "func(i:Int16, digits=0, prefix=yes)->Text"},
-            {"random", "Int16__random", "func(min=0, max=0xffffffff)->Int16"},
-            {"bits", "Int16__bits", "func(x:Int16)->[Bool]"},
+        {"Int16", Type(IntType, .bits=16), "Int16_t", "$Int16", $TypedArray(ns_entry_t,
+            {"format", "Int16$format", "func(i:Int16, digits=0)->Text"},
+            {"hex", "Int16$hex", "func(i:Int16, digits=0, uppercase=yes, prefix=yes)->Text"},
+            {"octal", "Int16$octal", "func(i:Int16, digits=0, prefix=yes)->Text"},
+            {"random", "Int16$random", "func(min=0, max=0xffffffff)->Int16"},
+            {"bits", "Int16$bits", "func(x:Int16)->[Bool]"},
             {"abs", "abs", "func(i:Int16)->Int16"},
-            {"min", "Int16__min", "Int16"},
-            {"max", "Int16__max", "Int16"},
+            {"min", "Int16$min", "Int16"},
+            {"max", "Int16$max", "Int16"},
         )},
-        {"Int8", Type(IntType, .bits=8), "Int8_t", "Int8", $TypedArray(ns_entry_t,
-            {"format", "Int8__format", "func(i:Int8, digits=0)->Text"},
-            {"hex", "Int8__hex", "func(i:Int8, digits=0, uppercase=yes, prefix=yes)->Text"},
-            {"octal", "Int8__octal", "func(i:Int8, digits=0, prefix=yes)->Text"},
-            {"random", "Int8__random", "func(min=0, max=0xffffffff)->Int8"},
-            {"bits", "Int8__bits", "func(x:Int8)->[Bool]"},
+        {"Int8", Type(IntType, .bits=8), "Int8_t", "$Int8", $TypedArray(ns_entry_t,
+            {"format", "Int8$format", "func(i:Int8, digits=0)->Text"},
+            {"hex", "Int8$hex", "func(i:Int8, digits=0, uppercase=yes, prefix=yes)->Text"},
+            {"octal", "Int8$octal", "func(i:Int8, digits=0, prefix=yes)->Text"},
+            {"random", "Int8$random", "func(min=0, max=0xffffffff)->Int8"},
+            {"bits", "Int8$bits", "func(x:Int8)->[Bool]"},
             {"abs", "abs", "func(i:Int8)->Int8"},
-            {"min", "Int8__min", "Int8"},
-            {"max", "Int8__max", "Int8"},
+            {"min", "Int8$min", "Int8"},
+            {"max", "Int8$max", "Int8"},
         )},
 #define C(name) {#name, "M_"#name, "Num"}
 #define F(name) {#name, #name, "func(n:Num)->Num"}
 #define F2(name) {#name, #name, "func(x:Num, y:Num)->Num"}
-        {"Num", Type(NumType, .bits=64), "Num_t", "Num", $TypedArray(ns_entry_t,
-            {"near", "Num__near", "func(x:Num, y:Num, ratio=1e-9, min_epsilon=1e-9)->Bool"},
-            {"format", "Num__format", "func(n:Num, precision=0)->Text"},
-            {"scientific", "Num__scientific", "func(n:Num, precision=0)->Text"},
-            {"nan", "Num__nan", "func(tag=\"\")->Num"},
-            {"isinf", "Num__isinf", "func(n:Num)->Bool"},
-            {"isfinite", "Num__isfinite", "func(n:Num)->Bool"},
-            {"isnan", "Num__isnan", "func(n:Num)->Bool"},
+        {"Num", Type(NumType, .bits=64), "Num_t", "$Num", $TypedArray(ns_entry_t,
+            {"near", "Num$near", "func(x:Num, y:Num, ratio=1e-9, min_epsilon=1e-9)->Bool"},
+            {"format", "Num$format", "func(n:Num, precision=0)->Text"},
+            {"scientific", "Num$scientific", "func(n:Num, precision=0)->Text"},
+            {"nan", "Num$nan", "func(tag=\"\")->Num"},
+            {"isinf", "Num$isinf", "func(n:Num)->Bool"},
+            {"isfinite", "Num$isfinite", "func(n:Num)->Bool"},
+            {"isnan", "Num$isnan", "func(n:Num)->Bool"},
             C(2_SQRTPI), C(E), C(PI_2), C(2_PI), C(1_PI), C(LN10), C(LN2), C(LOG2E),
             C(PI), C(PI_4), C(SQRT2), C(SQRT1_2),
             {"INF", "INFINITY", "Num"},
             {"TAU", "(2.*M_PI)", "Num"},
-            {"random", "Num__random", "func()->Num"},
+            {"random", "Num$random", "func()->Num"},
             {"abs", "fabs", "func(n:Num)->Num"},
             F(acos), F(acosh), F(asin), F(asinh), F(atan), F(atanh), F(cbrt), F(ceil), F(cos), F(cosh), F(erf), F(erfc),
             F(exp), F(exp2), F(expm1), F(floor), F(j0), F(j1), F(log), F(log10), F(log1p), F(log2), F(logb),
@@ -119,19 +119,19 @@ env_t *new_compilation_unit(void)
 #define C(name) {#name, "(Num32_t)(M_"#name")", "Num32"}
 #define F(name) {#name, #name"f", "func(n:Num32)->Num32"}
 #define F2(name) {#name, #name"f", "func(x:Num32, y:Num32)->Num32"}
-        {"Num32", Type(NumType, .bits=32), "Num32_t", "Num32", $TypedArray(ns_entry_t,
-            {"near", "Num32__near", "func(x:Num32, y:Num32, ratio=1e-9f32, min_epsilon=1e-9f32)->Bool"},
-            {"format", "Num32__format", "func(n:Num32, precision=0)->Text"},
-            {"scientific", "Num32__scientific", "func(n:Num32, precision=0)->Text"},
-            {"nan", "Num32__nan", "func(tag=\"\")->Num32"},
-            {"isinf", "Num32__isinf", "func(n:Num32)->Bool"},
-            {"isfinite", "Num32__isfinite", "func(n:Num32)->Bool"},
-            {"isnan", "Num32__isnan", "func(n:Num32)->Bool"},
+        {"Num32", Type(NumType, .bits=32), "Num32_t", "$Num32", $TypedArray(ns_entry_t,
+            {"near", "Num32$near", "func(x:Num32, y:Num32, ratio=1e-9f32, min_epsilon=1e-9f32)->Bool"},
+            {"format", "Num32$format", "func(n:Num32, precision=0)->Text"},
+            {"scientific", "Num32$scientific", "func(n:Num32, precision=0)->Text"},
+            {"nan", "Num32$nan", "func(tag=\"\")->Num32"},
+            {"isinf", "Num32$isinf", "func(n:Num32)->Bool"},
+            {"isfinite", "Num32$isfinite", "func(n:Num32)->Bool"},
+            {"isnan", "Num32$isnan", "func(n:Num32)->Bool"},
             C(2_SQRTPI), C(E), C(PI_2), C(2_PI), C(1_PI), C(LN10), C(LN2), C(LOG2E),
             C(PI), C(PI_4), C(SQRT2), C(SQRT1_2),
             {"INF", "(Num32_t)(INFINITY)", "Num32"},
             {"TAU", "(Num32_t)(2.f*M_PI)", "Num32"},
-            {"random", "Num32__random", "func()->Num32"},
+            {"random", "Num32$random", "func()->Num32"},
             {"abs", "fabsf", "func(n:Num32)->Num32"},
             F(acos), F(acosh), F(asin), F(asinh), F(atan), F(atanh), F(cbrt), F(ceil), F(cos), F(cosh), F(erf), F(erfc),
             F(exp), F(exp2), F(expm1), F(floor), F(j0), F(j1), F(log), F(log10), F(log1p), F(log2), F(logb),
@@ -142,43 +142,44 @@ env_t *new_compilation_unit(void)
 #undef F2
 #undef F
 #undef C
-        {"Text", TEXT_TYPE, "Text_t", "Text", $TypedArray(ns_entry_t,
-            {"quoted", "Text__quoted", "func(text:Text, color=no)->Text"},
-            {"upper", "Text__upper", "func(text:Text)->Text"},
-            {"lower", "Text__lower", "func(text:Text)->Text"},
-            {"title", "Text__title", "func(text:Text)->Text"},
-            // {"has", "Text__has", "func(text:Text, target:Text, where=ANYWHERE)->Bool"},
-            // {"without", "Text__without", "func(text:Text, target:Text, where=ANYWHERE)->Text"},
-            // {"trimmed", "Text__without", "func(text:Text, skip:Text, where=ANYWHERE)->Text"},
-            {"title", "Text__title", "func(text:Text)->Text"},
-            // {"find", "Text__find", "func(text:Text, pattern:Text)->FindResult"},
-            {"replace", "Text__replace", "func(text:Text, pattern:Text, replacement:Text, limit=Int.max)->Text"},
-            {"split", "Text__split", "func(text:Text, split:Text)->[Text]"},
-            {"join", "Text__join", "func(glue:Text, pieces:[Text])->Text"},
-            {"clusters", "Text__clusters", "func(text:Text)->[Text]"},
-            {"codepoints", "Text__codepoints", "func(text:Text)->[Int32]"},
-            {"bytes", "Text__bytes", "func(text:Text)->[Int8]"},
-            {"num_clusters", "Text__num_clusters", "func(text:Text)->Int"},
-            {"num_codepoints", "Text__num_codepoints", "func(text:Text)->Int"},
-            {"num_bytes", "Text__num_bytes", "func(text:Text)->Int"},
-            {"character_names", "Text__character_names", "func(text:Text)->[Text]"},
+        {"Text", TEXT_TYPE, "Text_t", "$Text", $TypedArray(ns_entry_t,
+            {"quoted", "Text$quoted", "func(text:Text, color=no)->Text"},
+            {"upper", "Text$upper", "func(text:Text)->Text"},
+            {"lower", "Text$lower", "func(text:Text)->Text"},
+            {"title", "Text$title", "func(text:Text)->Text"},
+            // {"has", "Text$has", "func(text:Text, target:Text, where=ANYWHERE)->Bool"},
+            // {"without", "Text$without", "func(text:Text, target:Text, where=ANYWHERE)->Text"},
+            // {"trimmed", "Text$without", "func(text:Text, skip:Text, where=ANYWHERE)->Text"},
+            {"title", "Text$title", "func(text:Text)->Text"},
+            // {"find", "Text$find", "func(text:Text, pattern:Text)->FindResult"},
+            {"replace", "Text$replace", "func(text:Text, pattern:Text, replacement:Text, limit=Int.max)->Text"},
+            {"split", "Text$split", "func(text:Text, split:Text)->[Text]"},
+            {"join", "Text$join", "func(glue:Text, pieces:[Text])->Text"},
+            {"clusters", "Text$clusters", "func(text:Text)->[Text]"},
+            {"codepoints", "Text$codepoints", "func(text:Text)->[Int32]"},
+            {"bytes", "Text$bytes", "func(text:Text)->[Int8]"},
+            {"num_clusters", "Text$num_clusters", "func(text:Text)->Int"},
+            {"num_codepoints", "Text$num_codepoints", "func(text:Text)->Int"},
+            {"num_bytes", "Text$num_bytes", "func(text:Text)->Int"},
+            {"character_names", "Text$character_names", "func(text:Text)->[Text]"},
         )},
     };
 
     for (size_t i = 0; i < sizeof(global_types)/sizeof(global_types[0]); i++) {
         env_t *ns_env = global_types[i].type == TEXT_TYPE ? Match(TEXT_TYPE, TextType)->env : namespace_env(env, global_types[i].name);
         binding_t *binding = new(binding_t, .type=Type(TypeInfoType, .name=global_types[i].name, .type=global_types[i].type, .env=ns_env));
-        Table_str_set(env->globals, global_types[i].name, binding);
-        Table_str_set(env->types, global_types[i].name, global_types[i].type);
+        Table$str_set(env->globals, global_types[i].name, binding);
+        Table$str_set(env->types, global_types[i].name, global_types[i].type);
     }
 
     for (size_t i = 0; i < sizeof(global_types)/sizeof(global_types[0]); i++) {
-        binding_t *type_binding = Table_str_get(*env->globals, global_types[i].name);
+        binding_t *type_binding = Table$str_get(*env->globals, global_types[i].name);
         assert(type_binding);
         env_t *ns_env = Match(type_binding->type, TypeInfoType)->env;
         for (int64_t j = 0; j < global_types[i].namespace.length; j++) {
             ns_entry_t *entry = global_types[i].namespace.data + j*global_types[i].namespace.stride;
             type_t *type = parse_type_string(ns_env, entry->type_str);
+            if (!type) compiler_err(NULL, NULL, NULL, "Couldn't parse type string: %s", entry->type_str);
             if (type->tag == ClosureType) type = Match(type, ClosureType)->fn;
             binding_t *b = new(binding_t, .code=entry->code, .type=type);
             set_binding(ns_env, entry->name, b);
@@ -269,11 +270,11 @@ env_t *namespace_env(env_t *env, const char *namespace_name)
 
 binding_t *get_binding(env_t *env, const char *name)
 {
-    binding_t *b = Table_str_get(*env->locals, name);
+    binding_t *b = Table$str_get(*env->locals, name);
     if (!b && env->fn_ctx && env->fn_ctx->closure_scope) {
-        b = Table_str_get(*env->fn_ctx->closure_scope, name);
+        b = Table$str_get(*env->fn_ctx->closure_scope, name);
         if (b) {
-            Table_str_set(env->fn_ctx->closed_vars, name, b);
+            Table$str_set(env->fn_ctx->closed_vars, name, b);
             return new(binding_t, .type=b->type, .code=CORD_all("$userdata->", name));
         }
     }
@@ -324,7 +325,7 @@ binding_t *get_namespace_binding(env_t *env, ast_t *self, const char *name)
 void set_binding(env_t *env, const char *name, binding_t *binding)
 {
     if (name && binding)
-        Table_str_set(env->locals, name, binding);
+        Table$str_set(env->locals, name, binding);
 }
 
 void compiler_err(file_t *f, const char *start, const char *end, const char *fmt, ...)
diff --git a/environment.h b/environment.h
index b1b9124..fbff64b 100644
--- a/environment.h
+++ b/environment.h
@@ -42,8 +42,11 @@ typedef struct env_s {
 } env_t;
 
 typedef struct {
-    CORD code;
     type_t *type;
+    union {
+        CORD code;
+        char value[0];
+    };
 } binding_t;
 
 env_t *new_compilation_unit(void);
diff --git a/structs.c b/structs.c
index 51cc7c9..1a6259e 100644
--- a/structs.c
+++ b/structs.c
@@ -127,7 +127,7 @@ void compile_struct_def(env_t *env, ast_t *ast)
     // Typeinfo:
     CORD_appendf(&env->code->typedefs, "extern const TypeInfo %r;\n", full_name);
 
-    type_t *t = Table_str_get(*env->types, def->name);
+    type_t *t = Table$str_get(*env->types, def->name);
     assert(t && t->tag == StructType);
     auto struct_ = Match(t, StructType);
     CORD typeinfo = CORD_asprintf("public const TypeInfo %r = {%zu, %zu, {.tag=CustomInfo, .CustomInfo={",
@@ -140,11 +140,11 @@ void compile_struct_def(env_t *env, ast_t *ast)
         type_t *member_t = struct_->fields->type;
         switch (member_t->tag) {
         case TextType:
-            typeinfo = CORD_all(typeinfo, ".hash=(void*)", type_to_cord(member_t), "__hash", ", ");
+            typeinfo = CORD_all(typeinfo, ".hash=(void*)", type_to_cord(member_t), "$hash", ", ");
             // fallthrough
         case IntType: case NumType:
-            typeinfo = CORD_all(typeinfo, ".compare=(void*)", type_to_cord(member_t), "__compare, "
-                                ".equal=(void*)", type_to_cord(member_t), "__equal, ");
+            typeinfo = CORD_all(typeinfo, ".compare=(void*)", type_to_cord(member_t), "$compare, "
+                                ".equal=(void*)", type_to_cord(member_t), "$equal, ");
             // fallthrough
         case BoolType: goto got_methods;
         default: break;
diff --git a/tomo.c b/tomo.c
index 7ea07bd..8d95d45 100644
--- a/tomo.c
+++ b/tomo.c
@@ -123,12 +123,12 @@ static void build_file_dependency_graph(const char *filename, table_t *dependenc
     else
         errx(1, "I don't know how to find object files in: %s", filename);
 
-    if (Table_str_get(*dependencies, base_filename))
+    if (Table$str_get(*dependencies, base_filename))
         return;
 
     array_t *deps = new(array_t);
-    Array__insert(deps, &base_filename, 0, $ArrayInfo(&Text));
-    Table_str_set(dependencies, base_filename, deps);
+    Array$insert(deps, &base_filename, 0, $ArrayInfo(&$Text));
+    Table$str_set(dependencies, base_filename, deps);
 
     transpile(base_filename, false);
 
@@ -148,7 +148,7 @@ static void build_file_dependency_graph(const char *filename, table_t *dependenc
                 char *tmp = realpath(heap_strf("%s/%.*s", file_dir, strcspn(line + strlen(prefix), "\"") - 2, line + strlen(prefix)), NULL);
                 const char *resolved_file = heap_str(tmp);
                 free(tmp);
-                Array__insert(deps, &resolved_file, 0, $ArrayInfo(&Text));
+                Array$insert(deps, &resolved_file, 0, $ArrayInfo(&$Text));
                 build_file_dependency_graph(resolved_file, dependencies);
             }
         }
@@ -166,13 +166,13 @@ array_t get_file_dependencies(const char *filename)
 
     const TypeInfo unit = {.size=0, .align=0, .tag=CustomInfo};
     const TypeInfo info = {.size=sizeof(table_t), .align=__alignof__(table_t),
-        .tag=TableInfo, .TableInfo.key=&Text, .TableInfo.value=&unit};
+        .tag=TableInfo, .TableInfo.key=&$Text, .TableInfo.value=&unit};
 
-    for (int64_t i = 1; i <= Table_length(file_dependencies); i++) {
-        struct { const char *name; array_t *deps; } *entry = Table_entry(file_dependencies, i);
+    for (int64_t i = 1; i <= Table$length(file_dependencies); i++) {
+        struct { const char *name; array_t *deps; } *entry = Table$entry(file_dependencies, i);
         for (int64_t j = 0; j < entry->deps->length; j++) {
             const char *dep = *(char**)(entry->deps->data + j*entry->deps->stride);
-            Table_set(&dependency_set, &dep, &dep, &info);
+            Table$set(&dependency_set, &dep, &dep, &info);
         }
     }
     return dependency_set.entries;
diff --git a/typecheck.c b/typecheck.c
index 05a1fb5..6f92374 100644
--- a/typecheck.c
+++ b/typecheck.c
@@ -19,7 +19,7 @@ type_t *parse_type_ast(env_t *env, type_ast_t *ast)
     switch (ast->tag) {
     case VarTypeAST: {
         const char *name = Match(ast, VarTypeAST)->name;
-        type_t *t = Table_str_get(*env->types, name);
+        type_t *t = Table$str_get(*env->types, name);
         if (t) return t;
         code_err(ast, "I don't know a type with the name '%s'", name);
     }
@@ -120,7 +120,7 @@ void bind_statement(env_t *env, ast_t *statement)
 
         arg_t *fields = NULL;
         type_t *type = Type(StructType, .name=def->name, .fields=fields, .opaque=true, .env=ns_env); // placeholder
-        Table_str_set(env->types, def->name, type);
+        Table$str_set(env->types, def->name, type);
         for (arg_ast_t *field_ast = def->fields; field_ast; field_ast = field_ast->next) {
             type_t *field_t = get_arg_ast_type(env, field_ast);
             if ((field_t->tag == StructType && Match(field_t, StructType)->opaque)
@@ -133,7 +133,7 @@ void bind_statement(env_t *env, ast_t *statement)
         type->__data.StructType.opaque = false;
         
         type_t *typeinfo_type = Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env);
-        Table_str_set(env->globals, def->name, new(binding_t, .type=typeinfo_type, .code=CORD_all(env->file_prefix, def->name)));
+        Table$str_set(env->globals, def->name, new(binding_t, .type=typeinfo_type, .code=CORD_all(env->file_prefix, def->name)));
 
         for (ast_list_t *stmt = def->namespace ? Match(def->namespace, Block)->statements : NULL; stmt; stmt = stmt->next) {
             bind_statement(ns_env, stmt->ast);
@@ -147,7 +147,7 @@ void bind_statement(env_t *env, ast_t *statement)
 
         tag_t *tags = NULL;
         type_t *type = Type(EnumType, .name=def->name, .tags=tags, .opaque=true, .env=ns_env); // placeholder
-        Table_str_set(env->types, def->name, type);
+        Table$str_set(env->types, def->name, type);
         for (tag_ast_t *tag_ast = def->tags; tag_ast; tag_ast = tag_ast->next) {
             arg_t *fields = NULL;
             for (arg_ast_t *field_ast = tag_ast->fields; field_ast; field_ast = field_ast->next) {
@@ -173,11 +173,11 @@ void bind_statement(env_t *env, ast_t *statement)
             } else { // Empty singleton value:
                 set_binding(ns_env, tag->name, new(binding_t, .type=type, .code=CORD_all(env->file_prefix, def->name, "$tagged$", tag->name)));
             }
-            Table_str_set(env->types, heap_strf("%s$%s", def->name, tag->name), tag->type);
+            Table$str_set(env->types, heap_strf("%s$%s", def->name, tag->name), tag->type);
         }
         
         type_t *typeinfo_type = Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env);
-        Table_str_set(env->globals, def->name, new(binding_t, .type=typeinfo_type));
+        Table$str_set(env->globals, def->name, new(binding_t, .type=typeinfo_type));
 
         for (ast_list_t *stmt = def->namespace ? Match(def->namespace, Block)->statements : NULL; stmt; stmt = stmt->next) {
             bind_statement(ns_env, stmt->ast);
@@ -189,7 +189,7 @@ void bind_statement(env_t *env, ast_t *statement)
 
         env_t *ns_env = namespace_env(env, def->name);
         type_t *type = Type(TextType, .lang=def->name, .env=ns_env);
-        Table_str_set(env->types, def->name, type);
+        Table$str_set(env->types, def->name, type);
 
         set_binding(ns_env, "from_unsafe_text",
                     new(binding_t, .type=Type(FunctionType, .args=new(arg_t, .name="text", .type=TEXT_TYPE), .ret=type),
@@ -199,7 +199,7 @@ void bind_statement(env_t *env, ast_t *statement)
                         .code="(Text_t)"));
 
         type_t *typeinfo_type = Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env);
-        Table_str_set(env->globals, def->name, new(binding_t, .type=typeinfo_type));
+        Table$str_set(env->globals, def->name, new(binding_t, .type=typeinfo_type));
 
         for (ast_list_t *stmt = def->namespace ? Match(def->namespace, Block)->statements : NULL; stmt; stmt = stmt->next)
             bind_statement(ns_env, stmt->ast);
@@ -208,14 +208,14 @@ void bind_statement(env_t *env, ast_t *statement)
     case Use: {
         auto use = Match(statement, Use);
         const char *name = file_base_name(use->raw_path);
-        if (Table_str_get(*env->imports, name))
+        if (Table$str_get(*env->imports, name))
             break;
 
         env_t *module_env = new_compilation_unit();
         module_env->file_prefix = heap_strf("%s$", name);
-        Table_str_set(module_env->imports, name, module_env);
+        Table$str_set(module_env->imports, name, module_env);
         const char *my_name = heap_strn(CORD_to_const_char_star(env->file_prefix), CORD_len(env->file_prefix)-1);
-        Table_str_set(module_env->imports, my_name, env);
+        Table$str_set(module_env->imports, my_name, env);
 
         const char *resolved_path = resolve_path(use->raw_path, statement->file->filename, getenv("USE_PATH"));
         if (!resolved_path)
@@ -230,7 +230,7 @@ void bind_statement(env_t *env, ast_t *statement)
         for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
             bind_statement(module_env, stmt->ast);
         }
-        Table_str_set(env->imports, name, module_env);
+        Table$str_set(env->imports, name, module_env);
         break;
     }
     case Extern: {
@@ -432,7 +432,7 @@ type_t *get_type(env_t *env, ast_t *ast)
         type_t *fielded_t = get_type(env, access->fielded);
         if (fielded_t->tag == ModuleType) {
             const char *name = Match(fielded_t, ModuleType)->name;
-            env_t *module_env = Table_str_get(*env->imports, name);
+            env_t *module_env = Table$str_get(*env->imports, name);
             return get_type(module_env, WrapAST(ast, Var, access->field));
         } else if (fielded_t->tag == TypeInfoType) {
             auto info = Match(fielded_t, TypeInfoType);
diff --git a/typecheck.h b/typecheck.h
index 0468956..295ac60 100644
--- a/typecheck.h
+++ b/typecheck.h
@@ -8,6 +8,7 @@
 #include <string.h>
 
 #include "ast.h"
+#include "environment.h"
 #include "types.h"
 
 type_t *parse_type_ast(env_t *env, type_ast_t *ast);