All: split types into types, env, printer, core.

- types: low-level mapping to the implementation language.
- core: functions on types that are exposed directly to mal.
- printer: implementation called by pr-str, str, prn, println.
- env: the environment implementation

- Also, unindent all TCO while loops so that the diff of step4 and
  step5 are minimized.

1 files changed, 55 insertions, 698 deletions

diff --git a/c/types.c b/c/types.c
index a6bfbf6..5c06d9d 100644
--- a/c/types.c
+++ b/c/types.c
@@ -3,11 +3,17 @@
 #include <stdlib.h>
 #include <string.h>
 #include "types.h"
+#include "printer.h"
 
-// State
 
-MalVal *mal_error = NULL;
+// Errors/Exceptions
 
+MalVal *mal_error = NULL; // WARNGIN: global state
+void _error(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    mal_error = malval_new_string(g_strdup_vprintf(fmt, args));
+}
 
 // Constant atomic values
 
@@ -16,10 +22,6 @@ MalVal mal_true = {MAL_TRUE, NULL, {0}, 0};
 MalVal mal_false = {MAL_FALSE, NULL, {0}, 0};
 
 
-// Pre-declarations
-
-MalVal *cons(MalVal *x, MalVal *seq);
-
 // General Functions
 
 // Print a hash table
@@ -103,18 +105,18 @@ MalVal *malval_new_symbol(char *val) {
     return mv;
 }
 
-MalVal *malval_new_hash_map(GHashTable *val) {
-    MalVal *mv = malval_new(MAL_HASH_MAP, NULL);
-    mv->val.hash_table = val;
-    return mv;
-}
-
 MalVal *malval_new_list(MalType type, GArray *val) {
     MalVal *mv = malval_new(type, NULL);
     mv->val.array = val;
     return mv;
 }
 
