Finish step 9 so all tests pass

I had punted on properly implemented equality, that is now sorted. It
was easier than I thought, but I was getting tripped up on Kotlin's
slightly opaque error messaging around type checking recursion.

Author: broquaint

kotlin/src/mal/core.kt

@@ -6,7 +6,7 @@ private fun to_fun(name: String, f: MalFn) : Pair<MalSymbol, MalFunc> =
     malSym(name) to malFun(name, f)
 
 // =: compare the first two parameters and return true if they are the same type and contain the same value.
-private fun is_equal(a: MalType, b: MalType) =
+private fun is_equal(a: MalType, b: MalType): Boolean =
     if(a::class == b::class) {
         when(a) {
             is MalNumber  -> a.num  == (b as MalNumber).num
@@ -18,29 +18,26 @@ private fun is_equal(a: MalType, b: MalType) =
             is MalSeq     -> compare_lists(a, (b as MalSeq))
             is MalMap     -> compare_maps(a, (b as MalMap))
             is MalFunc    -> a.func == (b as MalFunc).func
-            // XXX Not particularly useful but is_equal(a.src, b.src) hits:
-            // error: type checking has run into a recursive problem
-            is MalUserEx  -> a.src == (b as MalUserEx).src
+            is MalUserEx  -> is_equal(a.src, (b as MalUserEx).src)
             else -> throw MalCoreEx("Unknown type $a in is_equal (aka =)")
         }
     }
-    // Handle class when comparing lists & vectors.
+    // Handle case when comparing lists & vectors.
     else if (a is MalSeq && b is MalSeq) {
         compare_lists(a, b)
     }
     else {
         false
     }
+
 // In the case of equal length lists, each element of the list should be compared for equality and if they are the same return true, otherwise false.
-private fun compare_lists(a: MalSeq, b: MalSeq): Boolean {
-    if(a.atoms.count() == b.atoms.count())
-      return a.atoms.indices.all { v: Int -> is_equal(a.atoms[v], b.atoms[v]) }
-    else
-      return false
-}
+private fun compare_lists(a: MalSeq, b: MalSeq): Boolean =
+    a.atoms.count() == b.atoms.count() &&
+    a.atoms.indices.all { is_equal(a[it], b[it]) }
 
-// TODO Implement!
-private fun compare_maps(a: MalMap, b: MalMap) = a == b
+private fun compare_maps(a: MalMap, b: MalMap): Boolean =
+    a.pairs.size == b.pairs.size &&
+    a.pairs.all { (k, v) -> b.pairs.contains(k) && is_equal(v, b[k]) }
 
 private fun pr_str_core(seq: MalSeq) =
     seq.atoms.map { pr_str(it, print_readably=true) }.joinToString(" ")
@@ -51,7 +48,7 @@ private fun str_core(seq: MalSeq, joiner: String) =
 private val eof = ""
 
 object core {
-    val ns : Map<MalSymbol, MalFunc> = mutableMapOf(
+    val ns : Map<MalSymbol, MalFunc> = mapOf(
         // Basic number ops.
         malSym("+") to malFun("plus")  { int_ops_reducer(Int::plus,  it) },
         malSym("-") to malFun("minus") { int_ops_reducer(Int::minus, it) },
@@ -181,7 +178,7 @@ object core {
         to_fun("nth") {
             val seq = it[0] as MalSeq
             val idx = it[1] as MalNumber
-            seq[idx]
+            if (idx.num <= seq.atoms.lastIndex) seq[idx] else throw MalUserEx("the index ${idx} is out of bounds for ${pr_str(seq)}")
         },
         to_fun("first") {
             val v = it[0]
@@ -206,7 +203,7 @@ object core {
 
         to_fun("throw") {
             throw when(it.size) {
-                0    -> MalUserEx(MalString("error raised anon"))
+                0    -> MalUserEx("error raised anon")
                 else -> MalUserEx(it[0])
             }
         },
@@ -220,7 +217,7 @@ object core {
             val fn     = it[0]     as MalCallable
             val argSeq = it.last() as MalSeq
             val args   = it.atoms.slice(1 .. (if(it.size > 2) it.size - 2 else 0))
-            fn(malListOf(argSeq.atoms + args))
+            fn(malListOf(args + argSeq.atoms))
         },
         to_fun("map") {
             val fn   = it[0] as MalCallable
@@ -272,9 +269,13 @@ object core {
             MalMap(m.pairs - it.tail().atoms.map { it as MalKey })
         },
         to_fun("get") {
-            val m = it[0] as MalMap
+            val m = it[0]
             val k = it[1] as MalKey
-            m[k]
+            when(m) {
+                is MalMap -> m[k]
+                is MalNil -> m
+                else -> throw MalUserEx("Can't treat ${m} as a map")
+            }
         },
         to_fun("contains?") {
             val m = it[0] as MalMap

kotlin/src/mal/env.kt

@@ -34,7 +34,7 @@ class Env(val outer: Env? = null,
 
     // get: takes a symbol key and uses the find method to locate the environment with the key, then returns the matching value. If no key is found up the outer chain, then throws/raises a "not found" error.
     fun get(key: MalSymbol): MalType {
-        val env = find(key) ?: throw MalCoreEx("The symbol '${key.sym}' not found in env")
+        val env = find(key) ?: throw MalUserEx("'${key.sym}' not found")
         return env.data.getValue(key)
     }
 }

kotlin/src/mal/reader.kt

@@ -104,7 +104,7 @@ private fun read_atom(r: Reader, n: Int) : MalType {
 
 private fun make_map(pairs: List<MalType>) : MalMap {
     if(pairs.size % 2 != 0)
-        throw MalUserEx(MalString("maps requires an even number of items, got ${pairs.size} items"))
+        throw MalUserEx("maps requires an even number of items, got ${pairs.size} items")
 
     val map : MutableMap<MalKey, MalType> = mutableMapOf()
     for (idx in pairs.indices step 2) {

kotlin/src/mal/step9_try.kt

@@ -149,8 +149,7 @@ fun EVAL(cur_ast: MalType, cur_env: Env, depth: Int) : MalType {
                             // The return value from the fn* special form will now become an object/structure with attributes that allow the default invoke case of EVAL to do TCO on mal functions. Those attributes are:
                             val binds = rest[0] as MalSeq
                             val body  = rest[1]
-//                            val func  = malFun("funccall") 
-                            return MalUserFunc(body, binds, env) {
+                            return MalUserFunc(body, binds, env, "anon", MalNil()) {
                                 EVAL(body, Env(env, binds, it), n)
                             }
                         }

kotlin/src/mal/types.kt

@@ -90,7 +90,9 @@ class MalUserFunc(
         MalUserFunc(ast, params, env, name, m, func)
 }
 
-data class MalUserEx(val src: MalType) : Exception("Exception raised"), MalType
+data class MalUserEx(val src: MalType) : Exception("Exception raised"), MalType {
+    constructor(msg: String) : this(MalString(msg))
+}
 data class MalCoreEx(val msg: String) : Exception(msg)
 
 // Helper functions.