Big refactorHEADmaster

1 files changed, 397 insertions, 399 deletions

diff --git a/src/library.c b/src/library.c
index 1038004..b6b8b42 100644
--- a/src/library.c
+++ b/src/library.c
@@ -6,17 +6,17 @@
 
 static pit_value impl_sf_quote(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_runtime_eval_program_push_literal(rt, rt->program, pit_car(rt, args));
+    pit_runtime_eval_program_push_literal(rt, rt->program, pit_value_cons_car(rt, args));
     return PIT_NIL;
 }
 static pit_value impl_sf_if(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value c = pit_car(rt, args);
+    pit_value c = pit_value_cons_car(rt, args);
     if (pit_eval(rt, c) != PIT_NIL) {
-        if (pit_vec_push(pit_value)(rt->expr_stack, pit_car(rt, pit_cdr(rt, args))) < 0)
+        if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons_car(rt, pit_value_cons_cdr(rt, args))) < 0)
             pit_error(rt, "in special form \"if\": evaluation stack overflow");
     } else {
-        if (pit_vec_push(pit_value)(rt->expr_stack, pit_car(rt, pit_cdr(rt, pit_cdr(rt, args)))) < 0)
+        if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons_car(rt, pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args)))) < 0)
             pit_error(rt, "in special form \"if\": evaluation stack overflow");
     }
     return PIT_NIL;
@@ -24,14 +24,14 @@ static pit_value impl_sf_if(pit_runtime *rt, pit_value args, void *data) {
 static pit_value impl_sf_cond(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     while (args != PIT_NIL) {
-        pit_value clause = pit_car(rt, args);
-        pit_value cond = pit_car(rt, clause);
+        pit_value clause = pit_value_cons_car(rt, args);
+        pit_value cond = pit_value_cons_car(rt, clause);
         if (pit_eval(rt, cond) != PIT_NIL) {
-            if (pit_vec_push(pit_value)(rt->expr_stack, pit_cons(rt, pit_intern_cstr(rt, "progn"), pit_cdr(rt, clause))) < 0)
+            if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, pit_symtab_intern_cstr(rt, "progn"), pit_value_cons_cdr(rt, clause))) < 0)
                 pit_error(rt, "in special form \"cond\": evaluation stack overflow");
             return PIT_NIL;
         }
-        args = pit_cdr(rt, args);
+        args = pit_value_cons_cdr(rt, args);
     }
     if (pit_vec_push(pit_value)(rt->expr_stack, PIT_NIL) < 0)
         pit_error(rt, "in special form \"cond\": evaluation stack overflow");
