diff --git a/src/koans/01_equalities.clj b/src/koans/01_equalities.clj
index 8f76176..f40cf1b 100644
--- a/src/koans/01_equalities.clj
+++ b/src/koans/01_equalities.clj
@@ -1,36 +1,36 @@
 (ns koans.01-equalities
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "We shall contemplate truth by testing reality, via equality"
-  (= __ true)
+  (= true true)
 
   "To understand reality, we must compare our expectations against reality"
-  (= __ (+ 1 1))
+  (= 2 (+ 1 1))
 
   "You can test equality of many things"
-  (= (+ 3 4) 7 (+ 2 __))
+  (= (+ 3 4) 7 (+ 2 5))
 
   "Some things may appear different, but be the same"
-  (= __ (= 2 2/1))
+  (= true (= 2 2/1))
 
   "You cannot generally float to heavens of integers"
-  (= __ (= 2 2.0))
+  (= false (= 2 2.0))
 
   "But a looser equality is also possible"
-  (= __ (== 2.0 2))
+  (= true (== 2.0 2))
 
   "Something is not equal to nothing"
-  (= __ (not (= 1 nil)))
+  (= true (not (= 1 nil)))
 
   "Strings, and keywords, and symbols: oh my!"
-  (= __ (= "hello" :hello 'hello))
+  (= false (= "hello" :hello 'hello))
 
   "Make a keyword with your keyboard"
-  (= :hello (keyword __))
+  (= :hello (keyword "hello"))
 
   "Symbolism is all around us"
-  (= 'hello (symbol __))
+  (= 'hello (symbol "hello"))
 
   "When things cannot be equal, they must be different"
-  (not= :fill-in-the-blank __))
+  (not= :fill-in-the-blank 1))
\ No newline at end of file
diff --git a/src/koans/02_strings.clj b/src/koans/02_strings.clj
index 92f4817..59d863b 100644
--- a/src/koans/02_strings.clj
+++ b/src/koans/02_strings.clj
@@ -1,70 +1,70 @@
 (ns koans.02-strings
-  (:require [koan-engine.core :refer :all]
-            [clojure.string :as string]))
+    (:require [koan-engine.core :refer :all]
+      [clojure.string :as string]))
 
 (meditations
   "A string is nothing more than text surrounded by double quotes"
-  (= __ "hello")
+  (= "hello" "hello")
 
   "But double quotes are just magic on top of something deeper"
-  (= __ (str 'world))
+  (= "world" (str 'world))
 
   "You can do more than create strings, you can put them together"
-  (= "Cool right?" (str __ __))
+  (= "Cool right?" (str "Cool " "right?"))
 
   "You can even get certain characters"
-  (= \C (get "Characters" __))
+  (= \C (get "Characters" 0))
 
   "Or even count the characters"
-  (= __ (count "Hello World"))
+  (= 11 (count "Hello World"))
 
   "But strings and characters are not the same"
-  (= __ (= \c "c"))
+  (= false (= \c "c"))
 
   "What if you only wanted to get part of a string?"
-  (= "World" (subs "Hello World" __ __))
+  (= "World" (subs "Hello World" 6 11))
 
   "How about joining together elements in a list?"
-  (= __ (string/join '(1 2 3)))
+  (= "123" (string/join '(1 2 3)))
 
   "What if you wanted to separate them out?"
-  (= "1, 2, 3" (string/join __ '(1 2 3)))
+  (= "1, 2, 3" (string/join ", " '(1 2 3)))
 
   "Maybe you want to separate out all your lines"
-  (= [__ __ __] (string/split-lines "1\n2\n3"))
+  (= ["1" "2" "3"] (string/split-lines "1\n2\n3"))
 
   "You may want to make sure your words are backwards"
-  (= __ (string/reverse "hello"))
+  (= "olleh" (string/reverse "hello"))
 
   "Maybe you want to find the index of the first occurence of a substring"
-  (= 0 (.indexOf "hello world" __))
+  (= 0 (.indexOf "hello world" "h"))
 
   "Or maybe the last index of the same"
-  (= __ (.lastIndexOf "hello world, hello" "hello"))
+  (= 13 (.lastIndexOf "hello world, hello" "hello"))
 
   "But when something doesn't exist, it turns up negative"
-  (= __ (.indexOf "hello world" "bob"))
+  (= -1 (.indexOf "hello world" "bob"))
 
   "Sometimes you don't want whitespace cluttering the front and back"
-  (= __ (string/trim "  \nhello world \t \n"))
+  (= "hello world" (string/trim "  \nhello world \t \n"))
 
   "You can check if something is a char"
-  (= __ (char? \c))
+  (= true (char? \c))
 
   "But it may not be"
-  (= __ (char? "a"))
+  (= false (char? "a"))
 
   "But chars aren't strings"
-  (= __ (string? \b))
+  (= false (string? \b))
 
   "Strings are strings"
-  (= true (string? __))
+  (= true (string? "__"))
 
   "Some strings may be blank"
-  (= __ (string/blank? ""))
+  (= true (string/blank? ""))
 
   "Even if at first glance they aren't"
-  (= __ (string/blank? " \n \t  "))
+  (= true (string/blank? " \n \t  "))
 
   "However, most strings aren't blank"
-  (= __ (string/blank? "hello?\nare you out there?")))
+  (= false (string/blank? "hello?\nare you out there?")))
\ No newline at end of file
diff --git a/src/koans/03_lists.clj b/src/koans/03_lists.clj
index dbdf6f5..658355b 100644
--- a/src/koans/03_lists.clj
+++ b/src/koans/03_lists.clj
@@ -1,45 +1,45 @@
 (ns koans.03-lists
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "Lists can be expressed by function or a quoted form"
-  (= '(__ __ __ __ __) (list 1 2 3 4 5))
+  (= '(1 2 3 4 5) (list 1 2 3 4 5))
 
   "They are Clojure seqs (sequences), so they allow access to the first"
-  (= __ (first '(1 2 3 4 5)))
+  (= 1 (first '(1 2 3 4 5)))
 
   "As well as the rest"
-  (= __ (rest '(1 2 3 4 5)))
+  (= '(2 3 4 5) (rest '(1 2 3 4 5)))
 
   "Count your blessings"
-  (= __ (count '(dracula dooku chocula)))
+  (= 3 (count '(dracula dooku chocula)))
 
   "Before they are gone"
-  (= __ (count '()))
+  (= 0 (count '()))
 
   "The rest, when nothing is left, is empty"
-  (= __ (rest '(100)))
+  (= '() (rest '(100)))
 
   "Construction by adding an element to the front is easy"
-  (= __ (cons :a '(:b :c :d :e)))
+  (= '(:a :b :c :d :e) (cons :a '(:b :c :d :e)))
 
   "Conjoining an element to a list isn't hard either"
-  (= __ (conj '(:a :b :c :d) :e))
+  (= '(:e :a :b :c :d) (conj '(:a :b :c :d) :e))
 
   "You can use a list like a stack to get the first element"
-  (= __ (peek '(:a :b :c :d :e)))
+  (= :a (peek '(:a :b :c :d :e)))
 
   "Or the others"
-  (= __ (pop '(:a :b :c :d :e)))
+  (= '(:b :c :d :e) (pop '(:a :b :c :d :e)))
 
   "But watch out if you try to pop nothing"
-  (= __ (try
-          (pop '())
-          (catch IllegalStateException e
-            "No dice!")))
+  (= "No dice!" (try
+                  (pop '())
+                  (catch IllegalStateException e
+                    "No dice!")))
 
   "The rest of nothing isn't so strict"
-  (= __ (try
-          (rest '())
-          (catch IllegalStateException e
-            "No dice!"))))
+  (= '() (try
+           (rest '())
+           (catch IllegalStateException e
+             "No dice!"))))
\ No newline at end of file
diff --git a/src/koans/04_vectors.clj b/src/koans/04_vectors.clj
index 71970f6..290edca 100644
--- a/src/koans/04_vectors.clj
+++ b/src/koans/04_vectors.clj
@@ -1,33 +1,33 @@
 (ns koans.04-vectors
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "You can use vectors in clojure as array-like structures"
-  (= __ (count [42]))
+  (= 1 (count [42]))
 
   "You can create a vector from a list"
-  (= __ (vec '(1)))
+  (= [1] (vec '(1)))
 
   "Or from some elements"
-  (= __ (vector nil nil))
+  (= [nil nil] (vector nil nil))
 
   "But you can populate it with any number of elements at once"
-  (= [1 __] (vec '(1 2)))
+  (= [1 2] (vec '(1 2)))
 
   "Conjoining to a vector is different than to a list"
-  (= __ (conj [111 222] 333))
+  (= [111 222 333] (conj [111 222] 333))
 
   "You can get the first element of a vector like so"
-  (= __ (first [:peanut :butter :and :jelly]))
+  (= :peanut (first [:peanut :butter :and :jelly]))
 
   "And the last in a similar fashion"
-  (= __ (last [:peanut :butter :and :jelly]))
+  (= :jelly (last [:peanut :butter :and :jelly]))
 
   "Or any index if you wish"
-  (= __ (nth [:peanut :butter :and :jelly] 3))
+  (= :jelly (nth [:peanut :butter :and :jelly] 3))
 
   "You can also slice a vector"
-  (= __ (subvec [:peanut :butter :and :jelly] 1 3))
+  (= [:butter :and] (subvec [:peanut :butter :and :jelly] 1 3))
 
   "Equality with collections is in terms of values"
-  (= (list 1 2 3) (vector 1 2 __)))
+  (= (list 1 2 3) (vector 1 2 3)))
\ No newline at end of file
diff --git a/src/koans/05_sets.clj b/src/koans/05_sets.clj
index a6e631f..01e0e13 100644
--- a/src/koans/05_sets.clj
+++ b/src/koans/05_sets.clj
@@ -1,22 +1,22 @@
 (ns koans.05-sets
-  (:require [koan-engine.core :refer :all]
-            [clojure.set :as set]))
+    (:require [koan-engine.core :refer :all]
+      [clojure.set :as set]))
 
 (meditations
   "You can create a set by converting another collection"
-  (= #{3} (set __))
+  (= #{3} (set [3]))
 
   "Counting them is like counting other collections"
-  (= __ (count #{1 2 3}))
+  (= 3 (count #{1 2 3}))
 
   "Remember that a set is a *mathematical* set"
-  (= __ (set '(1 1 2 2 3 3 4 4 5 5)))
+  (= #{1 2 3 4 5} (set '(1 1 2 2 3 3 4 4 5 5)))
 
   "You can ask clojure for the union of two sets"
-  (= __ (set/union #{1 2 3 4} #{2 3 5}))
+  (= #{1 2 3 4 5} (set/union #{1 2 3 4} #{2 3 5}))
 
   "And also the intersection"
-  (= __ (set/intersection #{1 2 3 4} #{2 3 5}))
+  (= #{2 3} (set/intersection #{1 2 3 4} #{2 3 5}))
 
   "But don't forget about the difference"
-  (= __ (set/difference #{1 2 3 4 5} #{2 3 5})))
+  (= #{1 4} (set/difference #{1 2 3 4 5} #{2 3 5})))
\ No newline at end of file
diff --git a/src/koans/06_maps.clj b/src/koans/06_maps.clj
index 3466864..af66ce4 100644
--- a/src/koans/06_maps.clj
+++ b/src/koans/06_maps.clj
@@ -1,50 +1,50 @@
 (ns koans.06-maps
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "Don't get lost when creating a map"
-  (= {:a 1 :b 2} (hash-map :a 1 __ __))
+  (= {:a 1 :b 2} (hash-map :a 1 :b 2))
 
   "A value must be supplied for each key"
-  (= {:a 1} (hash-map :a __))
+  (= {:a 1} (hash-map :a 1))
 
   "The size is the number of entries"
-  (= __ (count {:a 1 :b 2}))
+  (= 2 (count {:a 1 :b 2}))
 
   "You can look up the value for a given key"
-  (= __ (get {:a 1 :b 2} :b))
+  (= 2 (get {:a 1 :b 2} :b))
 
   "Maps can be used as functions to do lookups"
-  (= __ ({:a 1 :b 2} :a))
+  (= 1 ({:a 1 :b 2} :a))
 
   "And so can keywords"
-  (= __ (:a {:a 1 :b 2}))
+  (= 1 (:a {:a 1 :b 2}))
 
   "But map keys need not be keywords"
-  (= __ ({2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"} 2014))
+  (= "Sochi" ({2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"} 2014))
 
   "You may not be able to find an entry for a key"
-  (= __ (get {:a 1 :b 2} :c))
+  (= nil (get {:a 1 :b 2} :c))
 
   "But you can provide your own default"
-  (= __ (get {:a 1 :b 2} :c :key-not-found))
+  (= :key-not-found (get {:a 1 :b 2} :c :key-not-found))
 
   "You can find out if a key is present"
-  (= __ (contains? {:a nil :b nil} :b))
+  (= true (contains? {:a nil :b nil} :b))
 
   "Or if it is missing"
-  (= __ (contains? {:a nil :b nil} :c))
+  (= false (contains? {:a nil :b nil} :c))
 
   "Maps are immutable, but you can create a new and improved version"
-  (= {1 "January" 2 __} (assoc {1 "January"} 2 "February"))
+  (= {1 "January" 2 "February"} (assoc {1 "January"} 2 "February"))
 
   "You can also create a new version with an entry removed"
-  (= {__ __} (dissoc {1 "January" 2 "February"} 2))
+  (= {1 "January"} (dissoc {1 "January" 2 "February"} 2))
 
   "Often you will need to get the keys, but the order is undependable"
-  (= (list __ __ __)
+  (= (list 2010 2014 2018)
      (sort (keys { 2014 "Sochi" 2018 "PyeongChang" 2010 "Vancouver"})))
 
   "You can get the values in a similar way"
-  (= (list __ __ __)
-     (sort (vals {2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"}))))
+  (= (list "PyeongChang" "Sochi" "Vancouver")
+     (sort (vals {2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"}))))
\ No newline at end of file
diff --git a/src/koans/07_functions.clj b/src/koans/07_functions.clj
index 4bf40a0..ab9917e 100644
--- a/src/koans/07_functions.clj
+++ b/src/koans/07_functions.clj
@@ -1,40 +1,40 @@
 (ns koans.07-functions
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (defn multiply-by-ten [n]
-  (* 10 n))
+      (* 10 n))
 
 (defn square [n] (* n n))
 
 (meditations
   "Calling a function is like giving it a hug with parentheses"
-  (= __ (square 9))
+  (= 81 (square 9))
 
   "Functions are usually defined before they are used"
-  (= __ (multiply-by-ten 2))
+  (= 20 (multiply-by-ten 2))
 
   "But they can also be defined inline"
-  (= __ ((fn [n] (* 5 n)) 2))
+  (= 10 ((fn [n] (* 5 n)) 2))
 
   "Or using an even shorter syntax"
-  (= __ (#(* 15 %) 4))
+  (= 60 (#(* 15 %) 4))
 
   "Even anonymous functions may take multiple arguments"
-  (= __ (#(+ %1 %2 %3) 4 5 6))
+  (= 15 (#(+ %1 %2 %3) 4 5 6))
 
   "Arguments can also be skipped"
-  (= __ (#(* 15 %2) 1 2))
+  (= 30 (#(* 15 %2) 1 2))
 
   "One function can beget another"
-  (= 9 (((fn [] ___)) 4 5))
+  (= 9 (((fn [] #(+ %1 %2))) 4 5))
 
   "Functions can also take other functions as input"
   (= 20 ((fn [f] (f 4 5))
-           ___))
+          *))
 
   "Higher-order functions take function arguments"
-  (= 25 (___
+  (= 25 ((fn [f] (f 5))
           (fn [n] (* n n))))
 
   "But they are often better written using the names of functions"
-  (= 25 (___ square)))
+  (= 25 ((fn [f] (f 5)) square)))
\ No newline at end of file
diff --git a/src/koans/08_conditionals.clj b/src/koans/08_conditionals.clj
index 87b9fdf..9dab1ac 100644
--- a/src/koans/08_conditionals.clj
+++ b/src/koans/08_conditionals.clj
@@ -1,47 +1,47 @@
 (ns koans.08-conditionals
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (defn explain-exercise-velocity [exercise-term]
-  (case exercise-term
-        :bicycling        "pretty fast"
-        :jogging          "not super fast"
-        :walking          "not fast at all"
-        "is that even exercise?"))
+      (case exercise-term
+            :bicycling        "pretty fast"
+            :jogging          "not super fast"
+            :walking          "not fast at all"
+            "is that even exercise?"))
 
 (meditations
   "You will face many decisions"
-  (= __ (if (false? (= 4 5))
+  (= :a (if (false? (= 4 5))
           :a
           :b))
 
   "Some of them leave you no alternative"
-  (= __ (if (> 4 3)
+  (= [] (if (> 4 3)
           []))
 
   "And in such a situation you may have nothing"
-  (= __ (if (nil? 0)
-          [:a :b :c]))
+  (= nil (if (nil? 0)
+           [:a :b :c]))
 
   "In others your alternative may be interesting"
   (= :glory (if (not (empty? ()))
               :doom
-              __))
+              :glory))
 
   "You may have a multitude of possible paths"
   (let [x 5]
-    (= :your-road (cond (= x __) :road-not-taken
-                        (= x __) :another-road-not-taken
-                        :else __)))
+       (= :your-road (cond (= x __) :road-not-taken
+                           (= x __) :another-road-not-taken
+                           :else :your-road)))
 
   "Or your fate may be sealed"
-  (= 'doom (if-not (zero? __)
-          'doom
-          'more-doom))
+  (= 'doom (if-not (zero? 1)
+                   'doom
+                   'more-doom))
 
   "In case of emergency, go fast"
   (= "pretty fast"
-     (explain-exercise-velocity __))
+     (explain-exercise-velocity :bicycling))
 
   "But admit it when you don't know what to do"
-  (= __
-     (explain-exercise-velocity :watching-tv)))
+  (= "is that even exercise?"
+     (explain-exercise-velocity :watching-tv)))
\ No newline at end of file
diff --git a/src/koans/09_higher_order_functions.clj b/src/koans/09_higher_order_functions.clj
index 8b7fd3c..6949379 100644
--- a/src/koans/09_higher_order_functions.clj
+++ b/src/koans/09_higher_order_functions.clj
@@ -1,35 +1,35 @@
 (ns koans.09-higher-order-functions
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "The map function relates a sequence to another"
-  (= [__ __ __] (map (fn [x] (* 4 x)) [1 2 3]))
+  (= [4 8 12] (map (fn [x] (* 4 x)) [1 2 3]))
 
   "You may create that mapping"
-  (= [1 4 9 16 25] (map (fn [x] __) [1 2 3 4 5]))
+  (= [1 4 9 16 25] (map (fn [x] (* x x)) [1 2 3 4 5]))
 
   "Or use the names of existing functions"
-  (= __ (map nil? [:a :b nil :c :d]))
+  (= [false false true false false] (map nil? [:a :b nil :c :d]))
 
   "A filter can be strong"
-  (= __ (filter (fn [x] false) '(:anything :goes :here)))
+  (= '() (filter (fn [x] false) '(:anything :goes :here)))
 
   "Or very weak"
-  (= __ (filter (fn [x] true) '(:anything :goes :here)))
+  (= '(:anything :goes :here) (filter (fn [x] true) '(:anything :goes :here)))
 
   "Or somewhere in between"
-  (= [10 20 30] (filter (fn [x] __) [10 20 30 40 50 60 70 80]))
+  (= [10 20 30] (filter (fn [x] (< x 35)) [10 20 30 40 50 60 70 80]))
 
   "Maps and filters may be combined"
-  (= [10 20 30] (map (fn [x] __) (filter (fn [x] __) [1 2 3 4 5 6 7 8])))
+  (= [10 20 30] (map (fn [x] (* x 10)) (filter (fn [x] (< x 4)) [1 2 3 4 5 6 7 8])))
 
   "Reducing can increase the result"
-  (= __ (reduce (fn [a b] (* a b)) [1 2 3 4]))
+  (= 24 (reduce (fn [a b] (* a b)) [1 2 3 4]))
 
   "You can start somewhere else"
-  (= 2400 (reduce (fn [a b] (* a b)) __ [1 2 3 4]))
+  (= 2400 (reduce (fn [a b] (* a b)) 100 [1 2 3 4]))
 
   "Numbers are not the only things one can reduce"
   (= "longest" (reduce (fn [a b]
-                         (if (< __ __) b a))
-                       ["which" "word" "is" "longest"])))
+                           (if (< (count a) (count b)) b a))
+                       ["which" "word" "is" "longest"])))
\ No newline at end of file
diff --git a/src/koans/10_runtime_polymorphism.clj b/src/koans/10_runtime_polymorphism.clj
index 8be1c6a..1e66560 100644
--- a/src/koans/10_runtime_polymorphism.clj
+++ b/src/koans/10_runtime_polymorphism.clj
@@ -1,28 +1,28 @@
 (ns koans.10-runtime-polymorphism
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (defn hello
-  ([] "Hello World!")
-  ([a] (str "Hello, you silly " a "."))
-  ([a & more] (str "Hello to this group: "
-                   (apply str
-                          (interpose ", " (cons a more)))
-                   "!")))
+      ([] "Hello World!")
+      ([a] (str "Hello, you silly " a "."))
+      ([a & more] (str "Hello to this group: "
+                       (apply str
+                              (interpose ", " (cons a more)))
+                       "!")))
 
 (defmulti diet (fn [x] (:eater x)))
-(defmethod diet :herbivore [a] __)
-(defmethod diet :carnivore [a] __)
-(defmethod diet :default [a] __)
+(defmethod diet :herbivore [a] (str (:name a) " eats veggies."))
+(defmethod diet :carnivore [a] (str (:name a) " eats animals."))
+(defmethod diet :default [a] (str "I don't know what " (:name a) " eats."))
 
 (meditations
   "Some functions can be used in different ways - with no arguments"
-  (= __ (hello))
+  (= "Hello World!" (hello))
 
   "With one argument"
-  (= __ (hello "world"))
+  (= "Hello, you silly world." (hello "world"))
 
   "Or with many arguments"
-  (= __
+  (= "Hello to this group: Peter, Paul, Mary!"
      (hello "Peter" "Paul" "Mary"))
 
   "Multimethods allow more complex dispatching"
@@ -39,4 +39,4 @@
 
   "You may use a default method when no others match"
   (= "I don't know what Rich Hickey eats."
-     (diet {:name "Rich Hickey"})))
+     (diet {:name "Rich Hickey"})))
\ No newline at end of file
diff --git a/src/koans/11_lazy_sequences.clj b/src/koans/11_lazy_sequences.clj
index 1023785..0903636 100644
--- a/src/koans/11_lazy_sequences.clj
+++ b/src/koans/11_lazy_sequences.clj
@@ -1,28 +1,28 @@
 (ns koans.11-lazy-sequences
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "There are many ways to generate a sequence"
-  (= __ (range 1 5))
+  (= '(1 2 3 4) (range 1 5))
 
   "The range starts at the beginning by default"
-  (= __ (range 5))
+  (= '(0 1 2 3 4) (range 5))
 
   "Only take what you need when the sequence is large"
   (= [0 1 2 3 4 5 6 7 8 9]
-     (take __ (range 100)))
+     (take 10 (range 100)))
 
   "Or limit results by dropping what you don't need"
   (= [95 96 97 98 99]
-     (drop __ (range 100)))
+     (drop 95 (range 100)))
 
   "Iteration provides an infinite lazy sequence"
-  (= __ (take 20 (iterate inc 0)))
+  (= '(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19) (take 20 (iterate inc 0)))
 
   "Repetition is key"
   (= [:a :a :a :a :a :a :a :a :a :a]
-     (repeat 10 __))
+     (repeat 10 :a))
 
   "Iteration can be used for repetition"
   (= (repeat 100 :hello)
-     (take 100 (iterate ___ :hello))))
+     (take 100 (iterate conj :hello))))
\ No newline at end of file
diff --git a/src/koans/12_sequence_comprehensions.clj b/src/koans/12_sequence_comprehensions.clj
index f131e1a..b152e02 100644
--- a/src/koans/12_sequence_comprehensions.clj
+++ b/src/koans/12_sequence_comprehensions.clj
@@ -1,31 +1,31 @@
 (ns koans.12-sequence-comprehensions
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "Sequence comprehensions can bind each element in turn to a symbol"
-  (= __
+  (= '(0 1 2 3 4 5)
      (for [x (range 6)]
-       x))
+          x))
 
   "They can easily emulate mapping"
   (= '(0 1 4 9 16 25)
      (map (fn [x] (* x x))
           (range 6))
      (for [x (range 6)]
-       __))
+          (* x x)))
 
   "And also filtering"
   (= '(1 3 5 7 9)
      (filter odd? (range 10))
-     (for [x __ :when (odd? x)]
-       x))
+     (for [x (range 10) :when (odd? x)]
+          x))
 
   "Combinations of these transformations is trivial"
   (= '(1 9 25 49 81)
      (map (fn [x] (* x x))
           (filter odd? (range 10)))
-     (for [x (range 10) :when __]
-       __))
+     (for [x (range 10) :when (odd? x)]
+          (* x x)))
 
   "More complex transformations simply take multiple binding forms"
   (= [[:top :left] [:top :middle] [:top :right]
@@ -33,4 +33,4 @@
       [:bottom :left] [:bottom :middle] [:bottom :right]]
      (for [row [:top :middle :bottom]
            column [:left :middle :right]]
-       __)))
+          [row column])))
\ No newline at end of file
diff --git a/src/koans/13_creating_functions.clj b/src/koans/13_creating_functions.clj
index 7d84bc8..2709e4c 100644
--- a/src/koans/13_creating_functions.clj
+++ b/src/koans/13_creating_functions.clj
@@ -1,35 +1,35 @@
 (ns koans.13-creating-functions
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (defn square [x] (* x x))
 
 (meditations
-  "One may know what they seek by knowing what they do not seek"
-  (= [__ __ __] (let [not-a-symbol? (complement symbol?)]
-                  (map not-a-symbol? [:a 'b "c"])))
+  "One may know what they seek by knowing what they do not seek" ;I like this!
+  (= [true false true] (let [not-a-symbol? (complement symbol?)]
+                            (map not-a-symbol? [:a 'b "c"])))
 
   "Praise and 'complement' may help you separate the wheat from the chaff"
   (= [:wheat "wheat" 'wheat]
-       (let [not-nil? ___]
-         (filter not-nil? [nil :wheat nil "wheat" nil 'wheat nil])))
+     (let [not-nil? (complement nil?)]
+          (filter not-nil? [nil :wheat nil "wheat" nil 'wheat nil])))
 
   "Partial functions allow procrastination"
-  (= 20 (let [multiply-by-5 (partial * 5)]
-          (___ __)))
+  (= 20 (let [multiply-by-5 (partial * 5)]                  ;awesome!
+             (multiply-by-5 4)))
 
   "Don't forget: first things first"
-  (= [__ __ __ __]
-       (let [ab-adder (partial concat [:a :b])]
-         (ab-adder [__ __])))
+  (= [:a :b :c :d]
+     (let [ab-adder (partial concat [:a :b])]
+          (ab-adder [:c :d])))
 
   "Functions can join forces as one 'composed' function"
   (= 25 (let [inc-and-square (comp square inc)]
-          (inc-and-square __)))
+             (inc-and-square 4)))
 
   "Have a go on a double dec-er"
-  (= __ (let [double-dec (comp dec dec)]
-          (double-dec 10)))
+  (= 8 (let [double-dec (comp dec dec)]
+            (double-dec 10)))
 
   "Be careful about the order in which you mix your functions"
-  (= 99 (let [square-and-dec ___]
-          (square-and-dec 10))))
+  (= 99 (let [square-and-dec (comp dec square)]
+             (square-and-dec 10))))
\ No newline at end of file
diff --git a/src/koans/14_recursion.clj b/src/koans/14_recursion.clj
index 4c39666..590a0a8 100644
--- a/src/koans/14_recursion.clj
+++ b/src/koans/14_recursion.clj
@@ -1,23 +1,31 @@
 (ns koans.14-recursion
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (defn is-even? [n]
-  (if (= n 0)
-    __
-    (___ (is-even? (dec n)))))
+      (if (= n 0)
+        true
+        (not (is-even? (dec n)))))
 
 (defn is-even-bigint? [n]
-  (loop [n   n
-         acc true]
-    (if (= n 0)
-      __
-      (recur (dec n) (not acc)))))
+      (loop [n   n
+             acc true]
+            (if (= n 0)
+              acc
+              (recur (dec n) (not acc)))))
 
 (defn recursive-reverse [coll]
-  __)
+      (loop [l '()
+             coll coll]
+            (if (= (count coll) 0)
+              l
+              (recur (conj l (first coll)) (rest coll)))))
 
 (defn factorial [n]
-  __)
+      (loop [sum 1
+             n n]
+            (if (= n 1)
+              sum
+              (recur (* sum n) (dec n)))))
 
 (meditations
   "Recursion ends with a base case"
@@ -51,4 +59,4 @@
   (< 1000000000000000000000000N (factorial 1000N))
 
   "But what happens when the machine limits you?"
-  (< 1000000000000000000000000N (factorial 100003N)))
+  (< 1000000000000000000000000N (factorial 100003N)))
\ No newline at end of file
diff --git a/src/koans/15_destructuring.clj b/src/koans/15_destructuring.clj
index 32fc983..cbc4855 100644
--- a/src/koans/15_destructuring.clj
+++ b/src/koans/15_destructuring.clj
@@ -1,5 +1,5 @@
 (ns koans.15-destructuring
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (def test-address
   {:street-address "123 Test Lane"
@@ -8,37 +8,41 @@
 
 (meditations
   "Destructuring is an arbiter: it breaks up arguments"
-  (= __ ((fn [[a b]] (str b a))
-         [:foo :bar]))
+  (= ":bar:foo" ((fn [[a b]] (str b a))
+                  [:foo :bar]))
 
   "Whether in function definitions"
   (= (str "An Oxford comma list of apples, "
           "oranges, "
           "and pears.")
-     ((fn [[a b c]] __)
-      ["apples" "oranges" "pears"]))
+     ((fn [[a b c]] (str "An Oxford comma list of " a ", " b ", and " c "."))
+       ["apples" "oranges" "pears"]))
 
   "Or in let expressions"
   (= "Rich Hickey aka The Clojurer aka Go Time aka Lambda Guru"
      (let [[first-name last-name & aliases]
            (list "Rich" "Hickey" "The Clojurer" "Go Time" "Lambda Guru")]
-       __))
+          (str first-name " " last-name " aka " (reduce #(str %1 " aka " %2) aliases))))
 
   "You can regain the full argument if you like arguing"
   (= {:original-parts ["Stephen" "Hawking"] :named-parts {:first "Stephen" :last "Hawking"}}
      (let [[first-name last-name :as full-name] ["Stephen" "Hawking"]]
-       __))
+          {:original-parts full-name
+           :named-parts {:first first-name :last last-name}}))
 
   "Break up maps by key"
   (= "123 Test Lane, Testerville, TX"
      (let [{street-address :street-address, city :city, state :state} test-address]
-       __))
+          (str street-address ", " city ", " state)))
 
   "Or more succinctly"
   (= "123 Test Lane, Testerville, TX"
-     (let [{:keys [street-address __ __]} test-address]
-       __))
+     (let [{:keys [street-address city state]} test-address]
+          (str street-address ", " city ", " state)))
 
   "All together now!"
   (= "Test Testerson, 123 Test Lane, Testerville, TX"
-     (___ ["Test" "Testerson"] test-address)))
+     (#(str (apply str (interpose " " %1))
+            (let [{:keys [street-address city state]} %2]
+                 (str ", " street-address ", " city ", " state)))
+       ["Test" "Testerson"] test-address)))
\ No newline at end of file
diff --git a/src/koans/16_refs.clj b/src/koans/16_refs.clj
index 3395f29..1784cb9 100644
--- a/src/koans/16_refs.clj
+++ b/src/koans/16_refs.clj
@@ -1,42 +1,43 @@
 (ns koans.16-refs
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (def the-world (ref "hello"))
 (def bizarro-world (ref {}))
 
 (meditations
   "In the beginning, there was a word"
-  (= __ (deref the-world))
+  (= "hello" (deref the-world))
 
   "You can get the word more succinctly, but it's the same"
-  (= __ @the-world)
+  (= "hello" @the-world)
 
-  "You can be the change you wish to see in the world."
-  (= __ (do
-          (dosync (ref-set the-world "better"))
-          @the-world))
+  "You can be the change you wish to see in the world."     ;like it
+  (= "better" (do
+                (dosync (ref-set the-world "better"))
+                @the-world))
 
   "Alter where you need not replace"
-  (= __ (let [exclamator (fn [x] (str x "!"))]
-          (dosync
-           (alter the-world exclamator)
-           (alter the-world exclamator)
-           (alter the-world exclamator))
-          @the-world))
+  (= "better!!!" (let [exclamator (fn [x] (str x "!"))]
+                      (dosync
+                        (alter the-world exclamator)
+                        (alter the-world exclamator)
+                        (alter the-world exclamator))
+                      @the-world))
 
   "Don't forget to do your work in a transaction!"
-  (= 0 (do __
+  (= 0 (do (dosync
+             (ref-set the-world 0))
            @the-world))
 
   "Functions passed to alter may depend on the data in the ref"
   (= 20 (do
-          (dosync (alter the-world ___))))
+          (dosync (alter the-world + 20))))
 
   "Two worlds are better than one"
   (= ["Real Jerry" "Bizarro Jerry"]
-       (do
-         (dosync
-          (ref-set the-world {})
-          (alter the-world assoc :jerry "Real Jerry")
-          (alter bizarro-world assoc :jerry "Bizarro Jerry")
-          __))))
+     (do
+       (dosync
+         (ref-set the-world {})
+         (alter the-world assoc :jerry "Real Jerry")
+         (alter bizarro-world assoc :jerry "Bizarro Jerry")
+         (vec [(:jerry @the-world) (:jerry @bizarro-world)])))))
\ No newline at end of file
diff --git a/src/koans/17_atoms.clj b/src/koans/17_atoms.clj
index 17d92dd..e9916ea 100644
--- a/src/koans/17_atoms.clj
+++ b/src/koans/17_atoms.clj
@@ -1,33 +1,36 @@
 (ns koans.17-atoms
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (def atomic-clock (atom 0))
 
 (meditations
   "Atoms are like refs"
-  (= __ @atomic-clock)
+  (= 0 @atomic-clock)
 
   "You can change at the swap meet"
-  (= __ (do
-          (swap! atomic-clock inc)
-          @atomic-clock))
+  (= 1 (do
+         (swap! atomic-clock inc)
+         @atomic-clock))
 
   "Keep taxes out of this: swapping requires no transaction"
   (= 5 (do
-         __
+         (swap! atomic-clock inc)
+         (swap! atomic-clock inc)
+         (swap! atomic-clock inc)
+         (swap! atomic-clock inc)
          @atomic-clock))
 
   "Any number of arguments might happen during a swap"
-  (= __ (do
+  (= 20 (do
           (swap! atomic-clock + 1 2 3 4 5)
           @atomic-clock))
 
   "Atomic atoms are atomic"
-  (= __ (do
+  (= 20 (do
           (compare-and-set! atomic-clock 100 :fin)
           @atomic-clock))
 
   "When your expectations are aligned with reality, things proceed that way"
   (= :fin (do
-            (compare-and-set! __ __ __)
-            @atomic-clock)))
+            (compare-and-set! atomic-clock 20 :fin)
+            @atomic-clock)))
\ No newline at end of file
diff --git a/src/koans/18_macros.clj b/src/koans/18_macros.clj
index 931dc75..759627c 100644
--- a/src/koans/18_macros.clj
+++ b/src/koans/18_macros.clj
@@ -1,45 +1,45 @@
 (ns koans.18-macros
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (defmacro hello [x]
-  (str "Hello, " x))
+          (str "Hello, " x))
 
 (defmacro infix [form]
-  (list (second form) (first form) (nth form 2)))
+          (list (second form) (first form) (nth form 2)))
 
 (defmacro infix-better [form]
-  `(~(second form) ; Note the syntax-quote (`) and unquote (~) characters!
-    __
-    __ ))
+          `(~(second form) ; Note the syntax-quote (`) and unquote (~) characters!
+             ~(first form)
+             ~(nth form 2)))
 
 (defmacro r-infix [form]
-  (cond (not (seq? form))
-        __
-        (= 1 (count form))
-        `(r-infix ~(first form))
-        :else
-        (let [operator (second form)
-              first-arg (first form)
-              others __]
-          `(~operator
-            (r-infix ~first-arg)
-            (r-infix ~others)))))
+          (cond (not (seq? form))
+                form
+                (= 1 (count form))
+                `(r-infix ~(first form))
+                :else
+                (let [operator (second form)
+                      first-arg (first form)
+                      others (rest (rest form))]
+                     `(~operator
+                        (r-infix ~first-arg)
+                        (r-infix ~others)))))
 
 (meditations
   "Macros are like functions created at compile time"
-  (= __ (hello "Macros!"))
+  (= "Hello, Macros!" (hello "Macros!"))
 
   "I can haz infix?"
-  (= __ (infix (9 + 1)))
+  (= (+ 9 1) (infix (9 + 1)))
 
   "Remember, these are nothing but code transformations"
-  (= __ (macroexpand '(infix (9 + 1))))
+  (= '(+ 9 1) (macroexpand '(infix (9 + 1))))
 
   "You can do better than that - hand crafting FTW!"
-  (= __ (macroexpand '(infix-better (10 * 2))))
+  (= '(* 10 2) (macroexpand '(infix-better (10 * 2))))
 
   "Things don't always work as you would like them to... "
-  (= __ (macroexpand '(infix-better ( 10 + (2 * 3)))))
+  (= '(+ 10 (2 * 3)) (macroexpand '(infix-better ( 10 + (2 * 3)))))
 
   "Really, you don't understand recursion until you understand recursion"
-  (= 36 (r-infix (10 + (2 * 3) + (4 * 5)))))
+  (= 36 (r-infix (10 + (2 * 3) + (4 * 5)))))
\ No newline at end of file
diff --git a/src/koans/19_datatypes.clj b/src/koans/19_datatypes.clj
index d6eb31f..adfd8b5 100644
--- a/src/koans/19_datatypes.clj
+++ b/src/koans/19_datatypes.clj
@@ -1,47 +1,50 @@
 (ns koans.19-datatypes
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (defrecord Nobel [prize])
 (deftype Pulitzer [prize])
 
 (defprotocol Award
-  (present [this recipient]))
+             (present [this recipient]))
 
 (defrecord Oscar [category]
-  Award
-  (present [this recipient]
-    (print (str "Congratulations on your "
-                (:category this) " Oscar, "
-                recipient
-                "!"))))
+           Award
+           (present [this recipient]
+                    (print (str "Congratulations on your "
+                                (:category this) " Oscar, "
+                                recipient
+                                "!"))))
 
 (deftype Razzie [category]
-  Award
-  (present [this recipient]
-    __))
+         Award
+         (present [this recipient]
+                  (print (str "You're really the "
+                              (.category this) ", "
+                              recipient
+                              "... sorry."))))
 
 (meditations
   "Holding records is meaningful only when the record is worthy of you"
-  (= __ (.prize (Nobel. "peace")))
+  (= "peace" (.prize (Nobel. "peace")))
 
   "Types are quite similar"
-  (= __ (.prize (Pulitzer. "literature")))
+  (= "literature" (.prize (Pulitzer. "literature")))
 
   "Records may be treated like maps"
-  (= __ (:prize (Nobel. "physics")))
+  (= "physics" (:prize (Nobel. "physics")))
 
   "While types may not"
-  (= __ (:prize (Pulitzer. "poetry")))
+  (= nil (:prize (Pulitzer. "poetry")))
 
   "Further study reveals why"
-  (= __
+  (= [true false]
      (map map? [(Nobel. "chemistry")
                 (Pulitzer. "music")]))
 
   "Either sort of datatype can define methods in a protocol"
-  (= __
+  (= "Congratulations on your Best Picture Oscar, Evil Alien Conquerors!"
      (with-out-str (present (Oscar. "Best Picture") "Evil Alien Conquerors")))
 
   "Surely we can implement our own by now"
   (= "You're really the Worst Picture, Final Destination 5... sorry."
-     (with-out-str (present (Razzie. "Worst Picture") "Final Destination 5"))))
+     (with-out-str (present (Razzie. "Worst Picture") "Final Destination 5"))))
\ No newline at end of file
diff --git a/src/koans/20_java_interop.clj b/src/koans/20_java_interop.clj
index 8a7a6e2..0d21caf 100644
--- a/src/koans/20_java_interop.clj
+++ b/src/koans/20_java_interop.clj
@@ -1,19 +1,19 @@
 (ns koans.20-java-interop
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "You may have done more with Java than you know"
-  (= __ (class "warfare")) ; hint: try typing (javadoc "warfare") in the REPL
+  (= String (class "warfare")) ; hint: try typing (javadoc "warfare") in the REPL
 
   "The dot signifies easy and direct Java interoperation"
-  (= __ (.toUpperCase "select * from"))
+  (= "SELECT * FROM" (.toUpperCase "select * from"))
 
   "But instance method calls are very different from normal functions"
-  (= ["SELECT" "FROM" "WHERE"] (map ___ ["select" "from" "where"]))
+  (= ["SELECT" "FROM" "WHERE"] (map #(.toUpperCase %) ["select" "from" "where"]))
 
   "Constructing might be harder than breaking"
-  (= 10 (let [latch (java.util.concurrent.CountDownLatch. __)]
-          (.getCount latch)))
+  (= 10 (let [latch (java.util.concurrent.CountDownLatch. 10)]
+             (.getCount latch)))
 
   "Static methods are slashing prices!"
-  (== __ (Math/pow 2 10)))
+  (== 1024 (Math/pow 2 10)))
\ No newline at end of file
diff --git a/src/koans/21_partition.clj b/src/koans/21_partition.clj
index 1a65620..c8809e2 100644
--- a/src/koans/21_partition.clj
+++ b/src/koans/21_partition.clj
@@ -1,21 +1,21 @@
 (ns koans.21-partition
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (meditations
   "To split a collection you can use the partition function"
-  (= '((0 1) (2 3)) (__ 2 (range 4)))
+  (= '((0 1) (2 3)) (partition 2 (range 4)))
 
   "But watch out if there are not enough elements to form n sequences"
-  (= '(__) (partition 3 [:a :b :c :d :e]))
+  (= '((:a :b :c)) (partition 3 [:a :b :c :d :e]))
 
   "You can use partition-all to also get partitions with less than n elements"
-  (= __ (partition-all 3 (range 5)))
+  (= '((0 1 2) (3 4)) (partition-all 3 (range 5)))
 
   "If you need to, you can start each sequence with an offset"
-  (= '((0 1 2) (5 6 7) (10 11 12)) (partition 3 __ (range 13)))
+  (= '((0 1 2) (5 6 7) (10 11 12)) (partition 3 5 (range 13)))
 
   "Consider padding the last sequence with some default values..."
-  (= '((0 1 2) (3 4 5) (6 :hello)) (partition 3 3 [__] (range 7)))
+  (= '((0 1 2) (3 4 5) (6 :hello)) (partition 3 3 [:hello] (range 7)))
 
   "... but notice that they will only pad up to the given sequence length"
-  (= '((0 1 2) (3 4 5) __) (partition 3 3 [:these :are "my" "words"] (range 7))))
+  (= '((0 1 2) (3 4 5) (6 :these :are)) (partition 3 3 [:these :are "my" "words"] (range 7))))
\ No newline at end of file
diff --git a/src/koans/22_group_by.clj b/src/koans/22_group_by.clj
index 01de423..859abbe 100644
--- a/src/koans/22_group_by.clj
+++ b/src/koans/22_group_by.clj
@@ -1,13 +1,13 @@
 (ns koans.22-group-by
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (defn get-odds-and-evens [coll]
-  (let [{odds true evens false} (group-by __ coll)]
-    [odds evens]))
+      (let [{odds true evens false} (group-by odd? coll)]
+           [odds evens]))
 
 (meditations
   "To categorize a collection by some function, use group-by."
-  (= __ (group-by count ["hello" "world" "foo" "bar"]))
+  (= {3 ["foo" "bar"], 5 ["hello" "world"]} (group-by count ["hello" "world" "foo" "bar"]))
 
   "You can simulate filter + remove in one pass"
   (= (get-odds-and-evens [1 2 3 4 5])
@@ -15,7 +15,7 @@
      [[1 3 5] [2 4]])
 
   "You can also group by a primary key"
-  (= __
+  (= {1 [{:id 1 :name "Bob"} {:id 1 :last-name "Smith"}], 2 [{:id 2 :name "Jennifer"}]}
      (group-by :id [{:id 1 :name "Bob"}
                     {:id 2 :name "Jennifer"}
                     {:id 1 :last-name "Smith"} ]))
@@ -23,14 +23,14 @@
   "But be careful when you group by a non-required key"
   (= {"Bob" [{:name "Bob" :id 1}]
       "Jennifer" [{:name "Jennifer" :id 2}]
-      __ [{:last-name "Smith" :id 1}]}
-   (group-by :name [{:id 1 :name "Bob"}
-                    {:id 2 :name "Jennifer"}
-                    {:id 1 :last-name "Smith"}]))
+      nil [{:last-name "Smith" :id 1}]}
+     (group-by :name [{:id 1 :name "Bob"}
+                      {:id 2 :name "Jennifer"}
+                      {:id 1 :last-name "Smith"}]))
 
   "The true power of group-by comes with custom functions"
-  (= __
+  (= {:naughty-list [{:name "Jimmy" :bad true} {:name "Joe" :bad true}], :nice-list [{:name "Jane" :bad false}]}
      (group-by #(if (:bad %) :naughty-list :nice-list)
                [{:name "Jimmy" :bad true}
                 {:name "Jane" :bad false}
-                {:name "Joe" :bad true}])))
+                {:name "Joe" :bad true}])))
\ No newline at end of file
diff --git a/src/koans/23_meta.clj b/src/koans/23_meta.clj
index 45fec03..991d792 100644
--- a/src/koans/23_meta.clj
+++ b/src/koans/23_meta.clj
@@ -1,51 +1,51 @@
 (ns koans.23-meta
-  (:require [koan-engine.core :refer :all]))
+    (:require [koan-engine.core :refer :all]))
 
 (def giants
   (with-meta 'Giants
-    {:league "National League"}))
+             {:league "National League"}))
 
 (meditations
   "Some objects can be tagged using the with-meta function"
-  (= __ (meta giants))
+  (= {:league "National League"} (meta giants))
 
-  "Or more succintly with a reader macro"
-  (= __ (meta '^{:division "West"} Giants))
+  "Or more succinctly with a reader macro"                  ;succintly -> *succinctly*
+  (= {:division "West"} (meta '^{:division "West"} Giants))
 
   "While others can't"
-  (= __ (try
-          (with-meta
-            2
-            {:prime true})
-          (catch ClassCastException e
-            "This doesn't implement the IObj interface")))
+  (= "This doesn't implement the IObj interface" (try
+                                                   (with-meta
+                                                     2
+                                                     {:prime true})
+                                                   (catch ClassCastException e
+                                                     "This doesn't implement the IObj interface")))
 
   "Notice when metadata carries over"
-  (= __ (meta (merge '^{:foo :bar} {:a 1 :b 2}
-                     {:b 3 :c 4})))
+  (= '^{:c 4 :a 1 :b 3 :foo :bar} (meta (merge '^{:foo :bar} {:a 1 :b 2}
+                                               {:b 3 :c 4})))
 
   "And when it doesn't"
-  (= __ (meta (merge {:a 1 :b 2}
-                     '^{:foo :bar} {:b 3 :c 4})))
+  (= '^{:c 4 :foo :bar :a 1 :b 3} (meta (merge {:a 1 :b 2}
+                                               '^{:foo :bar} {:b 3 :c 4})))
 
   "Metadata can be used as a type hint to avoid reflection during runtime"
-  (= __ (#(.charAt ^String % 0) "Cast me"))
+  (= \C (#(.charAt ^String % 0) "Cast me"))
 
   "You can directly update an object's metadata"
   (= 8 (let [giants
              (with-meta
                'Giants
                {:world-series-titles (atom 7)})]
-         (swap! (:world-series-titles (meta giants)) __)
-         @(:world-series-titles (meta giants))))
+            (swap! (:world-series-titles (meta giants)) inc)
+            @(:world-series-titles (meta giants))))
 
   "You can also create a new object from another object with metadata"
   (= {:league "National League" :park "AT&T Park"}
      (meta (vary-meta giants
-                      assoc __ __)))
+                      assoc :park "AT&T Park")))
 
   "But it won't affect behavior like equality"
-  (= __ (vary-meta giants dissoc :league))
+  (= giants (vary-meta giants dissoc :league))
 
   "Or the object's printed representation"
-  (= __ (pr-str (vary-meta giants dissoc :league))))
+  (= (pr-str giants) (pr-str (vary-meta giants dissoc :league))))
\ No newline at end of file