+MalVal *malval_new_hash_map(GHashTable *val) {
+    MalVal *mv = malval_new(MAL_HASH_MAP, NULL);
+    mv->val.hash_table = val;
+    return mv;
+}
+
 MalVal *malval_new_atom(MalVal *val) {
     MalVal *mv = malval_new(MAL_ATOM, NULL);
     mv->val.atom_val = val;
@@ -186,7 +188,7 @@ MalVal *malval_new_function(void *(*func)(void *), int arg_cnt, MalVal* metadata
     return mv;
 }
 
-MalVal *apply(MalVal *f, MalVal *args) {
+MalVal *_apply(MalVal *f, MalVal *args) {
     MalVal *res;
     assert_type(f, MAL_FUNCTION_C|MAL_FUNCTION_MAL,
                 "Cannot invoke %s", _pr_str(f,1));
@@ -259,196 +261,6 @@ MalVal *apply(MalVal *f, MalVal *args) {
 }
 
 
-char *_pr_str_hash_map(MalVal *obj, int print_readably) {
-    int start = 1;
-    char *repr = NULL, *repr_tmp1 = NULL, *repr_tmp2 = NULL;
-    GHashTableIter iter;
-    gpointer key, value;
-
-    repr = g_strdup_printf("{");
-
-    g_hash_table_iter_init (&iter, obj->val.hash_table);
-    while (g_hash_table_iter_next (&iter, &key, &value)) {
-        //g_print ("%s/%p ", (const char *) key, (void *) value);
-
-        repr_tmp1 = _pr_str((MalVal*)value, print_readably);
-        if (start) {
-            start = 0;
-            repr = g_strdup_printf("{\"%s\" %s", (char *)key, repr_tmp1);
-        } else {
-            repr_tmp2 = repr;
-            repr = g_strdup_printf("%s \"%s\" %s", repr_tmp2, (char *)key, repr_tmp1);
-            free(repr_tmp2);
-        }
-        free(repr_tmp1);
-    }
-    repr_tmp2 = repr;
-    repr = g_strdup_printf("%s}", repr_tmp2);
-    free(repr_tmp2);
-    return repr;
-}
-
-char *_pr_str_list(MalVal *obj, int print_readably, char start, char end) {
-    int i;
-    char *repr = NULL, *repr_tmp1 = NULL, *repr_tmp2 = NULL;
-    repr = g_strdup_printf("%c", start);
-    for (i=0; i<_count(obj); i++) {
-        repr_tmp1 = _pr_str(g_array_index(obj->val.array, MalVal*, i),
-                            print_readably);
-        if (i == 0) {
-            repr = g_strdup_printf("%c%s", start, repr_tmp1);
-        } else {
-            repr_tmp2 = repr;
-            repr = g_strdup_printf("%s %s", repr_tmp2, repr_tmp1);
-            free(repr_tmp2);
-        }
-        free(repr_tmp1);
-    }
-    repr_tmp2 = repr;
-    repr = g_strdup_printf("%s%c", repr_tmp2, end);
-    free(repr_tmp2);
-    return repr;
-}
-
-// Return a string representation of the MalVal object. Returned string must
-// be freed by caller.
-char *_pr_str(MalVal *obj, int print_readably) {
-    char *repr = NULL;
-    if (obj == NULL) { return NULL; }
-    switch (obj->type) {
-    case MAL_NIL:
-        repr = g_strdup_printf("nil");
-        break;
-    case MAL_TRUE:
-        repr = g_strdup_printf("true");
-        break;
-    case MAL_FALSE:
-        repr = g_strdup_printf("false");
-        break;
-    case MAL_STRING:
-        if (print_readably) {
-            char *repr_tmp = g_strescape(obj->val.string, "");
-            repr = g_strdup_printf("\"%s\"", repr_tmp);
-            free(repr_tmp);
-        } else {
-            repr = g_strdup_printf("%s", obj->val.string);
-        }
-        break;
-    case MAL_SYMBOL:
-        repr = g_strdup_printf("%s", obj->val.string);
-        break;
-    case MAL_INTEGER:
-        repr = g_strdup_printf("%" G_GINT64_FORMAT, obj->val.intnum);
-        break;
-    case MAL_FLOAT:
-        repr = g_strdup_printf("%f", obj->val.floatnum);
-        break;
-    case MAL_HASH_MAP:
-        repr = _pr_str_hash_map(obj, print_readably);
-        break;
-    case MAL_LIST:
-        repr = _pr_str_list(obj, print_readably, '(', ')');
-        break;
-    case MAL_VECTOR:
-        repr = _pr_str_list(obj, print_readably, '[', ']');
-        break;
-    case MAL_ATOM:
-        repr = g_strdup_printf("(atom %s)",
-                               _pr_str(obj->val.atom_val, print_readably));
-        break;
-    case MAL_FUNCTION_C:
-        repr = g_strdup_printf("#<function@%p>", obj->val.f0);
-        break;
-    case MAL_FUNCTION_MAL:
-        repr = g_strdup_printf("#<Function: (fn* %s %s)>",
-                                _pr_str(obj->val.func.args, print_readably),
-                                _pr_str(obj->val.func.body, print_readably));
-        break;
-    default:
-        printf("pr_str unknown type %d\n", obj->type);
-        repr = g_strdup_printf("<unknown>");
-    }
-    return repr;
-}
-
-// Return a string representation of the MalVal arguments. Returned string must
-// be freed by caller.
-char *_pr_str_args(MalVal *args, char *sep, int print_readably) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "_pr_str called with non-sequential args");
-    int i;
-    char *repr = g_strdup_printf(""),
-         *repr2 = NULL;
-    for (i=0; i<_count(args); i++) {
-        MalVal *obj = g_array_index(args->val.array, MalVal*, i);
-        if (i != 0) {
-            repr2 = repr;
-            repr = g_strdup_printf("%s%s", repr2, sep);
-            free(repr2);
-        }
-        repr2 = repr;
-        repr = g_strdup_printf("%s%s",
-                               repr2, _pr_str(obj, print_readably));
-        free(repr2);
-    }
-    return repr;
-}
-
-// Return a string representation of a MalVal sequence (in a format that can
-// be read by the reader). Returned string must be freed by caller.
-MalVal *pr_str(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "pr_str called with non-sequential args");
-    return malval_new_string(_pr_str_args(args, " ", 1));
-}
-
-// Return a string representation of a MalVal sequence with every item
-// concatenated together. Returned string must be freed by caller.
-MalVal *str(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "str called with non-sequential args");
-    return malval_new_string(_pr_str_args(args, "", 0));
-}
-
-// Print a string representation of a MalVal sequence (in a format that can
-// be read by the reader) followed by a newline. Returns nil.
-MalVal *prn(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "prn called with non-sequential args");
-    char *repr = _pr_str_args(args, " ", 1);
-    g_print("%s\n", repr);
-    free(repr);
-    return &mal_nil;
-}
-
-// Print a string representation of a MalVal sequence (for human consumption)
-// followed by a newline. Returns nil.
-MalVal *println(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "println called with non-sequential args");
-    char *repr = _pr_str_args(args, " ", 0);
-    g_print("%s\n", repr);
-    free(repr);
-    return &mal_nil;
-}
-
-MalVal *with_meta(MalVal *obj, MalVal *meta) {
-    MalVal *new_obj = malval_new(obj->type, meta);
-    new_obj->val = obj->val;
-    return new_obj;
-}
-
-MalVal *meta(MalVal *obj) {
-    assert_type(obj, MAL_LIST|MAL_VECTOR|MAL_HASH_MAP|MAL_FUNCTION_C|MAL_FUNCTION_MAL,
-                "attempt to get metadata from non-collection type");
-    if (obj->metadata == NULL) {
-        return &mal_nil;
-    } else {
-        return obj->metadata;
-    }
-}
-
-
 int _equal_Q(MalVal *a, MalVal *b) {
     if (a == NULL || b == NULL) { return FALSE; }
 
@@ -498,170 +310,9 @@ int _equal_Q(MalVal *a, MalVal *b) {
     }
 }
 