@@ -42,8 +42,8 @@ static pit_value impl_sf_progn(pit_runtime *rt, pit_value args, void *data) {
     pit_value bodyforms = args;
     pit_value final = PIT_NIL;
     while (bodyforms != PIT_NIL) {
-        final = pit_eval(rt, pit_car(rt, bodyforms));
-        bodyforms = pit_cdr(rt, bodyforms);
+        final = pit_eval(rt, pit_value_cons_car(rt, bodyforms));
+        bodyforms = pit_value_cons_cdr(rt, bodyforms);
     }
     pit_runtime_eval_program_push_literal(rt, rt->program, final);
     return PIT_NIL;
@@ -53,38 +53,38 @@ static pit_value impl_sf_or(pit_runtime *rt, pit_value args, void *data) {
     pit_value bodyforms = args;
     pit_value final = PIT_NIL;
     while (bodyforms != PIT_NIL) {
-        final = pit_eval(rt, pit_car(rt, bodyforms));
+        final = pit_eval(rt, pit_value_cons_car(rt, bodyforms));
         if (final != PIT_NIL) break;
-        bodyforms = pit_cdr(rt, bodyforms);
+        bodyforms = pit_value_cons_cdr(rt, bodyforms);
     }
     pit_runtime_eval_program_push_literal(rt, rt->program, final);
     return PIT_NIL;
 }
 static pit_value impl_sf_lambda(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value as = pit_car(rt, args);
-    pit_value body = pit_cdr(rt, args);
-    pit_runtime_eval_program_push_literal(rt, rt->program, pit_lambda(rt, as, body));
+    pit_value as = pit_value_cons_car(rt, args);
+    pit_value body = pit_value_cons_cdr(rt, args);
+    pit_runtime_eval_program_push_literal(rt, rt->program, pit_value_func_lambda(rt, as, body));
     return PIT_NIL;
 }
 static pit_value impl_m_defun(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value nm = pit_car(rt, args);
-    pit_value as = pit_car(rt, pit_cdr(rt, args));
-    pit_value body = pit_cdr(rt, pit_cdr(rt, args));
-    return pit_list(rt, 3,
-        pit_intern_cstr(rt, "fset!"),
-        pit_list(rt, 2, pit_intern_cstr(rt, "quote"), nm),
-        pit_cons(rt, pit_intern_cstr(rt, "lambda"), pit_cons(rt, as, body))
+    pit_value nm = pit_value_cons_car(rt, args);
+    pit_value as = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_value body = pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args));
+    return pit_value_list(rt, 3,
+        pit_symtab_intern_cstr(rt, "fset!"),
+        pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "quote"), nm),
+        pit_value_cons(rt, pit_symtab_intern_cstr(rt, "lambda"), pit_value_cons(rt, as, body))
     );
 }
 static pit_value impl_m_defmacro(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value nm = pit_car(rt, args);
-    return pit_list(rt, 3,
-        pit_intern_cstr(rt, "progn"),
-        pit_cons(rt, pit_intern_cstr(rt, "defun!"), args),
-        pit_list(rt, 2, pit_intern_cstr(rt, "set-symbol-macro!"), nm)
+    pit_value nm = pit_value_cons_car(rt, args);
+    return pit_value_list(rt, 3,
+        pit_symtab_intern_cstr(rt, "progn"),
+        pit_value_cons(rt, pit_symtab_intern_cstr(rt, "defun!"), args),
+        pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "set-symbol-macro!"), nm)
     );
 }
 static pit_value impl_m_defstruct(pit_runtime *rt, pit_value args, void *data) {
@@ -95,76 +95,76 @@ static pit_value impl_m_defstruct(pit_runtime *rt, pit_value args, void *data) {
     char nm_str[128];
     char field_str[128];
     char buf[512];
-    pit_value nm = pit_car(rt, args);
-    pit_value fields = pit_cdr(rt, args);
+    pit_value nm = pit_value_cons_car(rt, args);
+    pit_value fields = pit_value_cons_cdr(rt, args);
     i64 field_idx = 0;
-    i64 nm_len = pit_as_bytes(rt, pit_symbol_name(rt, nm), (u8 *) nm_str, sizeof(nm_str) - 1);
+    i64 nm_len = pit_value_bytes_copy(rt, pit_symtab_symbol_name(rt, nm), (u8 *) nm_str, sizeof(nm_str) - 1);
     if (nm_len < 0) return PIT_NIL;
     nm_str[nm_len] = 0;
     /* constructor */
     pit_libc_string_snprintf(buf, sizeof(buf), ":%s", nm_str);
-    aargs = pit_cons(rt, pit_intern_cstr(rt, buf), pit_cons(rt, pit_intern_cstr(rt, "array"), PIT_NIL));
-    fields = pit_cdr(rt, args);
+    aargs = pit_value_cons(rt, pit_symtab_intern_cstr(rt, buf), pit_value_cons(rt, pit_symtab_intern_cstr(rt, "array"), PIT_NIL));
+    fields = pit_value_cons_cdr(rt, args);
     while (fields != PIT_NIL) {
-        i64 field_len = pit_as_bytes(rt,
-            pit_symbol_name(rt, pit_car(rt, fields)),
+        i64 field_len = pit_value_bytes_copy(rt,
+            pit_symtab_symbol_name(rt, pit_value_cons_car(rt, fields)),
             (u8 *) field_str, sizeof(field_str) - 1
         );
         if (field_len < 0) return PIT_NIL;
         field_str[field_len] = 0;
         pit_libc_string_snprintf(buf, sizeof(buf), ":%s", field_str);
-        aargs = pit_cons(rt,
-            pit_list(rt, 3, pit_intern_cstr(rt, "plist/get"), pit_intern_cstr(rt, buf), pit_intern_cstr(rt, "kwargs")),
+        aargs = pit_value_cons(rt,
+            pit_value_list(rt, 3, pit_symtab_intern_cstr(rt, "plist/get"), pit_symtab_intern_cstr(rt, buf), pit_symtab_intern_cstr(rt, "kwargs")),
             aargs
         );
-        fields = pit_cdr(rt, fields);
+        fields = pit_value_cons_cdr(rt, fields);
     }
     pit_libc_string_snprintf(buf, sizeof(buf), "%s/new", nm_str);
-    df = pit_list(rt, 4,
-        pit_intern_cstr(rt, "defun!"),
-        pit_intern_cstr(rt, buf),
-        pit_list(rt, 2, pit_intern_cstr(rt, "&"), pit_intern_cstr(rt, "kwargs")),
-        pit_reverse(rt, aargs)
+    df = pit_value_list(rt, 4,
+        pit_symtab_intern_cstr(rt, "defun!"),
+        pit_symtab_intern_cstr(rt, buf),
+        pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "&"), pit_symtab_intern_cstr(rt, "kwargs")),
+        pit_value_list_reverse(rt, aargs)
     );
-    ret = pit_cons(rt, df, ret);
+    ret = pit_value_cons(rt, df, ret);
     /* getters and setters */
-    fields = pit_cdr(rt, args);
+    fields = pit_value_cons_cdr(rt, args);
     field_idx = 0;
     while (fields != PIT_NIL) {
-        i64 field_len = pit_as_bytes(rt,
-            pit_symbol_name(rt, pit_car(rt, fields)),
+        i64 field_len = pit_value_bytes_copy(rt,
+            pit_symtab_symbol_name(rt, pit_value_cons_car(rt, fields)),
             (u8 *) field_str, sizeof(field_str) - 1
         );
         if (field_len < 0) return PIT_NIL;
         field_str[field_len] = 0;
         /* getter */
         pit_libc_string_snprintf(buf, sizeof(buf), "%s/get-%s", nm_str, field_str);
-        df = pit_list(rt, 4,
-            pit_intern_cstr(rt, "defun!"),
-            pit_intern_cstr(rt, buf),
-            pit_list(rt, 1, pit_intern_cstr(rt, "v")),
-            pit_list(rt, 3,
-                pit_intern_cstr(rt, "array/get"),
-                pit_integer_new(rt, field_idx + 1),
-                pit_intern_cstr(rt, "v")
+        df = pit_value_list(rt, 4,
+            pit_symtab_intern_cstr(rt, "defun!"),
+            pit_symtab_intern_cstr(rt, buf),
+            pit_value_list(rt, 1, pit_symtab_intern_cstr(rt, "v")),
+            pit_value_list(rt, 3,
+                pit_symtab_intern_cstr(rt, "array/get"),
+                pit_value_integer_new(rt, field_idx + 1),
+                pit_symtab_intern_cstr(rt, "v")
             )
         );
-        ret = pit_cons(rt, df, ret);
+        ret = pit_value_cons(rt, df, ret);
         /* setter */
         pit_libc_string_snprintf(buf, sizeof(buf), "%s/set-%s!", nm_str, field_str);
-        df = pit_list(rt, 4,
-            pit_intern_cstr(rt, "defun!"),
-            pit_intern_cstr(rt, buf),
-            pit_list(rt, 2, pit_intern_cstr(rt, "v"), pit_intern_cstr(rt, "x")),
-            pit_list(rt, 4,
-                pit_intern_cstr(rt, "array/set!"),
-                pit_integer_new(rt, field_idx + 1),
-                pit_intern_cstr(rt, "x"),
-                pit_intern_cstr(rt, "v")
+        df = pit_value_list(rt, 4,
+            pit_symtab_intern_cstr(rt, "defun!"),
+            pit_symtab_intern_cstr(rt, buf),
+            pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "v"), pit_symtab_intern_cstr(rt, "x")),
+            pit_value_list(rt, 4,
+                pit_symtab_intern_cstr(rt, "array/set!"),
+                pit_value_integer_new(rt, field_idx + 1),
+                pit_symtab_intern_cstr(rt, "x"),
+                pit_symtab_intern_cstr(rt, "v")
             )
         );
-        ret = pit_cons(rt, df, ret);
-        fields = pit_cdr(rt, fields);
+        ret = pit_value_cons(rt, df, ret);
+        fields = pit_value_cons_cdr(rt, fields);
         field_idx += 1;
     }
     // (defstruct foo x y z)
@@ -172,48 +172,48 @@ static pit_value impl_m_defstruct(pit_runtime *rt, pit_value args, void *data) {
     // (defun foo/get-x (f) ...)
     // (defun foo/set-x! (f v) ...)
     // pit_trace(rt, ret);
-    return pit_cons(rt, pit_intern_cstr(rt, "progn"), ret);
+    return pit_value_cons(rt, pit_symtab_intern_cstr(rt, "progn"), ret);
 }
 static pit_value impl_m_let(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     pit_value lparams = PIT_NIL;
     pit_value largs = PIT_NIL;
-    pit_value binds = pit_car(rt, args);
-    pit_value bodyforms = pit_cdr(rt, args);
+    pit_value binds = pit_value_cons_car(rt, args);
+    pit_value bodyforms = pit_value_cons_cdr(rt, args);
     pit_value lambda, application;
     while (binds != PIT_NIL) {
-        pit_value bind = pit_car(rt, binds);
-        pit_value sym = pit_car(rt, bind);
-        pit_value expr = pit_car(rt, pit_cdr(rt, bind));
-        lparams = pit_cons(rt, sym, lparams);
-        largs = pit_cons(rt, expr, largs);
-        binds = pit_cdr(rt, binds);
-    }
-    lambda = pit_cons(rt, pit_intern_cstr(rt, "lambda"), pit_cons(rt, lparams, bodyforms));
-    application = pit_cons(rt, lambda, largs);
+        pit_value bind = pit_value_cons_car(rt, binds);
+        pit_value sym = pit_value_cons_car(rt, bind);
+        pit_value expr = pit_value_cons_car(rt, pit_value_cons_cdr(rt, bind));
+        lparams = pit_value_cons(rt, sym, lparams);
+        largs = pit_value_cons(rt, expr, largs);
+        binds = pit_value_cons_cdr(rt, binds);
+    }
+    lambda = pit_value_cons(rt, pit_symtab_intern_cstr(rt, "lambda"), pit_value_cons(rt, lparams, bodyforms));
+    application = pit_value_cons(rt, lambda, largs);
     return application;
 }
 static pit_value impl_m_and(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     pit_value ret = PIT_NIL;
-    args = pit_reverse(rt, args);
+    args = pit_value_list_reverse(rt, args);
     if (args != PIT_NIL) {
-        ret = pit_car(rt, args);
-        args = pit_cdr(rt, args);
+        ret = pit_value_cons_car(rt, args);
+        args = pit_value_cons_cdr(rt, args);
     }
     while (args != PIT_NIL) {
-        ret = pit_list(rt, 3, pit_intern_cstr(rt, "if"), pit_car(rt, args), ret, PIT_NIL);
-        args = pit_cdr(rt, args);
+        ret = pit_value_list(rt, 3, pit_symtab_intern_cstr(rt, "if"), pit_value_cons_car(rt, args), ret, PIT_NIL);
+        args = pit_value_cons_cdr(rt, args);
     }
     return ret;
 }
 static pit_value impl_m_setq(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value sym = pit_car(rt, args);
-    pit_value v = pit_car(rt, pit_cdr(rt, args));
-    return pit_list(rt, 3,
-        pit_intern_cstr(rt, "set!"),
-        pit_list(rt, 2, pit_intern_cstr(rt, "quote"), sym),
+    pit_value sym = pit_value_cons_car(rt, args);
+    pit_value v = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    return pit_value_list(rt, 3,
+        pit_symtab_intern_cstr(rt, "set!"),
+        pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "quote"), sym),
         v
     );
 }
@@ -222,139 +222,139 @@ static pit_value impl_m_setq(pit_runtime *rt, pit_value args, void *data) {
 // (cond ((eq x 'y) 'foo) ((eq x 'z) 'bar))
 static pit_value impl_m_case(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value x = pit_car(rt, args);
-    pit_value cases = pit_cdr(rt, args);
+    pit_value x = pit_value_cons_car(rt, args);
+    pit_value cases = pit_value_cons_cdr(rt, args);
     pit_value clauses = PIT_NIL;
-    pit_value xvar = pit_intern_cstr(rt, "(internal case)");
+    pit_value xvar = pit_symtab_intern_cstr(rt, "(internal case)");
     while (cases != PIT_NIL) {
-        pit_value c = pit_car(rt, cases);
-        clauses = pit_cons(rt,
-            pit_list(rt, 2,
-                pit_list(rt, 3, pit_intern_cstr(rt, "equal?"),
+        pit_value c = pit_value_cons_car(rt, cases);
+        clauses = pit_value_cons(rt,
+            pit_value_list(rt, 2,
+                pit_value_list(rt, 3, pit_symtab_intern_cstr(rt, "equal?"),
                     xvar,
-                    pit_list(rt, 2, pit_intern_cstr(rt, "quote"), pit_car(rt, c))
+                    pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "quote"), pit_value_cons_car(rt, c))
                 ),
-                pit_car(rt, pit_cdr(rt, c))
+                pit_value_cons_car(rt, pit_value_cons_cdr(rt, c))
             ),
             clauses
         );
-        cases = pit_cdr(rt, cases);
+        cases = pit_value_cons_cdr(rt, cases);
     }
-    return pit_list(rt, 3,
-        pit_intern_cstr(rt, "let"),
-        pit_list(rt, 1, pit_list(rt, 2, xvar, x)),
-        pit_cons(rt, pit_intern_cstr(rt, "cond"), pit_reverse(rt, clauses))
+    return pit_value_list(rt, 3,
+        pit_symtab_intern_cstr(rt, "let"),
+        pit_value_list(rt, 1, pit_value_list(rt, 2, xvar, x)),
+        pit_value_cons(rt, pit_symtab_intern_cstr(rt, "cond"), pit_value_list_reverse(rt, clauses))
     );
 }
 static pit_value impl_set(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value sym = pit_car(rt, args);
-    pit_value v = pit_car(rt, pit_cdr(rt, args));
-    pit_set(rt, sym, v);
+    pit_value sym = pit_value_cons_car(rt, args);
+    pit_value v = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_symtab_set(rt, sym, v);
     return v;
 }
 static pit_value impl_fset(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value sym = pit_car(rt, args);
-    pit_value v = pit_car(rt, pit_cdr(rt, args));
-    pit_fset(rt, sym, v);
+    pit_value sym = pit_value_cons_car(rt, args);
+    pit_value v = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_symtab_fset(rt, sym, v);
     return v;
 }
-static pit_value impl_symbol_is_macro(pit_runtime *rt, pit_value args, void *data) {
+static pit_value impl_symbol_mark_macro(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value sym = pit_car(rt, args);
-    pit_symbol_is_macro(rt, sym);
+    pit_value sym = pit_value_cons_car(rt, args);
+    pit_symtab_symbol_mark_macro(rt, sym);
     return PIT_NIL;
 }
 static pit_value impl_funcall(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value f = pit_car(rt, args);
-    return pit_apply(rt, f, pit_cdr(rt, args));
+    pit_value f = pit_value_cons_car(rt, args);
+    return pit_value_apply(rt, f, pit_value_cons_cdr(rt, args));
 }
 static pit_value impl_apply(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value f = pit_car(rt, args);
-    pit_value xs = pit_car(rt, pit_cdr(rt, args));
-    return pit_apply(rt, f, xs);
+    pit_value f = pit_value_cons_car(rt, args);
+    pit_value xs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    return pit_value_apply(rt, f, xs);
 }
 static pit_value impl_error(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     rt->error = PIT_T;
-    rt->error = pit_car(rt, args);
+    rt->error = pit_value_cons_car(rt, args);
     rt->error_line = rt->source_line;
     rt->error_column = rt->source_column;
     return PIT_NIL;
 }
 static pit_value impl_eval(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_eval(rt, pit_car(rt, args));
+    return pit_eval(rt, pit_value_cons_car(rt, args));
 }
 static pit_value impl_eq_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value x = pit_car(rt, args);
-    pit_value y = pit_car(rt, pit_cdr(rt, args));
-    return pit_bool_new(rt, pit_eq(x, y));
+    pit_value x = pit_value_cons_car(rt, args);
+    pit_value y = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    return pit_value_bool_new(rt, pit_value_eq(x, y));
 }
 static pit_value impl_equal_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value x = pit_car(rt, args);
-    pit_value y = pit_car(rt, pit_cdr(rt, args));
-    return pit_bool_new(rt, pit_equal(rt, x, y));
+    pit_value x = pit_value_cons_car(rt, args);
+    pit_value y = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    return pit_value_bool_new(rt, pit_value_equal(rt, x, y));
 }
 static pit_value impl_integer_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_bool_new(rt, pit_is_integer(rt, pit_car(rt, args)));
+    return pit_value_bool_new(rt, pit_value_is_integer(rt, pit_value_cons_car(rt, args)));
 }
 static pit_value impl_double_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_bool_new(rt, pit_is_double(rt, pit_car(rt, args)));
+    return pit_value_bool_new(rt, pit_value_is_double(rt, pit_value_cons_car(rt, args)));
 }
 static pit_value impl_symbol_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_bool_new(rt, pit_is_symbol(rt, pit_car(rt, args)));
+    return pit_value_bool_new(rt, pit_value_is_symbol(rt, pit_value_cons_car(rt, args)));
 }
 static pit_value impl_cons_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_bool_new(rt, pit_is_cons(rt, pit_car(rt, args)));
+    return pit_value_bool_new(rt, pit_value_is_cons(rt, pit_value_cons_car(rt, args)));
 }
 static pit_value impl_array_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_bool_new(rt, pit_is_array(rt, pit_car(rt, args)));
+    return pit_value_bool_new(rt, pit_value_is_array(rt, pit_value_cons_car(rt, args)));
 }
 static pit_value impl_bytes_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_bool_new(rt, pit_is_bytes(rt, pit_car(rt, args)));
+    return pit_value_bool_new(rt, pit_value_is_bytes(rt, pit_value_cons_car(rt, args)));
 }
 static pit_value impl_function_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value a = pit_car(rt, args);
-    bool b = (pit_is_symbol(rt, a) && pit_fget(rt, a) != PIT_NIL)
-        || pit_is_func(rt, a)
-        || pit_is_nativefunc(rt, a);
-    return pit_bool_new(rt, b);
+    pit_value a = pit_value_cons_car(rt, args);
+    bool b = (pit_value_is_symbol(rt, a) && pit_symtab_fget(rt, a) != PIT_NIL)
+        || pit_value_is_func(rt, a)
+        || pit_value_is_nativefunc(rt, a);
+    return pit_value_bool_new(rt, b);
 }
 static pit_value impl_cons(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_cons(rt, pit_car(rt, args), pit_car(rt, pit_cdr(rt, args)));
+    return pit_value_cons(rt, pit_value_cons_car(rt, args), pit_value_cons_car(rt, pit_value_cons_cdr(rt, args)));
 }
 static pit_value impl_car(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_car(rt, pit_car(rt, args));
+    return pit_value_cons_car(rt, pit_value_cons_car(rt, args));
 }
 static pit_value impl_cdr(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_cdr(rt, pit_car(rt, args));
+    return pit_value_cons_cdr(rt, pit_value_cons_car(rt, args));
 }
 static pit_value impl_setcar(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value v = pit_car(rt, pit_cdr(rt, args));
-    pit_setcar(rt, pit_car(rt, args), v);
+    pit_value v = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_value_cons_setcar(rt, pit_value_cons_car(rt, args), v);
     return v;
 }
 static pit_value impl_setcdr(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value v = pit_car(rt, pit_cdr(rt, args));
-    pit_setcdr(rt, pit_car(rt, args), v);
+    pit_value v = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_value_cons_setcdr(rt, pit_value_cons_car(rt, args), v);
     return v;
 }
 static pit_value impl_list(pit_runtime *rt, pit_value args, void *data) {
@@ -364,195 +364,195 @@ static pit_value impl_list(pit_runtime *rt, pit_value args, void *data) {
 }
 static pit_value impl_list_nth(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 n = pit_as_integer(rt, pit_car(rt, args));
-    pit_value xs = pit_car(rt, pit_cdr(rt, args));
+    i64 n = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    pit_value xs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     while (xs != PIT_NIL && n-- > 0) {
-        xs = pit_cdr(rt, xs);
+        xs = pit_value_cons_cdr(rt, xs);
     }
-    return pit_car(rt, xs);
+    return pit_value_cons_car(rt, xs);
 }
 static pit_value impl_list_iota(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 n = pit_as_integer(rt, pit_car(rt, args));
+    i64 n = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
     pit_value ret = PIT_NIL;
     while (n > 0) {
-        ret = pit_cons(rt, pit_integer_new(rt, --n), ret);
+        ret = pit_value_cons(rt, pit_value_integer_new(rt, --n), ret);
     }
     return ret;
 }
 static pit_value impl_list_len(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value arr = pit_car(rt, args);
-    return pit_integer_new(rt, pit_list_len(rt, arr));
+    pit_value arr = pit_value_cons_car(rt, args);
+    return pit_value_integer_new(rt, pit_value_list_len(rt, arr));
 }
 static pit_value impl_list_reverse(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return pit_reverse(rt, pit_car(rt, args));
+    return pit_value_list_reverse(rt, pit_value_cons_car(rt, args));
 }
 static pit_value impl_list_uniq(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value xs = pit_car(rt, args);
+    pit_value xs = pit_value_cons_car(rt, args);
     pit_value ret = PIT_NIL;
     while (xs != PIT_NIL) {
-        pit_value x = pit_car(rt, xs);
-        if (pit_contains_equal(rt, x, ret) == PIT_NIL) {
-            ret = pit_cons(rt, x, ret);
+        pit_value x = pit_value_cons_car(rt, xs);
+        if (pit_value_list_contains_equal(rt, x, ret) == PIT_NIL) {
+            ret = pit_value_cons(rt, x, ret);
         }
-        xs = pit_cdr(rt, xs);
+        xs = pit_value_cons_cdr(rt, xs);
     }
-    return pit_reverse(rt, ret);
+    return pit_value_list_reverse(rt, ret);
 }
 static pit_value impl_list_append(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    args = pit_reverse(rt, args);
-    pit_value ret = pit_car(rt, args);
-    pit_value ls = pit_cdr(rt, args);
+    args = pit_value_list_reverse(rt, args);
+    pit_value ret = pit_value_cons_car(rt, args);
+    pit_value ls = pit_value_cons_cdr(rt, args);
     while (ls != PIT_NIL) {
-        pit_value xs = pit_reverse(rt, pit_car(rt, ls));
+        pit_value xs = pit_value_list_reverse(rt, pit_value_cons_car(rt, ls));
         while (xs != PIT_NIL) {
-            ret = pit_cons(rt, pit_car(rt, xs), ret);
-            xs = pit_cdr(rt, xs);
+            ret = pit_value_cons(rt, pit_value_cons_car(rt, xs), ret);
+            xs = pit_value_cons_cdr(rt, xs);
         }
-        ls = pit_cdr(rt, ls);
+        ls = pit_value_cons_cdr(rt, ls);
     }
     return ret;
 }
 static pit_value impl_list_concat(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    return impl_list_append(rt, pit_car(rt, args), NULL);
+    return impl_list_append(rt, pit_value_cons_car(rt, args), NULL);
 }
 static pit_value impl_list_take(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 num = pit_as_integer(rt, pit_car(rt, args));
-    pit_value arr = pit_car(rt, pit_cdr(rt, args));
+    i64 num = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    pit_value arr = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     pit_value ret = PIT_NIL;
     while (num > 0 && arr != PIT_NIL) {
-        ret = pit_cons(rt, pit_car(rt, arr), ret);
-        arr = pit_cdr(rt, arr);
+        ret = pit_value_cons(rt, pit_value_cons_car(rt, arr), ret);
+        arr = pit_value_cons_cdr(rt, arr);
         num -= 1;
     }
-    return pit_reverse(rt, ret);
+    return pit_value_list_reverse(rt, ret);
 }
 static pit_value impl_list_drop(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 num = pit_as_integer(rt, pit_car(rt, args));
-    pit_value arr = pit_car(rt, pit_cdr(rt, args));
+    i64 num = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    pit_value arr = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     while (num > 0 && arr != PIT_NIL) {
-        arr = pit_cdr(rt, arr);
+        arr = pit_value_cons_cdr(rt, arr);
         num -= 1;
     }
     return arr;
 }
 static pit_value impl_list_map(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value func = pit_car(rt, args);
-    pit_value xs = pit_car(rt, pit_cdr(rt, args));
+    pit_value func = pit_value_cons_car(rt, args);
+    pit_value xs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     pit_value ret = PIT_NIL;
     while (xs != PIT_NIL) {
-        pit_value y = pit_apply(rt, func, pit_cons(rt, pit_car(rt, xs), PIT_NIL));
-        ret = pit_cons(rt, y, ret);
-        xs = pit_cdr(rt, xs);
+        pit_value y = pit_value_apply(rt, func, pit_value_cons(rt, pit_value_cons_car(rt, xs), PIT_NIL));
+        ret = pit_value_cons(rt, y, ret);
+        xs = pit_value_cons_cdr(rt, xs);
     }
-    return pit_reverse(rt, ret);
+    return pit_value_list_reverse(rt, ret);
 }
 static pit_value impl_list_foldl(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value func = pit_car(rt, args);
-    pit_value acc = pit_car(rt, pit_cdr(rt, args));
-    pit_value xs = pit_car(rt, pit_cdr(rt, pit_cdr(rt, args)));
+    pit_value func = pit_value_cons_car(rt, args);
+    pit_value acc = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_value xs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args)));
     while (xs != PIT_NIL) {
-        acc = pit_apply(rt, func, pit_list(rt, 2, pit_car(rt, xs), acc));
-        xs = pit_cdr(rt, xs);
+        acc = pit_value_apply(rt, func, pit_value_list(rt, 2, pit_value_cons_car(rt, xs), acc));
+        xs = pit_value_cons_cdr(rt, xs);
     }
     return acc;
 }
 static pit_value impl_list_filter(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value func = pit_car(rt, args);
-    pit_value xs = pit_car(rt, pit_cdr(rt, args));
+    pit_value func = pit_value_cons_car(rt, args);
+    pit_value xs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     pit_value ret = PIT_NIL;
     while (xs != PIT_NIL) {
-        pit_value x = pit_car(rt, xs);
-        pit_value y = pit_apply(rt, func, pit_cons(rt, x, PIT_NIL));
+        pit_value x = pit_value_cons_car(rt, xs);
+        pit_value y = pit_value_apply(rt, func, pit_value_cons(rt, x, PIT_NIL));
         if (y != PIT_NIL) {
-            ret = pit_cons(rt, x, ret);
+            ret = pit_value_cons(rt, x, ret);
         }
-        xs = pit_cdr(rt, xs);
+        xs = pit_value_cons_cdr(rt, xs);
     }
-    return pit_reverse(rt, ret);
+    return pit_value_list_reverse(rt, ret);
 }
 static pit_value impl_list_find(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value func = pit_car(rt, args);
-    pit_value xs = pit_car(rt, pit_cdr(rt, args));
+    pit_value func = pit_value_cons_car(rt, args);
+    pit_value xs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     while (xs != PIT_NIL) {
-        pit_value x = pit_car(rt, xs);
-        pit_value y = pit_apply(rt, func, pit_cons(rt, x, PIT_NIL));
+        pit_value x = pit_value_cons_car(rt, xs);
+        pit_value y = pit_value_apply(rt, func, pit_value_cons(rt, x, PIT_NIL));
         if (y != PIT_NIL) {
             return x;
         }
-        xs = pit_cdr(rt, xs);
+        xs = pit_value_cons_cdr(rt, xs);
     }
     return PIT_NIL;
 }
 static pit_value impl_list_contains_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value needle = pit_car(rt, args);