-MalVal *equal_Q(MalVal *a, MalVal *b) {
-    if (_equal_Q(a, b)) { return &mal_true; }
-    else { return &mal_false; }
-}
-
-//
-// nil, true, false, string
-MalVal *nil_Q(MalVal *seq) { return seq->type & MAL_NIL ? &mal_true : &mal_false; }
-MalVal *true_Q(MalVal *seq) { return seq->type & MAL_TRUE ? &mal_true : &mal_false; }
-MalVal *false_Q(MalVal *seq) { return seq->type & MAL_FALSE ? &mal_true : &mal_false; }
-MalVal *string_Q(MalVal *seq) { return seq->type & MAL_STRING ? &mal_true : &mal_false; }
-
-//
-// Numbers
-#define WRAP_INTEGER_OP(name, op) \
-    MalVal *int_ ## name(MalVal *a, MalVal *b)     { \
-        return malval_new_integer(a->val.intnum op b->val.intnum); \
-    }
-#define WRAP_INTEGER_CMP_OP(name, op) \
-    MalVal *int_ ## name(MalVal *a, MalVal *b)     { \
-        return a->val.intnum op b->val.intnum ? &mal_true : &mal_false; \
-    }
-WRAP_INTEGER_OP(plus,+)
-WRAP_INTEGER_OP(minus,-)
-WRAP_INTEGER_OP(multiply,*)
-WRAP_INTEGER_OP(divide,/)
-WRAP_INTEGER_CMP_OP(gt,>)
-WRAP_INTEGER_CMP_OP(gte,>=)
-WRAP_INTEGER_CMP_OP(lt,<)
-WRAP_INTEGER_CMP_OP(lte,<=)
-
-
-//
-// Symbols
-MalVal *symbol_Q(MalVal *seq) { return seq->type & MAL_SYMBOL ? &mal_true : &mal_false; }
-
-
-// Hash maps
-//
-MalVal *_hash_map(int count, ...) {
-    assert((count % 2) == 0,
-           "odd number of parameters to hash-map");
-    GHashTable *htable = g_hash_table_new(g_str_hash, g_str_equal);
-    MalVal *hm = malval_new_hash_map(htable);
-    char *k;
-    MalVal *v;
-    va_list ap;
-    va_start(ap, count);
-    while (count > 0) {
-        k = va_arg(ap, char*);
-        v = va_arg(ap, MalVal*);
-        g_hash_table_insert(htable, k, v);
-        count = count - 2;
-    }
-    va_end(ap);
-    return hm;
-}
-
-MalVal *_assoc_BANG(MalVal* hm, MalVal *args) {
-    assert((_count(args) % 2) == 0,
-           "odd number of parameters to assoc!");
-    GHashTable *htable = hm->val.hash_table;
-    int i;
-    MalVal *k, *v;
-    for (i=0; i<_count(args); i+=2) {
-        k = g_array_index(args->val.array, MalVal*, i);
-        assert_type(k, MAL_STRING,
-                    "assoc! called with non-string key");
-        v = g_array_index(args->val.array, MalVal*, i+1);
-        g_hash_table_insert(htable, k->val.string, v);
-    }
-    return hm;
-}
-
-MalVal *_dissoc_BANG(MalVal* hm, MalVal *args) {
-    GHashTable *htable = hm->val.hash_table;
-    int i;
-    MalVal *k, *v;
-    for (i=0; i<_count(args); i++) {
-        k = g_array_index(args->val.array, MalVal*, i);
-        assert_type(k, MAL_STRING,
-                    "dissoc! called with non-string key");
-        g_hash_table_remove(htable, k->val.string);
-    }
-    return hm;
-}
-
-MalVal *hash_map(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "hash-map called with non-sequential arguments");
-    GHashTable *htable = g_hash_table_new(g_str_hash, g_str_equal);
-    MalVal *hm = malval_new_hash_map(htable);
-    return _assoc_BANG(hm, args);
-}
-
-int _hash_map_Q(MalVal *seq) {
-    return seq->type & MAL_HASH_MAP;
-}
-MalVal *hash_map_Q(MalVal *seq) { return _hash_map_Q(seq) ? &mal_true : &mal_false; }
-
-MalVal *assoc(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "assoc called with non-sequential arguments");
-    assert(_count(args) >= 2,
-           "assoc needs at least 2 arguments");
-    GHashTable *htable = g_hash_table_copy(_nth(args,0)->val.hash_table);
-    MalVal *hm = malval_new_hash_map(htable);
-    return _assoc_BANG(hm, rest(args));
-}
-
-MalVal *dissoc(MalVal* args) {
-    GHashTable *htable = g_hash_table_copy(_nth(args,0)->val.hash_table);
-    MalVal *hm = malval_new_hash_map(htable);
-    return _dissoc_BANG(hm, rest(args));
-}
-
-MalVal *keys(MalVal *obj) {
-    assert_type(obj, MAL_HASH_MAP,
-                "keys called on non-hash-map");
-
-    GHashTableIter iter;
-    gpointer key, value;
-    MalVal *seq = malval_new_list(MAL_LIST,
-                                  g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
-                                                    _count(obj)));
-    g_hash_table_iter_init (&iter, obj->val.hash_table);
-    while (g_hash_table_iter_next (&iter, &key, &value)) {
-        MalVal *kname = malval_new_string((char *)key);
-        g_array_append_val(seq->val.array, kname);
-    }
-    return seq;
-}
-
-MalVal *vals(MalVal *obj) {
-    assert_type(obj, MAL_HASH_MAP,
-                "vals called on non-hash-map");
-
-    GHashTableIter iter;
-    gpointer key, value;
-    MalVal *seq = malval_new_list(MAL_LIST,
-                                  g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
-                                                    _count(obj)));
-    g_hash_table_iter_init (&iter, obj->val.hash_table);
-    while (g_hash_table_iter_next (&iter, &key, &value)) {
-        g_array_append_val(seq->val.array, value);
-    }
-    return seq;
-}
-
-
-// Errors/Exceptions
-void _error(const char *fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    mal_error = malval_new_string(g_strdup_vprintf(fmt, args));
-}
-void throw(MalVal *obj) {
-    mal_error = obj;
-}
-
 
 // Lists