-    pit_value haystack = pit_car(rt, pit_cdr(rt, args));
+    pit_value needle = pit_value_cons_car(rt, args);
+    pit_value haystack = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     while (haystack != PIT_NIL) {
-        if (pit_equal(rt, needle, pit_car(rt, haystack))) return PIT_T;
-        haystack = pit_cdr(rt, haystack);
+        if (pit_value_equal(rt, needle, pit_value_cons_car(rt, haystack))) return PIT_T;
+        haystack = pit_value_cons_cdr(rt, haystack);
     }
     return PIT_NIL;
 }
 static pit_value impl_list_all_p(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value f = pit_car(rt, args);
-    pit_value xs = pit_car(rt, pit_cdr(rt, args));
+    pit_value f = pit_value_cons_car(rt, args);
+    pit_value xs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     while (xs != PIT_NIL) {
-        pit_value x = pit_car(rt, xs);
-        if (pit_apply(rt, f, pit_cons(rt, x, PIT_NIL)) == PIT_NIL) {
+        pit_value x = pit_value_cons_car(rt, xs);
+        if (pit_value_apply(rt, f, pit_value_cons(rt, x, PIT_NIL)) == PIT_NIL) {
             return PIT_NIL;
         }
-        xs = pit_cdr(rt, xs);
+        xs = pit_value_cons_cdr(rt, xs);
     }
     return PIT_T;
 }
 static pit_value impl_list_zip_with(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value f = pit_car(rt, args);
-    pit_value xs = pit_car(rt, pit_cdr(rt, args));
-    pit_value ys = pit_car(rt, pit_cdr(rt, pit_cdr(rt, args)));
+    pit_value f = pit_value_cons_car(rt, args);
+    pit_value xs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_value ys = pit_value_cons_car(rt, pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args)));
     pit_value ret = PIT_NIL;
     while (xs != PIT_NIL && ys != PIT_NIL) {
-        pit_value z = pit_apply(rt, f, pit_list(rt, 2, pit_car(rt, xs), pit_car(rt, ys)));
-        ret = pit_cons(rt, z, ret);
-        xs = pit_cdr(rt, xs); ys = pit_cdr(rt, ys);
+        pit_value z = pit_value_apply(rt, f, pit_value_list(rt, 2, pit_value_cons_car(rt, xs), pit_value_cons_car(rt, ys)));
+        ret = pit_value_cons(rt, z, ret);
+        xs = pit_value_cons_cdr(rt, xs); ys = pit_value_cons_cdr(rt, ys);
     }
-    return pit_reverse(rt, ret);
+    return pit_value_list_reverse(rt, ret);
 }
 static pit_value impl_bytes_len(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value v = pit_car(rt, args);
+    pit_value v = pit_value_cons_car(rt, args);
     if (pit_value_sort(v) != PIT_VALUE_SORT_REF) {
         pit_error(rt, "value is not a ref");
         return PIT_NIL;
     }
-    pit_value_heavy *h = pit_deref(rt, pit_as_ref(rt, v));
+    pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, v));
     if (!h) { pit_error(rt, "bad ref"); return PIT_NIL; }
     if (h->hsort != PIT_VALUE_HEAVY_SORT_BYTES) { pit_error(rt, "ref is not bytes"); return PIT_NIL; }
-    return pit_integer_new(rt, h->in.bytes.len);
+    return pit_value_integer_new(rt, h->in.bytes.len);
 }
 static pit_value impl_bytes_range(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 start = pit_as_integer(rt, pit_car(rt, args));
-    i64 end = pit_as_integer(rt, pit_car(rt, pit_cdr(rt, args)));
-    pit_value v = pit_car(rt, pit_cdr(rt, pit_cdr(rt, args)));
+    i64 start = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    i64 end = pit_value_as_integer(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, args)));
+    pit_value v = pit_value_cons_car(rt, pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args)));
     if (pit_value_sort(v) != PIT_VALUE_SORT_REF) {
         pit_error(rt, "value is not a ref");
         return PIT_NIL;
     }
-    pit_value_heavy *h = pit_deref(rt, pit_as_ref(rt, v));
+    pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, v));
     if (!h) { pit_error(rt, "bad ref"); return PIT_NIL; }
     if (h->hsort != PIT_VALUE_HEAVY_SORT_BYTES) { pit_error(rt, "ref is not bytes"); return PIT_NIL; }
     if (start < 0 || start >= h->in.bytes.len) {
@@ -563,43 +563,41 @@ static pit_value impl_bytes_range(pit_runtime *rt, pit_value args, void *data) {
         pit_error(rt, "bytes range end index out of bounds: %d", end);
         return PIT_NIL;
     }
-    return pit_bytes_new(rt, h->in.bytes.data + start, end - start);
+    return pit_value_bytes_new(rt, h->in.bytes.data + start, end - start);
 }
 static pit_value impl_array(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 scratch_reset = rt->scratch->next;
-    i64 len = 0;
+    i64 len = pit_value_list_len(rt, args);
+    pit_value ret = pit_value_array_new(rt, len);
+    i64 idx = 0;
     while (args != PIT_NIL) {
-        pit_value *cell = pit_arena_alloc_array(rt->scratch, sizeof(pit_value));
-        *cell = pit_car(rt, args);
-        len += 1;
-        args = pit_cdr(rt, args);
+        pit_value_array_set(rt, ret, idx++, pit_value_cons_car(rt, args));
+        args = pit_value_cons_cdr(rt, args);
     }
-    rt->scratch->next = scratch_reset;
-    return pit_array_from_buf(rt, pit_arena_get(rt->scratch, (i32) scratch_reset), len);
+    return ret;
 }
 static pit_value impl_array_to_list(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value arr = pit_car(rt, args);
-    i64 ilen = pit_array_len(rt, arr);
+    pit_value arr = pit_value_cons_car(rt, args);
+    i64 ilen = pit_value_array_len(rt, arr);
     pit_value ret = PIT_NIL;
     i64 i = 0;
     for (; i < ilen; ++i) {
-        ret = pit_cons(rt, pit_array_get(rt, arr, i), ret);
+        ret = pit_value_cons(rt, pit_value_array_get(rt, arr, i), ret);
     }
-    return pit_reverse(rt, ret);
+    return pit_value_list_reverse(rt, ret);
 }
 static pit_value impl_array_from_list(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     i64 i = 0;
-    pit_value xs = pit_car(rt, args);
-    i64 ilen = pit_list_len(rt, xs);
-    pit_value ret = pit_array_new(rt, ilen);
-    pit_value_heavy *h = pit_deref(rt, pit_as_ref(rt, ret));
+    pit_value xs = pit_value_cons_car(rt, args);
+    i64 ilen = pit_value_list_len(rt, xs);
+    pit_value ret = pit_value_array_new(rt, ilen);
+    pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, ret));
     if (!h) { pit_error(rt, "failed to deref heavy value for array"); return PIT_NIL; }
     while (xs != PIT_NIL) {
-        h->in.array.data[i] = pit_car(rt, xs);
-        xs = pit_cdr(rt, xs);
+        h->in.array.data[i] = pit_value_cons_car(rt, xs);
+        xs = pit_value_cons_cdr(rt, xs);
         i += 1;
     }
     return ret;