-
-MalVal *_list(int count, ...) {
+MalVal *_listX(int count, ...) {
     MalVal *seq = malval_new_list(MAL_LIST,
                                   g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
                                                     count));
@@ -675,7 +326,8 @@ MalVal *_list(int count, ...) {
     va_end(ap);
     return seq;
 }
-MalVal *list(MalVal *args) {
+
+MalVal *_list(MalVal *args) {
     assert_type(args, MAL_LIST|MAL_VECTOR,
                 "list called with invalid arguments");
     args->type = MAL_LIST;
@@ -685,116 +337,68 @@ MalVal *list(MalVal *args) {
 int _list_Q(MalVal *seq) {
     return seq->type & MAL_LIST;
 }
-MalVal *list_Q(MalVal *seq) { return _list_Q(seq) ? &mal_true : &mal_false; }
 
 
 // Vectors
-
-MalVal *_vector(int count, ...) {
-    MalVal *seq = malval_new_list(MAL_VECTOR,
-                                  g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
-                                                    count));
-    MalVal *v;
-    va_list ap;
-    va_start(ap, count);
-    while (count-- > 0) {
-        v = va_arg(ap, MalVal*);
-        g_array_append_val(seq->val.array, v);
-    }
-    va_end(ap);
-    return seq;
-}
-MalVal *vector(MalVal *args) {
+MalVal *_vector(MalVal *args) {
     assert_type(args, MAL_LIST|MAL_VECTOR,
                 "vector called with invalid arguments");
     args->type = MAL_VECTOR;
     return args;
 }
 
-
 int _vector_Q(MalVal *seq) {
     return seq->type & MAL_VECTOR;
 }
-MalVal *vector_Q(MalVal *seq) { return _vector_Q(seq) ? &mal_true : &mal_false; }
 
 
-// hash map and vector functions
-MalVal *get(MalVal *obj, MalVal *key) {
-    MalVal *val;
-    switch (obj->type) {
-    case MAL_VECTOR:
-        return _nth(obj, key->val.intnum);
-    case MAL_HASH_MAP:
-        if (g_hash_table_lookup_extended(obj->val.hash_table,
-                                         key->val.string,
-                                         NULL, (gpointer*)&val)) {
-            return val;
-        } else {
-            return &mal_nil;
-        }
-    default:
-        abort("get called on unsupported type %d", obj->type);
+// Hash maps
+MalVal *_hash_map(MalVal *args) {
+    assert_type(args, MAL_LIST|MAL_VECTOR,
+                "hash-map called with non-sequential arguments");
+    GHashTable *htable = g_hash_table_new(g_str_hash, g_str_equal);
+    MalVal *hm = malval_new_hash_map(htable);
+    return _assoc_BANG(hm, args);
+}
+
+int _hash_map_Q(MalVal *seq) {
+    return seq->type & MAL_HASH_MAP;
+}
+
+MalVal *_assoc_BANG(MalVal* hm, MalVal *args) {
+    assert((_count(args) % 2) == 0,
+           "odd number of parameters to assoc!");
+    GHashTable *htable = hm->val.hash_table;
+    int i;
+    MalVal *k, *v;
+    for (i=0; i<_count(args); i+=2) {
+        k = g_array_index(args->val.array, MalVal*, i);
+        assert_type(k, MAL_STRING,
+                    "assoc! called with non-string key");
+        v = g_array_index(args->val.array, MalVal*, i+1);
+        g_hash_table_insert(htable, k->val.string, v);
     }
+    return hm;
 }
 
-MalVal *contains_Q(MalVal *obj, MalVal *key) {
-    switch (obj->type) {
-    case MAL_VECTOR:
-        if (key->val.intnum < obj->val.array->len) {
-            return &mal_true;
-        } else {
-            return &mal_false;
-        }
-    case MAL_HASH_MAP:
-        if (g_hash_table_contains(obj->val.hash_table, key->val.string)) {
-            return &mal_true;
-        } else {
-            return &mal_false;
-        }
-    default:
-        abort("contains? called on unsupported type %d", obj->type);
+MalVal *_dissoc_BANG(MalVal* hm, MalVal *args) {
+    GHashTable *htable = hm->val.hash_table;
+    int i;
+    MalVal *k, *v;
+    for (i=0; i<_count(args); i++) {
+        k = g_array_index(args->val.array, MalVal*, i);
+        assert_type(k, MAL_STRING,
+                    "dissoc! called with non-string key");
+        g_hash_table_remove(htable, k->val.string);
     }
+    return hm;
 }
 
 
 // Atoms
-MalVal *atom(MalVal *val) {
-    return malval_new_atom(val);
-}
-
 int _atom_Q(MalVal *exp) {
     return exp->type & MAL_ATOM;
 }
-MalVal *atom_Q(MalVal *exp) { return _atom_Q(exp) ? &mal_true : &mal_false; }
-
-MalVal *deref(MalVal *atm) {
-    assert_type(atm, MAL_ATOM,
-                "deref called on non-atom");
-    return atm->val.atom_val;
-}
-
-MalVal *reset_BANG(MalVal *atm, MalVal *val) {
-    assert_type(atm, MAL_ATOM,
-                "reset! called with non-atom");
-    atm->val.atom_val = val;
-    return val;
-}
-
-MalVal *swap_BANG(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "swap! called with invalid arguments");
-    assert(_count(args) >= 2,
-           "swap! called with %d args, needs at least 2", _count(args));
-    MalVal *atm = _nth(args, 0),
-           *f = _nth(args, 1),
-           *sargs = _slice(args, 2, _count(args)),
-           *fargs = cons(atm->val.atom_val, sargs),
-           *new_val = apply(f, fargs);
-    if (mal_error) { return NULL; }
-    atm->val.atom_val = new_val;
-    return new_val;
-}
-
 
 
 // Sequence functions
@@ -813,96 +417,6 @@ MalVal *_slice(MalVal *seq, int start, int end) {
 int _sequential_Q(MalVal *seq) {
     return seq->type & (MAL_LIST|MAL_VECTOR);
 }
-MalVal *sequential_Q(MalVal *seq) {
-    return _sequential_Q(seq) ? &mal_true : &mal_false;
-}
-
-MalVal *cons(MalVal *x, MalVal *seq) {
-    assert_type(seq, MAL_LIST|MAL_VECTOR,
-                "second argument to cons is non-sequential");
-    int i, len = _count(seq);
-    GArray *new_arr = g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
-                                        len+1);
-    g_array_append_val(new_arr, x);
-    for (i=0; i<len; i++) {
-        g_array_append_val(new_arr, g_array_index(seq->val.array, MalVal*, i));
-    }
-    return malval_new_list(MAL_LIST, new_arr);
-}
-
-MalVal *count(MalVal *seq) {
-    return malval_new_integer(_count(seq));
-}
-
-MalVal *empty_Q(MalVal *seq) {
-    assert_type(seq, MAL_LIST|MAL_VECTOR,
-                "empty? called with non-sequential");
-    return (seq->val.array->len == 0) ? &mal_true : &mal_false;
-}
-
-MalVal *concat(MalVal *args) {
-    MalVal *arg, *e, *lst;
-    int i, j, arg_cnt = _count(args);
-    lst = malval_new_list(MAL_LIST,
-                        g_array_sized_new(TRUE, TRUE, sizeof(MalVal*), arg_cnt));
-    for (i=0; i<arg_cnt; i++) {
-        arg = g_array_index(args->val.array, MalVal*, i);
-        assert_type(arg, MAL_LIST|MAL_VECTOR,
-                    "concat called with non-sequential");
-        for (j=0; j<_count(arg); j++) {
-            e = g_array_index(arg->val.array, MalVal*, j);
-            g_array_append_val(lst->val.array, e);
-        }
-    }
-
-    return lst;
-}
-
-MalVal *sconj(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "conj called with non-sequential");
-    MalVal *src_lst = _nth(args, 0);
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "first argument to conj is non-sequential");
-    int i, len = _count(src_lst) + _count(args) - 1;
-    GArray *new_arr = g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
-                                        len);
-    // Copy in src_lst
-    for (i=0; i<_count(src_lst); i++) {
-        g_array_append_val(new_arr, g_array_index(src_lst->val.array, MalVal*, i));
-    }
-    // Conj extra args
-    for (i=1; i<_count(args); i++) {
-        if (src_lst->type & MAL_LIST) {
-            g_array_prepend_val(new_arr, g_array_index(args->val.array, MalVal*, i));
-        } else {
-            g_array_append_val(new_arr, g_array_index(args->val.array, MalVal*, i));
-        }
-    }
-    return malval_new_list(src_lst->type, new_arr);
-}
-
-MalVal *first(MalVal *seq) {
-    assert_type(seq, MAL_LIST|MAL_VECTOR,
-                "first called with non-sequential");
-    if (_count(seq) == 0) {
-        return &mal_nil;
-    }
-    return g_array_index(seq->val.array, MalVal*, 0);
-}
-
-MalVal *last(MalVal *seq) {
-    assert_type(seq, MAL_LIST|MAL_VECTOR,
-                "last called with non-sequential");
-    if (_count(seq) == 0) {
-        return &mal_nil;
-    }
-    return g_array_index(seq->val.array, MalVal*, _count(seq)-1);
-}
-
-MalVal *rest(MalVal *seq) {
-    return _slice(seq, 1, _count(seq));
-}
 
 MalVal *_nth(MalVal *seq, int idx) {
     assert_type(seq, MAL_LIST|MAL_VECTOR,
@@ -912,30 +426,6 @@ MalVal *_nth(MalVal *seq, int idx) {
     }
     return g_array_index(seq->val.array, MalVal*, idx);
 }
-MalVal *nth(MalVal *seq, MalVal *idx) {
-    return _nth(seq, idx->val.intnum);
-}
-
-MalVal *sapply(MalVal *args) {
-    assert_type(args, MAL_LIST|MAL_VECTOR,
-                "apply called with non-sequential");
-    MalVal *f = _nth(args, 0);
-    MalVal *last_arg = _nth(args, _count(args)-1); 
-    assert_type(last_arg, MAL_LIST|MAL_VECTOR,
-                "last argument to apply is non-sequential");
-    int i, len = _count(args) - 2 + _count(last_arg);
-    GArray *new_arr = g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
-                                        len);
-    // Initial arguments
-    for (i=1; i<_count(args)-1; i++) {
-        g_array_append_val(new_arr, g_array_index(args->val.array, MalVal*, i));
-    }
-    // Add arguments from last_arg
-    for (i=0; i<_count(last_arg); i++) {
-        g_array_append_val(new_arr, g_array_index(last_arg->val.array, MalVal*, i));
-    }
-    return apply(f, malval_new_list(MAL_LIST, new_arr));
-}
 
 MalVal *_map2(MalVal *(*func)(void*, void*), MalVal *lst, void *arg2) {
     MalVal *e, *el;
@@ -951,136 +441,3 @@ MalVal *_map2(MalVal *(*func)(void*, void*), MalVal *lst, void *arg2) {
     }
     return el;
 }
-
-MalVal *map(MalVal *mvf, MalVal *lst) {
-    MalVal *res, *el;
-    assert_type(mvf, MAL_FUNCTION_C|MAL_FUNCTION_MAL,
-                "map called with non-function");
-    assert_type(lst, MAL_LIST|MAL_VECTOR,
-                "map called with non-sequential");
-    int i, len = _count(lst);
-    el = malval_new_list(MAL_LIST,
-                         g_array_sized_new(TRUE, TRUE, sizeof(MalVal*), len));
-    for (i=0; i<len; i++) {
-        // TODO: this is replicating some of apply functionality
-        if (mvf->type & MAL_FUNCTION_MAL) {
-            Env *fn_env = new_env(mvf->val.func.env,
-                                  mvf->val.func.args,
-                                  _slice(lst, i, i+1));
-            res = mvf->val.func.evaluator(mvf->val.func.body, fn_env);
-        } else {
-            res = mvf->val.f1(g_array_index(lst->val.array, MalVal*, i));
-        }
-        if (!res || mal_error) return NULL;
-        g_array_append_val(el->val.array, res);
-    }
-    return el;
-}
-
-
-// Env
-
-Env *new_env(Env *outer, MalVal* binds, MalVal *exprs) {
-    Env *e = malloc(sizeof(Env));
-    e->table = g_hash_table_new(g_str_hash, g_str_equal);
-    e->outer = outer;
-
-    if (binds && exprs) {
-        assert_type(binds, MAL_LIST|MAL_VECTOR,
-                    "new_env called with non-sequential bindings");
-        assert_type(exprs, MAL_LIST|MAL_VECTOR,
-                    "new_env called with non-sequential expressions");
-        int binds_len = _count(binds),
-            exprs_len = _count(exprs),
-            varargs = 0, i;
-        for (i=0; i<binds_len; i++) {
-            if (i > exprs_len) { break; }
-            if (_nth(binds, i)->val.string[0] == '&') {
-                varargs = 1;
-                env_set(e, _nth(binds, i+1)->val.string, _slice(exprs, i, _count(exprs)));
-                break;
-            } else {
-              env_set(e, _nth(binds, i)->val.string, _nth(exprs, i));
-            }
-        }
-        assert(varargs || (binds_len == exprs_len),
-               "Arity mismatch: %d formal params vs %d actual params",
-               binds_len, exprs_len);
-
-    }
-    return e;
-}
-
-Env *env_find(Env *env, char *key) {
-    void *val = g_hash_table_lookup(env->table, key);
-    if (val) {
-        return env;
-    } else if (env->outer) {
-        return env_find(env->outer, key);
-    } else {
-        return NULL;
-    }
-}
-
-MalVal *env_get(Env *env, char *key) {
-    Env *e = env_find(env, key);
-    assert(e, "'%s' not found", key);
-    return g_hash_table_lookup(e->table, key);
-}
-
-Env *env_set(Env *env, char *key, MalVal *val) {
-    g_hash_table_insert(env->table, key, val);
-    return env;
-}
-
-types_ns_entry types_ns[49] = {
-    {"pr-str", (void*(*)(void*))pr_str, -1},
-    {"str", (void*(*)(void*))str, -1},
-    {"prn", (void*(*)(void*))prn, -1},
-    {"println", (void*(*)(void*))println, -1},
-    {"with-meta", (void*(*)(void*))with_meta, 2},
-    {"meta", (void*(*)(void*))meta, 1},
-    {"=", (void*(*)(void*))equal_Q, 2},
-    {"symbol?", (void*(*)(void*))symbol_Q, 1},
-    {"nil?", (void*(*)(void*))nil_Q, 1},
-    {"true?", (void*(*)(void*))true_Q, 1},
-    {"false?", (void*(*)(void*))false_Q, 1},
-    {"+", (void*(*)(void*))int_plus, 2},
-    {"-", (void*(*)(void*))int_minus, 2},
-    {"*", (void*(*)(void*))int_multiply, 2},
-    {"/", (void*(*)(void*))int_divide, 2},
-    {">", (void*(*)(void*))int_gt, 2},
-    {">=", (void*(*)(void*))int_gte, 2},
-    {"<", (void*(*)(void*))int_lt, 2},
-    {"<=", (void*(*)(void*))int_lte, 2},
-    {"hash-map", (void*(*)(void*))hash_map, -1},
-    {"map?", (void*(*)(void*))hash_map_Q, 1},
-    {"assoc", (void*(*)(void*))assoc, -1},
-    {"dissoc", (void*(*)(void*))dissoc, -1},
-    {"get", (void*(*)(void*))get, 2},
-    {"contains?", (void*(*)(void*))contains_Q, 2},
-    {"keys", (void*(*)(void*))keys, 1},
-    {"vals", (void*(*)(void*))vals, 1},
-    {"throw", (void*(*)(void*))throw, 1},
-    {"list", (void*(*)(void*))list, -1},
-    {"list?", (void*(*)(void*))list_Q, 1},
-    {"vector", (void*(*)(void*))vector, -1},
-    {"vector?", (void*(*)(void*))vector_Q, 1},
-    {"atom", (void*(*)(void*))atom, 1},
-    {"atom?", (void*(*)(void*))atom_Q, 1},
-    {"deref", (void*(*)(void*))deref, 1},
-    {"reset!", (void*(*)(void*))reset_BANG, 2},
-    {"swap!", (void*(*)(void*))swap_BANG, -1},
-    {"sequential?", (void*(*)(void*))sequential_Q, 1},
-    {"cons", (void*(*)(void*))cons, 2},
-    {"count", (void*(*)(void*))count, 1},
-    {"empty?", (void*(*)(void*))empty_Q, 1},
-    {"concat", (void*(*)(void*))concat, -1},
-    {"conj", (void*(*)(void*))sconj, -1},
-    {"first", (void*(*)(void*))first, 1},
-    {"last", (void*(*)(void*))last, 1},
-    {"rest", (void*(*)(void*))rest, 1},
-    {"nth", (void*(*)(void*))nth, 2},
-    {"apply", (void*(*)(void*))sapply, -1},
-    {"map", (void*(*)(void*))map, 2},
-    };