@@ -607,11 +605,11 @@ static pit_value impl_array_from_list(pit_runtime *rt, pit_value args, void *dat
 static pit_value impl_array_repeat(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     i64 i = 0;
-    pit_value v = pit_car(rt, args);
-    pit_value len = pit_car(rt, pit_cdr(rt, args));
-    i64 ilen = pit_as_integer(rt, len);
-    pit_value ret = pit_array_new(rt, ilen);
-    pit_value_heavy *h = pit_deref(rt, pit_as_ref(rt, ret));
+    pit_value v = pit_value_cons_car(rt, args);
+    pit_value len = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    i64 ilen = pit_value_as_integer(rt, len);
+    pit_value ret = pit_value_array_new(rt, ilen);
+    pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, ret));
     if (!h) { pit_error(rt, "failed to deref heavy value for array"); return PIT_NIL; }
     for (; i < ilen; ++i) {
         h->in.array.data[i] = v;
@@ -620,98 +618,98 @@ static pit_value impl_array_repeat(pit_runtime *rt, pit_value args, void *data)
 }
 static pit_value impl_array_len(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value arr = pit_car(rt, args);
-    return pit_integer_new(rt, pit_array_len(rt, arr));
+    pit_value arr = pit_value_cons_car(rt, args);
+    return pit_value_integer_new(rt, pit_value_array_len(rt, arr));
 }
 static pit_value impl_array_get(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value idx = pit_car(rt, args);
-    pit_value arr = pit_car(rt, pit_cdr(rt, args));
-    return pit_array_get(rt, arr, pit_as_integer(rt, idx));
+    pit_value idx = pit_value_cons_car(rt, args);
+    pit_value arr = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    return pit_value_array_get(rt, arr, pit_value_as_integer(rt, idx));
 }
 static pit_value impl_array_set(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value idx = pit_car(rt, args);
-    pit_value v = pit_car(rt, pit_cdr(rt, args));
-    pit_value arr = pit_car(rt, pit_cdr(rt, pit_cdr(rt, args)));
-    return pit_array_set(rt, arr, pit_as_integer(rt, idx), v);
+    pit_value idx = pit_value_cons_car(rt, args);
+    pit_value v = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_value arr = pit_value_cons_car(rt, pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args)));
+    return pit_value_array_set(rt, arr, pit_value_as_integer(rt, idx), v);
 }
 static pit_value impl_array_map(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value func = pit_car(rt, args);
-    pit_value arr = pit_car(rt, pit_cdr(rt, args));
-    i64 len = pit_array_len(rt, arr);
-    pit_value ret = pit_array_new(rt, len);
+    pit_value func = pit_value_cons_car(rt, args);
+    pit_value arr = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    i64 len = pit_value_array_len(rt, arr);
+    pit_value ret = pit_value_array_new(rt, len);
     i64 i = 0;
     for (i = 0; i < len; ++i) {
-        pit_value y = pit_apply(rt, func, pit_cons(rt, pit_array_get(rt, arr, i), PIT_NIL));
-        pit_array_set(rt, ret, i, y);
+        pit_value y = pit_value_apply(rt, func, pit_value_cons(rt, pit_value_array_get(rt, arr, i), PIT_NIL));
+        pit_value_array_set(rt, ret, i, y);
     }
     return ret;
 }
 static pit_value impl_array_map_mut(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value func = pit_car(rt, args);
-    pit_value arr = pit_car(rt, pit_cdr(rt, args));
-    i64 len = pit_array_len(rt, arr);
+    pit_value func = pit_value_cons_car(rt, args);
+    pit_value arr = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    i64 len = pit_value_array_len(rt, arr);
     i64 i = 0;
     for (i = 0; i < len; ++i) {
-        pit_value y = pit_apply(rt, func, pit_cons(rt, pit_array_get(rt, arr, i), PIT_NIL));
-        pit_array_set(rt, arr, i, y);
+        pit_value y = pit_value_apply(rt, func, pit_value_cons(rt, pit_value_array_get(rt, arr, i), PIT_NIL));
+        pit_value_array_set(rt, arr, i, y);
     }
     return arr;
 }
 static pit_value impl_abs(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 x = pit_as_integer(rt, pit_car(rt, args));
-    if (x < 0) return pit_integer_new(rt, -x);
-    return pit_integer_new(rt, x);
+    i64 x = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    if (x < 0) return pit_value_integer_new(rt, -x);
+    return pit_value_integer_new(rt, x);
 }
 static pit_value impl_add(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     i64 total = 0;
     while (args != PIT_NIL) {
-        total += pit_as_integer(rt, pit_car(rt, args));
-        args = pit_cdr(rt, args);
+        total += pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+        args = pit_value_cons_cdr(rt, args);
     }
-    return pit_integer_new(rt, total);
+    return pit_value_integer_new(rt, total);
 }
 static pit_value impl_sub(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     i64 total = 0;
     while (args != PIT_NIL) {
-        total -= pit_as_integer(rt, pit_car(rt, args));
-        args = pit_cdr(rt, args);
+        total -= pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+        args = pit_value_cons_cdr(rt, args);
     }
-    return pit_integer_new(rt, total);
+    return pit_value_integer_new(rt, total);
 }
 static pit_value impl_mul(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     i64 total = 1;
     while (args != PIT_NIL) {
-        total *= pit_as_integer(rt, pit_car(rt, args));
-        args = pit_cdr(rt, args);
+        total *= pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+        args = pit_value_cons_cdr(rt, args);
     }
-    return pit_integer_new(rt, total);
+    return pit_value_integer_new(rt, total);
 }
 static pit_value impl_div(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 total = pit_as_integer(rt, pit_car(rt, args));
-    args = pit_cdr(rt, args);
+    i64 total = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    args = pit_value_cons_cdr(rt, args);
     while (args != PIT_NIL) {
-        i64 denom = pit_as_integer(rt, pit_car(rt, args));
+        i64 denom = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
         if (denom == 0) {
             pit_error(rt, "divide by zero");
             return PIT_NIL;
         }
         total /= denom;
-        args = pit_cdr(rt, args);
+        args = pit_value_cons_cdr(rt, args);
     }
-    return pit_integer_new(rt, total);
+    return pit_value_integer_new(rt, total);
 }
 static pit_value impl_not(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    if (pit_car(rt, args) == PIT_NIL) {
+    if (pit_value_cons_car(rt, args) == PIT_NIL) {
         return PIT_T;
     } else {
         return PIT_NIL;
@@ -719,194 +717,194 @@ static pit_value impl_not(pit_runtime *rt, pit_value args, void *data) {
 }
 static pit_value impl_lt(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 x = pit_as_integer(rt, pit_car(rt, args));
-    i64 y = pit_as_integer(rt, pit_car(rt, pit_cdr(rt, args)));
-    return pit_bool_new(rt, x < y);
+    i64 x = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    i64 y = pit_value_as_integer(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, args)));
+    return pit_value_bool_new(rt, x < y);
 }
 static pit_value impl_gt(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 x = pit_as_integer(rt, pit_car(rt, args));
-    i64 y = pit_as_integer(rt, pit_car(rt, pit_cdr(rt, args)));
-    return pit_bool_new(rt, x > y);
+    i64 x = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    i64 y = pit_value_as_integer(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, args)));
+    return pit_value_bool_new(rt, x > y);
 }
 static pit_value impl_le(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 x = pit_as_integer(rt, pit_car(rt, args));
-    i64 y = pit_as_integer(rt, pit_car(rt, pit_cdr(rt, args)));
-    return pit_bool_new(rt, x <= y);
+    i64 x = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    i64 y = pit_value_as_integer(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, args)));
+    return pit_value_bool_new(rt, x <= y);
 }
 static pit_value impl_ge(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 x = pit_as_integer(rt, pit_car(rt, args));
-    i64 y = pit_as_integer(rt, pit_car(rt, pit_cdr(rt, args)));
-    return pit_bool_new(rt, x >= y);
+    i64 x = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    i64 y = pit_value_as_integer(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, args)));
+    return pit_value_bool_new(rt, x >= y);
 }
 static pit_value impl_bitwise_and(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     i64 total = -1;
     while (args != PIT_NIL) {
-        total &= pit_as_integer(rt, pit_car(rt, args));
-        args = pit_cdr(rt, args);
+        total &= pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+        args = pit_value_cons_cdr(rt, args);
     }
-    return pit_integer_new(rt, total);
+    return pit_value_integer_new(rt, total);
 }
 static pit_value impl_bitwise_or(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     i64 total = 0;
     while (args != PIT_NIL) {
-        total |= pit_as_integer(rt, pit_car(rt, args));
-        args = pit_cdr(rt, args);
+        total |= pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+        args = pit_value_cons_cdr(rt, args);
     }
-    return pit_integer_new(rt, total);
+    return pit_value_integer_new(rt, total);
 }
 static pit_value impl_bitwise_xor(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
     i64 total = 0;
     while (args != PIT_NIL) {
-        total ^= pit_as_integer(rt, pit_car(rt, args));
-        args = pit_cdr(rt, args);
+        total ^= pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+        args = pit_value_cons_cdr(rt, args);
     }
-    return pit_integer_new(rt, total);
+    return pit_value_integer_new(rt, total);
 }
 static pit_value impl_bitwise_not(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 x = pit_as_integer(rt, pit_car(rt, args));
-    return pit_integer_new(rt, ~x);
+    i64 x = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    return pit_value_integer_new(rt, ~x);
 }
 static pit_value impl_bitwise_lshift(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 val = pit_as_integer(rt, pit_car(rt, args));
-    i64 shift = pit_as_integer(rt, pit_car(rt, pit_cdr(rt, args)));
-    return pit_integer_new(rt, val << shift);
+    i64 val = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    i64 shift = pit_value_as_integer(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, args)));
+    return pit_value_integer_new(rt, val << shift);
 }
 static pit_value impl_bitwise_rshift(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    i64 val = pit_as_integer(rt, pit_car(rt, args));
-    i64 shift = pit_as_integer(rt, pit_car(rt, pit_cdr(rt, args)));
+    i64 val = pit_value_as_integer(rt, pit_value_cons_car(rt, args));
+    i64 shift = pit_value_as_integer(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, args)));
     if (shift >= 64) val = 0;
     else val >>= shift;
-    return pit_integer_new(rt, val);
+    return pit_value_integer_new(rt, val);
 }
 void pit_install_library_essential(pit_runtime *rt) {
     /* special forms */
-    pit_sfset(rt, pit_intern_cstr(rt, "quote"), pit_nativefunc_new(rt, impl_sf_quote));
-    pit_sfset(rt, pit_intern_cstr(rt, "if"), pit_nativefunc_new(rt, impl_sf_if));
-    pit_sfset(rt, pit_intern_cstr(rt, "cond"), pit_nativefunc_new(rt, impl_sf_cond));
-    pit_sfset(rt, pit_intern_cstr(rt, "progn"), pit_nativefunc_new(rt, impl_sf_progn));
-    pit_sfset(rt, pit_intern_cstr(rt, "or"), pit_nativefunc_new(rt, impl_sf_or));
-    pit_sfset(rt, pit_intern_cstr(rt, "lambda"), pit_nativefunc_new(rt, impl_sf_lambda));
+    pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "quote"), pit_value_nativefunc_new(rt, impl_sf_quote));
+    pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "if"), pit_value_nativefunc_new(rt, impl_sf_if));
+    pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "cond"), pit_value_nativefunc_new(rt, impl_sf_cond));
+    pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "progn"), pit_value_nativefunc_new(rt, impl_sf_progn));
+    pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "or"), pit_value_nativefunc_new(rt, impl_sf_or));
+    pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "lambda"), pit_value_nativefunc_new(rt, impl_sf_lambda));
     /* macros */
-    pit_mset(rt, pit_intern_cstr(rt, "defun!"), pit_nativefunc_new(rt, impl_m_defun));
-    pit_mset(rt, pit_intern_cstr(rt, "defmacro!"), pit_nativefunc_new(rt, impl_m_defmacro));
-    pit_mset(rt, pit_intern_cstr(rt, "defstruct!"), pit_nativefunc_new(rt, impl_m_defstruct));
-    pit_mset(rt, pit_intern_cstr(rt, "let"), pit_nativefunc_new(rt, impl_m_let));
-    pit_mset(rt, pit_intern_cstr(rt, "and"), pit_nativefunc_new(rt, impl_m_and));
-    pit_mset(rt, pit_intern_cstr(rt, "setq!"), pit_nativefunc_new(rt, impl_m_setq));
-    pit_mset(rt, pit_intern_cstr(rt, "case"), pit_nativefunc_new(rt, impl_m_case));
+    pit_symtab_mset(rt, pit_symtab_intern_cstr(rt, "defun!"), pit_value_nativefunc_new(rt, impl_m_defun));
+    pit_symtab_mset(rt, pit_symtab_intern_cstr(rt, "defmacro!"), pit_value_nativefunc_new(rt, impl_m_defmacro));
+    pit_symtab_mset(rt, pit_symtab_intern_cstr(rt, "defstruct!"), pit_value_nativefunc_new(rt, impl_m_defstruct));
+    pit_symtab_mset(rt, pit_symtab_intern_cstr(rt, "let"), pit_value_nativefunc_new(rt, impl_m_let));
+    pit_symtab_mset(rt, pit_symtab_intern_cstr(rt, "and"), pit_value_nativefunc_new(rt, impl_m_and));
+    pit_symtab_mset(rt, pit_symtab_intern_cstr(rt, "setq!"), pit_value_nativefunc_new(rt, impl_m_setq));
+    pit_symtab_mset(rt, pit_symtab_intern_cstr(rt, "case"), pit_value_nativefunc_new(rt, impl_m_case));
     /* error */
-    pit_fset(rt, pit_intern_cstr(rt, "error!"), pit_nativefunc_new(rt, impl_error));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "error!"), pit_value_nativefunc_new(rt, impl_error));
     /* eval */
-    pit_fset(rt, pit_intern_cstr(rt, "eval!"), pit_nativefunc_new(rt, impl_eval));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "eval!"), pit_value_nativefunc_new(rt, impl_eval));
     /* predicates */
-    pit_fset(rt, pit_intern_cstr(rt, "eq?"), pit_nativefunc_new(rt, impl_eq_p));
-    pit_fset(rt, pit_intern_cstr(rt, "equal?"), pit_nativefunc_new(rt, impl_equal_p));
-    pit_fset(rt, pit_intern_cstr(rt, "integer?"), pit_nativefunc_new(rt, impl_integer_p));
-    pit_fset(rt, pit_intern_cstr(rt, "double?"), pit_nativefunc_new(rt, impl_double_p));
-    pit_fset(rt, pit_intern_cstr(rt, "symbol?"), pit_nativefunc_new(rt, impl_symbol_p));
-    pit_fset(rt, pit_intern_cstr(rt, "cons?"), pit_nativefunc_new(rt, impl_cons_p));
-    pit_fset(rt, pit_intern_cstr(rt, "array?"), pit_nativefunc_new(rt, impl_array_p));
-    pit_fset(rt, pit_intern_cstr(rt, "bytes?"), pit_nativefunc_new(rt, impl_bytes_p));
-    pit_fset(rt, pit_intern_cstr(rt, "function?"), pit_nativefunc_new(rt, impl_function_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "eq?"), pit_value_nativefunc_new(rt, impl_eq_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "equal?"), pit_value_nativefunc_new(rt, impl_equal_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "integer?"), pit_value_nativefunc_new(rt, impl_integer_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "double?"), pit_value_nativefunc_new(rt, impl_double_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "symbol?"), pit_value_nativefunc_new(rt, impl_symbol_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "cons?"), pit_value_nativefunc_new(rt, impl_cons_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array?"), pit_value_nativefunc_new(rt, impl_array_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bytes?"), pit_value_nativefunc_new(rt, impl_bytes_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "function?"), pit_value_nativefunc_new(rt, impl_function_p));
     /* symbols */
-    pit_fset(rt, pit_intern_cstr(rt, "set!"), pit_nativefunc_new(rt, impl_set));
-    pit_fset(rt, pit_intern_cstr(rt, "fset!"), pit_nativefunc_new(rt, impl_fset));
-    pit_fset(rt, pit_intern_cstr(rt, "symbol-is-macro!"), pit_nativefunc_new(rt, impl_symbol_is_macro));
-    pit_fset(rt, pit_intern_cstr(rt, "funcall"), pit_nativefunc_new(rt, impl_funcall));
-    pit_fset(rt, pit_intern_cstr(rt, "apply"), pit_nativefunc_new(rt, impl_apply));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "set!"), pit_value_nativefunc_new(rt, impl_set));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "fset!"), pit_value_nativefunc_new(rt, impl_fset));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "symbol-is-macro!"), pit_value_nativefunc_new(rt, impl_symbol_mark_macro));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "funcall"), pit_value_nativefunc_new(rt, impl_funcall));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "apply"), pit_value_nativefunc_new(rt, impl_apply));
     /* cons cells */
-    pit_fset(rt, pit_intern_cstr(rt, "cons"), pit_nativefunc_new(rt, impl_cons));
-    pit_fset(rt, pit_intern_cstr(rt, "car"), pit_nativefunc_new(rt, impl_car));
-    pit_fset(rt, pit_intern_cstr(rt, "cdr"), pit_nativefunc_new(rt, impl_cdr));
-    pit_fset(rt, pit_intern_cstr(rt, "setcar!"), pit_nativefunc_new(rt, impl_setcar));
-    pit_fset(rt, pit_intern_cstr(rt, "setcdr!"), pit_nativefunc_new(rt, impl_setcdr));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "cons"), pit_value_nativefunc_new(rt, impl_cons));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "car"), pit_value_nativefunc_new(rt, impl_car));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "cdr"), pit_value_nativefunc_new(rt, impl_cdr));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "setcar!"), pit_value_nativefunc_new(rt, impl_setcar));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "setcdr!"), pit_value_nativefunc_new(rt, impl_setcdr));
     /* cons lists*/
-    pit_fset(rt, pit_intern_cstr(rt, "list"), pit_nativefunc_new(rt, impl_list));
-    pit_fset(rt, pit_intern_cstr(rt, "list/nth"), pit_nativefunc_new(rt, impl_list_nth));
-    pit_fset(rt, pit_intern_cstr(rt, "list/iota"), pit_nativefunc_new(rt, impl_list_iota));
-    pit_fset(rt, pit_intern_cstr(rt, "list/len"), pit_nativefunc_new(rt, impl_list_len));
-    pit_fset(rt, pit_intern_cstr(rt, "list/reverse"), pit_nativefunc_new(rt, impl_list_reverse));
-    pit_fset(rt, pit_intern_cstr(rt, "list/uniq"), pit_nativefunc_new(rt, impl_list_uniq));
-    pit_fset(rt, pit_intern_cstr(rt, "list/append"), pit_nativefunc_new(rt, impl_list_append));
-    pit_fset(rt, pit_intern_cstr(rt, "list/concat"), pit_nativefunc_new(rt, impl_list_concat));
-    pit_fset(rt, pit_intern_cstr(rt, "list/take"), pit_nativefunc_new(rt, impl_list_take));
-    pit_fset(rt, pit_intern_cstr(rt, "list/drop"), pit_nativefunc_new(rt, impl_list_drop));
-    pit_fset(rt, pit_intern_cstr(rt, "list/map"), pit_nativefunc_new(rt, impl_list_map));
-    pit_fset(rt, pit_intern_cstr(rt, "list/foldl"), pit_nativefunc_new(rt, impl_list_foldl));
-    pit_fset(rt, pit_intern_cstr(rt, "list/filter"), pit_nativefunc_new(rt, impl_list_filter));
-    pit_fset(rt, pit_intern_cstr(rt, "list/find"), pit_nativefunc_new(rt, impl_list_find));
-    pit_fset(rt, pit_intern_cstr(rt, "list/contains?"), pit_nativefunc_new(rt, impl_list_contains_p));
-    pit_fset(rt, pit_intern_cstr(rt, "list/all?"), pit_nativefunc_new(rt, impl_list_all_p));
-    pit_fset(rt, pit_intern_cstr(rt, "list/zip-with"), pit_nativefunc_new(rt, impl_list_zip_with));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list"), pit_value_nativefunc_new(rt, impl_list));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/nth"), pit_value_nativefunc_new(rt, impl_list_nth));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/iota"), pit_value_nativefunc_new(rt, impl_list_iota));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/len"), pit_value_nativefunc_new(rt, impl_list_len));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/reverse"), pit_value_nativefunc_new(rt, impl_list_reverse));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/uniq"), pit_value_nativefunc_new(rt, impl_list_uniq));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/append"), pit_value_nativefunc_new(rt, impl_list_append));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/concat"), pit_value_nativefunc_new(rt, impl_list_concat));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/take"), pit_value_nativefunc_new(rt, impl_list_take));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/drop"), pit_value_nativefunc_new(rt, impl_list_drop));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/map"), pit_value_nativefunc_new(rt, impl_list_map));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/foldl"), pit_value_nativefunc_new(rt, impl_list_foldl));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/filter"), pit_value_nativefunc_new(rt, impl_list_filter));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/find"), pit_value_nativefunc_new(rt, impl_list_find));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/contains?"), pit_value_nativefunc_new(rt, impl_list_contains_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/all?"), pit_value_nativefunc_new(rt, impl_list_all_p));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "list/zip-with"), pit_value_nativefunc_new(rt, impl_list_zip_with));
     /* bytestrings */ 
-    pit_fset(rt, pit_intern_cstr(rt, "bytes/len"), pit_nativefunc_new(rt, impl_bytes_len));
-    pit_fset(rt, pit_intern_cstr(rt, "bytes/range"), pit_nativefunc_new(rt, impl_bytes_range));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bytes/len"), pit_value_nativefunc_new(rt, impl_bytes_len));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bytes/range"), pit_value_nativefunc_new(rt, impl_bytes_range));
     /* array */
-    pit_fset(rt, pit_intern_cstr(rt, "array"), pit_nativefunc_new(rt, impl_array));
-    pit_fset(rt, pit_intern_cstr(rt, "array/to-list"), pit_nativefunc_new(rt, impl_array_to_list));
-    pit_fset(rt, pit_intern_cstr(rt, "array/from-list"), pit_nativefunc_new(rt, impl_array_from_list));
-    pit_fset(rt, pit_intern_cstr(rt, "array/repeat"), pit_nativefunc_new(rt, impl_array_repeat));
-    pit_fset(rt, pit_intern_cstr(rt, "array/len"), pit_nativefunc_new(rt, impl_array_len));
-    pit_fset(rt, pit_intern_cstr(rt, "array/get"), pit_nativefunc_new(rt, impl_array_get));
-    pit_fset(rt, pit_intern_cstr(rt, "array/set!"), pit_nativefunc_new(rt, impl_array_set));
-    pit_fset(rt, pit_intern_cstr(rt, "array/map"), pit_nativefunc_new(rt, impl_array_map));
-    pit_fset(rt, pit_intern_cstr(rt, "array/map!"), pit_nativefunc_new(rt, impl_array_map_mut));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array"), pit_value_nativefunc_new(rt, impl_array));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array/to-list"), pit_value_nativefunc_new(rt, impl_array_to_list));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array/from-list"), pit_value_nativefunc_new(rt, impl_array_from_list));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array/repeat"), pit_value_nativefunc_new(rt, impl_array_repeat));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array/len"), pit_value_nativefunc_new(rt, impl_array_len));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array/get"), pit_value_nativefunc_new(rt, impl_array_get));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array/set!"), pit_value_nativefunc_new(rt, impl_array_set));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array/map"), pit_value_nativefunc_new(rt, impl_array_map));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "array/map!"), pit_value_nativefunc_new(rt, impl_array_map_mut));
     /* arithmetic */
-    pit_fset(rt, pit_intern_cstr(rt, "abs"), pit_nativefunc_new(rt, impl_abs));
-    pit_fset(rt, pit_intern_cstr(rt, "+"), pit_nativefunc_new(rt, impl_add));
-    pit_fset(rt, pit_intern_cstr(rt, "-"), pit_nativefunc_new(rt, impl_sub));
-    pit_fset(rt, pit_intern_cstr(rt, "*"), pit_nativefunc_new(rt, impl_mul));
-    pit_fset(rt, pit_intern_cstr(rt, "/"), pit_nativefunc_new(rt, impl_div));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "abs"), pit_value_nativefunc_new(rt, impl_abs));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "+"), pit_value_nativefunc_new(rt, impl_add));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "-"), pit_value_nativefunc_new(rt, impl_sub));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "*"), pit_value_nativefunc_new(rt, impl_mul));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "/"), pit_value_nativefunc_new(rt, impl_div));
     /* booleans */
-    pit_fset(rt, pit_intern_cstr(rt, "not"), pit_nativefunc_new(rt, impl_not));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "not"), pit_value_nativefunc_new(rt, impl_not));
     /* comparisons */
-    pit_fset(rt, pit_intern_cstr(rt, "<"), pit_nativefunc_new(rt, impl_lt));
-    pit_fset(rt, pit_intern_cstr(rt, ">"), pit_nativefunc_new(rt, impl_gt));
-    pit_fset(rt, pit_intern_cstr(rt, "<="), pit_nativefunc_new(rt, impl_le));
-    pit_fset(rt, pit_intern_cstr(rt, ">="), pit_nativefunc_new(rt, impl_ge));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "<"), pit_value_nativefunc_new(rt, impl_lt));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, ">"), pit_value_nativefunc_new(rt, impl_gt));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "<="), pit_value_nativefunc_new(rt, impl_le));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, ">="), pit_value_nativefunc_new(rt, impl_ge));
     /* bitwise arithmetic */
-    pit_fset(rt, pit_intern_cstr(rt, "bitwise/and"), pit_nativefunc_new(rt, impl_bitwise_and));
-    pit_fset(rt, pit_intern_cstr(rt, "bitwise/or"), pit_nativefunc_new(rt, impl_bitwise_or));
-    pit_fset(rt, pit_intern_cstr(rt, "bitwise/xor"), pit_nativefunc_new(rt, impl_bitwise_xor));
-    pit_fset(rt, pit_intern_cstr(rt, "bitwise/not"), pit_nativefunc_new(rt, impl_bitwise_not));
-    pit_fset(rt, pit_intern_cstr(rt, "bitwise/lshift"), pit_nativefunc_new(rt, impl_bitwise_lshift));
-    pit_fset(rt, pit_intern_cstr(rt, "bitwise/rshift"), pit_nativefunc_new(rt, impl_bitwise_rshift));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bitwise/and"), pit_value_nativefunc_new(rt, impl_bitwise_and));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bitwise/or"), pit_value_nativefunc_new(rt, impl_bitwise_or));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bitwise/xor"), pit_value_nativefunc_new(rt, impl_bitwise_xor));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bitwise/not"), pit_value_nativefunc_new(rt, impl_bitwise_not));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bitwise/lshift"), pit_value_nativefunc_new(rt, impl_bitwise_lshift));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "bitwise/rshift"), pit_value_nativefunc_new(rt, impl_bitwise_rshift));
 }
 
 static pit_value impl_plist_get(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value k = pit_car(rt, args);
-    pit_value vs = pit_car(rt, pit_cdr(rt, args));
-    return pit_plist_get(rt, k, vs);
+    pit_value k = pit_value_cons_car(rt, args);
+    pit_value vs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    return pit_value_list_plist_get(rt, k, vs);
 }
 void pit_install_library_plist(pit_runtime *rt) {
     /* property lists / keyword arguments */
-    pit_fset(rt, pit_intern_cstr(rt, "plist/get"), pit_nativefunc_new(rt, impl_plist_get));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "plist/get"), pit_value_nativefunc_new(rt, impl_plist_get));
 }
 
 static pit_value impl_alist_get(pit_runtime *rt, pit_value args, void *data) {
     (void) data;
-    pit_value k = pit_car(rt, args);
-    pit_value vs = pit_car(rt, pit_cdr(rt, args));
+    pit_value k = pit_value_cons_car(rt, args);
+    pit_value vs = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
     while (vs != PIT_NIL) {
-        pit_value v = pit_car(rt, vs);
-        if (pit_equal(rt, k, pit_car(rt, v))) {
-            return pit_cdr(rt, v);
+        pit_value v = pit_value_cons_car(rt, vs);
+        if (pit_value_equal(rt, k, pit_value_cons_car(rt, v))) {
+            return pit_value_cons_cdr(rt, v);
         }
-        vs = pit_cdr(rt, vs);
+        vs = pit_value_cons_cdr(rt, vs);
     }
     return PIT_NIL;
 }
 void pit_install_library_alist(pit_runtime *rt) {
     /* association lists */
-    pit_fset(rt, pit_intern_cstr(rt, "alist/get"), pit_nativefunc_new(rt, impl_alist_get));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "alist/get"), pit_value_nativefunc_new(rt, impl_alist_get));
 }