Complete next 8 lessons.

koans/condition-handlers.lsp

@@ -23,22 +23,22 @@ error handling code from normal operational code."
 
 (define-test test-conditions-derive-from-types
     "conditions inherit from base types"
-  (true-or-false? ___ (typep (make-condition 'minimal-error-cond)
+  (true-or-false? t (typep (make-condition 'minimal-error-cond)
                              'minimal-error-cond))
 
-  (true-or-false? ___ (typep (make-condition 'minimal-error-cond)
+  (true-or-false? t (typep (make-condition 'minimal-error-cond)
                              'error))
 
-  (true-or-false? ___ (typep (make-condition 'minimal-error-cond)
+  (true-or-false? nil (typep (make-condition 'minimal-error-cond)
                              'warning))
 
-  (true-or-false? ___ (typep (make-condition 'minimal-warning-cond)
+  (true-or-false? t (typep (make-condition 'minimal-warning-cond)
                              'minimal-warning-cond))
 
-  (true-or-false? ___ (typep (make-condition 'minimal-warning-cond)
+  (true-or-false? nil (typep (make-condition 'minimal-warning-cond)
                              'error))
 
-  (true-or-false? ___ (typep (make-condition 'minimal-warning-cond)
+  (true-or-false? t (typep (make-condition 'minimal-warning-cond)
                              'warning)))
 
 
@@ -60,21 +60,21 @@ error handling code from normal operational code."
     "assert-error checks that the right error is thrown"
   (assert-equal 3 (my-divide 6 2))
   (assert-error 'my-div-by-zero-error (my-divide 6 0))
-  (assert-error ____ (my-divide 6 "zero")))
+  (assert-error 'my-non-number-args-error (my-divide 6 "zero")))
 
 
 (define-test test-handle-errors
     "the handler case is like a case statement which can capture errors
      and warnings, and execute appropriate forms in those conditions."
-  (assert-equal ___
+  (assert-equal 3
                 (handler-case (my-divide 6 2)
                   (my-div-by-zero-error (condition) :zero-div-error)
                   (my-non-number-args-error (condition) :bad-args)))
-  (assert-equal ___
+  (assert-equal :zero-div-error
                 (handler-case (my-divide 6 0)
                   (my-div-by-zero-error (condition) :zero-div-error)
                   (my-non-number-args-error (condition) :bad-args)))
-  (assert-equal ___
+  (assert-equal :bad-args
                 (handler-case (my-divide 6 "woops")
                   (my-div-by-zero-error (condition) :zero-div-error)
                   (my-non-number-args-error (condition) :bad-args))))
@@ -112,13 +112,13 @@ http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node312.html"
 
 
 (define-test test-errors-have-slots
-    (assert-equal ____
+    (assert-equal :timestamp-logline-type
                   (handler-case (get-logline-type "TIMESTAMP y13m01d03")
                     (logline-parse-error (condition) (list (reason condition) (original-line condition)))))
-    (assert-equal ____
+    (assert-equal :http-logline-type
                   (handler-case (get-logline-type "HTTP access 128.0.0.100")
                     (logline-parse-error (condition) (list (reason condition) (original-line condition)))))
-    (assert-equal ____
+    (assert-equal
                   (handler-case (get-logline-type "bogus logline")
                     (logline-parse-error (condition) (list (reason condition) (original-line condition)))))
     (assert-equal ____

koans/control-statements.lsp

@@ -17,11 +17,11 @@
       (if t
           (setf result "true value")
           (setf result "false value"))
-      (assert-equal result ____)
+      (assert-equal result "true value")
       (if nil
           (setf result "true value")
           (setf result "false value"))
-      (assert-equal result ____)))
+      (assert-equal result "false value")))
 
 
 (define-test test-when-and-unless
@@ -36,16 +36,16 @@
         (unless (> x 5)
           (setf result-2 x)
           (push x unless-nums)))
-      (assert-equal result-1 ___)
-      (assert-equal result-2 ___)
-      (assert-equal when-nums ___)
-      (assert-equal unless-nums ___)))
+      (assert-equal result-1 10)
+      (assert-equal result-2 5)
+      (assert-equal when-nums '(10 9 8 7 6))
+      (assert-equal unless-nums '(5 4 3 2 1))))
 
 
 (define-test test-and-short-circuits
     "and only evaluates forms until one evaluates to nil"
   (assert-equal
-   ____
+   2
    (let ((x 0))
      (and
       (setf x (+ 1 x))
@@ -58,11 +58,11 @@
 (define-test test-or-also-short-circuits
     "or only evaluates until one argument evaluates to non-nil"
   (assert-equal
-   ____
+   1
    (let ((x 0))
      (or
       (setf x (+ 1 x))
       (setf x (+ 1 x))
       nil
       (setf x (+ 1 x)))
-     x)))
+     x)))

koans/functions.lsp

@@ -20,7 +20,7 @@
 
 (define-test test-call-a-function
     "DEFUN defines global functions"
-  (assert-equal ___ (some-named-function 7 11)))
+  (assert-equal 18 (some-named-function 7 11)))
 
 
 (define-test test-shadow-a-function
@@ -30,8 +30,8 @@
    (assert-eq 18 (some-named-function 7 11))
    "flet binds a function to a name within a lexical environment"
    (flet ((some-named-function (a b) (* a b)))
-     (assert-equal ___ (some-named-function 7 11)))
-   (assert-equal ___  (some-named-function 7 11)))
+     (assert-equal 77 (some-named-function 7 11)))
+   (assert-equal 18  (some-named-function 7 11)))
 
 
 ; borrowed from Common Lisp The Language chapter 5.2.2
@@ -41,9 +41,9 @@
 
 (define-test test-optional-parameters
     "Optional parameters are filled in with their default value."
-   (assert-equal (func-with-opt-params :test-1 :test-2) ___)
-   (assert-equal (func-with-opt-params :test-1) ___)
-   (assert-equal (func-with-opt-params) ___))
+   (assert-equal (func-with-opt-params :test-1 :test-2) '(:test-1 :test-2))
+   (assert-equal (func-with-opt-params :test-1) '(:test-1 3))
+   (assert-equal (func-with-opt-params) '(2 3)))
 
 
 ;; ----
@@ -56,9 +56,9 @@
    "Common Lisp optional params may bind a symbol which indicate whether the
     value was provided or defaulted.  Each optional parameter binding has the
     form (var default-form supplied-p)."
-   (assert-equal (func-with-opt-params-and-indication :test-1 :test-2) ___)
-   (assert-equal (func-with-opt-params-and-indication :test-1) ___)
-   (assert-equal (func-with-opt-params-and-indication) ___))
+   (assert-equal (func-with-opt-params-and-indication :test-1 :test-2) '(:test-1 t :test-2 t))
+   (assert-equal (func-with-opt-params-and-indication :test-1) '(:test-1 t 3 nil))
+   (assert-equal (func-with-opt-params-and-indication) '(2 nil 3 nil)))
 
 
 ;; ----
@@ -70,9 +70,9 @@
 (define-test test-func-with-rest-params
   "With &rest, the remaining params, are handed in as a list.  Remaining
    arguments (possibly none) are collected into a list."
-  (assert-equal (func-with-rest-params) ___)
-  (assert-equal (func-with-rest-params 1) ___)
-   (assert-equal (func-with-rest-params 1 :two 333) ___))
+  (assert-equal (func-with-rest-params) nil)
+  (assert-equal (func-with-rest-params 1) '(1))
+   (assert-equal (func-with-rest-params 1 :two 333) '(1 :two 333)))
 
 
 ;; ----
@@ -83,24 +83,24 @@
 
 (define-test test-key-params ()
   "Key params allow the user to specify params in any order"
-   (assert-equal (func-with-key-params) ___)
-   (assert-equal (func-with-key-params :a 11 :b 22) ___)
+   (assert-equal (func-with-key-params) '(nil nil))
+   (assert-equal (func-with-key-params :a 11 :b 22) '(11 22))
    ; it is not necessary to specify all key parameters
-   (assert-equal (func-with-key-params :b 22) ___)
+   (assert-equal (func-with-key-params :b 22) '(nil 22))
    ; order is not important
-   (assert-equal (func-with-key-params :b 22 :a 0) ___))
+   (assert-equal (func-with-key-params :b 22 :a 0) '(0 22)))
 
 (defun func-key-params-can-have-defaults (&key  (a 3 a?) (b 4 b?))
   (list a a? b b?))
 
 (define-test test-key-params-can-have-defaults
     "key parameters can have defaults also"
-   (assert-equal (func-key-params-can-have-defaults) ____)
-   (assert-equal (func-key-params-can-have-defaults :a 3 :b 4) ___)
-   (assert-equal (func-key-params-can-have-defaults :a 11 :b 22) ___)
-   (assert-equal (func-key-params-can-have-defaults :b 22) ___)
+   (assert-equal (func-key-params-can-have-defaults) '(3 nil 4 nil))
+   (assert-equal (func-key-params-can-have-defaults :a 3 :b 4) '(3 t 4 t))
+   (assert-equal (func-key-params-can-have-defaults :a 11 :b 22) '(11 t 22 t))
+   (assert-equal (func-key-params-can-have-defaults :b 22) '(3 nil 22 t))
    ; order is not important
-   (assert-equal (func-key-params-can-have-defaults :b 22 :a 0) ___))
+   (assert-equal (func-key-params-can-have-defaults :b 22 :a 0) '(0 t 22 t)))
 
 
 ;; ----
@@ -112,10 +112,10 @@
 
 (define-test test-many-kinds-params
     "CL provides the programmer with more than enough rope to hang himself."
-   (assert-equal (func-with-funky-parameters 1) ___)
-   (assert-equal (func-with-funky-parameters 1 :b 2) ___)
-   (assert-equal (func-with-funky-parameters 1 :b 2 :c 3) ___)
-   (assert-equal (func-with-funky-parameters 1 :c 3 :b 2) ___))
+  (assert-equal (func-with-funky-parameters 1) '(1 nil 1 nil))
+  (assert-equal (func-with-funky-parameters 1 :b 2) '(1 2 1 (:b 2)))
+  (assert-equal (func-with-funky-parameters 1 :b 2 :c 3) '(1 2 3 (:b 2 :c 3)))
+  (assert-equal (func-with-funky-parameters 1 :c 3 :b 2) '(1 2 3 (:c 3 :b 2))))
 
 
 ;; Note that &rest parameters have to come before &key parameters.
@@ -129,16 +129,16 @@
    (assert-equal 19 ((lambda (a b) (+ a b)) 10 9))
   (let ((my-function))
     (setf my-function (lambda (a b) (* a b)))
-    (assert-equal ___ (funcall my-function 11 9)))
+    (assert-equal 99 (funcall my-function 11 9)))
   (let ((list-of-functions nil))
     (push (lambda (a b) (+ a b)) list-of-functions)
     (push (lambda (a b) (* a b)) list-of-functions)
     (push (lambda (a b) (- a b)) list-of-functions)
-    (assert-equal ___ (funcall (second list-of-functions) 2 33))))
+    (assert-equal 66 (funcall (second list-of-functions) 2 33))))
 
 (define-test test-lambdas-can-have-optional-params
-   (assert-equal ___ ((lambda (a &optional (b 100)) (+ a b)) 10 9))
-   (assert-equal ___ ((lambda (a &optional (b 100)) (+ a b)) 10)))
+   (assert-equal 19 ((lambda (a &optional (b 100)) (+ a b)) 10 9))
+   (assert-equal 110 ((lambda (a &optional (b 100)) (+ a b)) 10)))
 
 
 ; returns sign x
@@ -148,9 +148,9 @@
   1)
 
 (define-test test-return-from-function-early
-   (assert-equal (sign-of -5.5) ___)
-   (assert-equal (sign-of 0) ___)
-   (assert-equal (sign-of ___) 1))
+   (assert-equal (sign-of -5.5) -1)
+   (assert-equal (sign-of 0) 0)
+   (assert-equal (sign-of 201) 1))
 
 
 ;; ----
@@ -170,8 +170,8 @@
   (let ((add-100 (adder 100))
         (add-500 (adder 500)))
   "add-100 and add-500 now refer to different bindings to x"
-   (assert-equal ___ (funcall add-100 3))
-   (assert-equal ___ (funcall add-500 3))))
+   (assert-equal 103 (funcall add-100 3))
+   (assert-equal 503 (funcall add-500 3))))
 
 
 ;; ----
@@ -192,13 +192,13 @@
     "An illustration of how lexical closures may interact."
   (let ((tangled-funs-1 (two-funs 1))
         (tangled-funs-2 (two-funs 2)))
-     (assert-equal (funcall (first tangled-funs-1)) ___)
+     (assert-equal (funcall (first tangled-funs-1)) 1)
      (funcall (second tangled-funs-1) 0)
-     (assert-equal (funcall (first tangled-funs-1)) ___)
+     (assert-equal (funcall (first tangled-funs-1)) 0)
 
-     (assert-equal (funcall (first tangled-funs-2)) ___)
+     (assert-equal (funcall (first tangled-funs-2)) 2)
      (funcall (second tangled-funs-2) 100)
-     (assert-equal (funcall (first tangled-funs-2)) ___)))
+     (assert-equal (funcall (first tangled-funs-2)) 100)))
 
 
 (define-test test-apply-function-with-apply
@@ -209,13 +209,13 @@
     (setq f2 '-)
     (setq f3 'max)
 
-    (assert-equal ___ (apply f1 '(1 2)))
-    (assert-equal ___ (apply f2 '(1 2)))
+    (assert-equal 3 (apply f1 '(1 2)))
+    (assert-equal -1 (apply f2 '(1 2)))
 
     ; after the function name, the parameters are consed onto the front
     ; of the very last parameter
-    (assert-equal ___ (apply f1 1 2 '(3)))
-    (assert-equal ___ (apply f3 1 2 3 4 '()))))
+    (assert-equal 6 (apply f1 1 2 '(3)))
+    (assert-equal 4 (apply f3 1 2 3 4 '()))))
 
 
 (define-test test-apply-function-with-funcall
@@ -225,7 +225,7 @@
     (setq f1 '+)
     (setq f2 '-)
     (setq f3 'max)
-    (assert-equal ___ (funcall f1 1 2))
-    (assert-equal ___ (funcall f2 1 2))
-    (assert-equal ___ (funcall f1 1 2 3))
-    (assert-equal ___ (funcall f3 1 2 3 4))))
+    (assert-equal 3 (funcall f1 1 2))
+    (assert-equal -1 (funcall f2 1 2))
+    (assert-equal 6 (funcall f1 1 2 3))
+    (assert-equal 4 (funcall f3 1 2 3 4))))

koans/hash-tables.lsp

@@ -20,10 +20,10 @@
     "make hash table with make-hash-table"
   (let ((my-hash-table))
     (setf my-hash-table (make-hash-table))
-    (true-or-false? ___ (typep my-hash-table 'hash-table))
-    (true-or-false? ___  (hash-table-p my-hash-table))
-    (true-or-false? ___  (hash-table-p (make-array '(3 3 3))))
-    (assert-equal ___ (hash-table-count my-hash-table))))
+    (true-or-false? t (typep my-hash-table 'hash-table))
+    (true-or-false? t  (hash-table-p my-hash-table))
+    (true-or-false? nil  (hash-table-p (make-array '(3 3 3))))
+    (assert-equal 0 (hash-table-count my-hash-table))))
 
 
 (define-test test-hash-table-access
@@ -37,11 +37,11 @@
 
   (setf (gethash 8 table-of-cube-roots) 2)
   (setf (gethash -3 table-of-cube-roots) -27)
-  (assert-equal ___ (gethash -3 table-of-cube-roots))
-  (assert-equal ___ (hash-table-count table-of-cube-roots))
+  (assert-equal -27 (gethash -3 table-of-cube-roots))
+  (assert-equal 3 (hash-table-count table-of-cube-roots))
 
   "accessing unset keys returns nil"
-  (assert-equal ___ (gethash 125 table-of-cube-roots))))
+  (assert-equal nil (gethash 125 table-of-cube-roots))))
 
 
 (define-test test-hash-key-equality
@@ -67,9 +67,9 @@
     (setf (gethash "one" hash-table-default) "uno")
 
     "count how many unique key-value pairs in each"
-    (assert-equal ___ (hash-table-count hash-table-eq))
-    (assert-equal ___ (hash-table-count hash-table-equal))
-    (assert-equal ___ (hash-table-count hash-table-default))))
+    (assert-equal 2 (hash-table-count hash-table-eq))
+    (assert-equal 1 (hash-table-count hash-table-equal))
+    (assert-equal 2 (hash-table-count hash-table-default))))
 
 
 (define-test test-hash-table-equality
@@ -79,9 +79,9 @@
       (setf (gethash "one" h2) "yat")
       (setf (gethash "two" h1) "yi")
       (setf (gethash "two" h2) "yi")
-      (true-or-false? ___ (eq h1 h2))
-      (true-or-false? ___ (equal h1 h2))
-      (true-or-false? ___ (equalp h1 h2))))
+      (true-or-false? nil (eq h1 h2))
+      (true-or-false? nil (equal h1 h2))
+      (true-or-false? t (equalp h1 h2))))
 
 
 (define-test test-changing-hash-tables
@@ -93,7 +93,7 @@
       (setf (gethash "two" expected) "zwei")
 
       (setf (gethash "one" babel-fish) "eins")
-      (setf (gethash "two" babel-fish) ____)
+      (setf (gethash "two" babel-fish) "zwei")
 
       (assert-true (equalp babel-fish expected))))
 
@@ -109,18 +109,22 @@
       (setf value-and-exists (multiple-value-list (gethash "Obama" prev-pres)))
       (assert-equal value-and-exists '("Bush" t))
       (setf value-and-exists (multiple-value-list (gethash "Lincoln" prev-pres)))
-      (assert-equal value-and-exists ____)
+      (assert-equal value-and-exists '("Buchanan" t))
       (setf value-and-exists (multiple-value-list (gethash "Washington" prev-pres)))
-      (assert-equal value-and-exists ____)
+      (assert-equal value-and-exists '(nil t))
       (setf value-and-exists (multiple-value-list (gethash "Franklin" prev-pres)))
-      (assert-equal value-and-exists ____)))
+      (assert-equal value-and-exists '(nil nil))))
 
 
 (define-test test-make-your-own-hash-table
     "make a hash table that meets the following conditions"
-  (let ((colors (make-hash-table))
+  (let ((colors (make-hash-table :test #'equal))
         (values (make-hash-table)))
 
+    (setf (gethash "blue" colors) '(0 0 1))
+    (setf (gethash "green" colors) '(0 1 0))
+    (setf (gethash "red" colors) '(1 0 0))
+    (setf (gethash "purple" colors) '(1 0 1))
     (assert-equal (hash-table-count colors) 4)
     (setf values (list (gethash "blue" colors)
                        (gethash "green" colors)

koans/iteration.lsp

@@ -31,12 +31,13 @@
       (if (> one-prime biggest-in-list)
           (setf biggest-in-list one-prime))
       (incf how-many-in-list))
-    (assert-equal ___ how-many-in-list)
-    (assert-equal ___ biggest-in-list))
+    (assert-equal 4 how-many-in-list)
+    (assert-equal 999565999 biggest-in-list))
   (let ((sum 0))
     "write your own do-list here to calculate the sum of some-primes"
     "you may be interested in investigating the 'incf' function"
-    ;(dolist ... )
+    (dolist (x some-primes)
+      (incf sum x))
     (assert-equal 999607602 sum)))
 
 
@@ -47,7 +48,7 @@
           (my-return))
       (dolist (x my-list my-return)
         (push (* x x) my-return))
-      (assert-equal ____ my-return)))
+      (assert-equal '(16 9 4 1) my-return)))
 
 
 (define-test test-dotimes
@@ -55,7 +56,7 @@
       binding them in order to your selected symbol."
     (let ((out-list nil))
       (dotimes (y 3) (push y out-list))
-      (assert-equal out-list ___)))
+      (assert-equal out-list '(2 1 0))))
 
 
 (defvar *x* "global")
@@ -63,8 +64,8 @@
     "dotimes establishes a local lexical binding which may shadow
      a global value."
   (dotimes (*x* 4)
-    (true-or-false? ___ (equal "global" *x*)))
-  (true-or-false? ___ (equal "global" *x*)))
+    (true-or-false? nil (equal "global" *x*)))
+  (true-or-false? t (equal "global" *x*)))
 
 
 (define-test test-loop-until-return
@@ -75,14 +76,14 @@
       (loop
         (incf loop-counter)
         (if (>= loop-counter 100) (return loop-counter)))
-      (assert-equal ___ loop-counter)))
+      (assert-equal 100 loop-counter)))
 
 
 (define-test test-mapcar
     "mapcar takes a list an a function.  It returns a new list
      with the function applied to each element of the input"
   (let ((mc-result (mapcar #'evenp '(1 2 3 4 5))))
-    (assert-equal mc-result ____)))
+    (assert-equal mc-result '(nil t nil t nil))))
 
 
 ;; ----
@@ -106,11 +107,11 @@
   (assert-equal (vowels-to-xs "Astronomy") "xstrxnxmy")
   (let* ((subjects '("Astronomy" "Biology" "Chemistry" "Linguistics"))
          (mc-result (mapcar #'vowels-to-xs subjects)))
-    (assert-equal mc-result ____)))
+    (assert-equal mc-result '("xstrxnxmy" "Bxxlxgy" "Chxmxstry" "Lxngxxstxcs"))))
 
 
 ;; ----
 
 (define-test test-mapcar-with-lambda
     (let ((mc-result (mapcar (lambda (x) (mod x 10)) '(21 152 403 14))))
-      (assert-equal mc-result ____)))
+      (assert-equal mc-result '(1 2 3 4))))

koans/mapcar-and-reduce.lsp

@@ -16,9 +16,9 @@
     "We can apply a function to each member
      of a list using mapcar."
   (defun times-two (x) (* x 2))
-  (assert-equal ____ (mapcar #'times-two '(1 2 3)))
-  (assert-equal ____ (mapcar #'first '((3 2 1) 
-                                      ("little" "small" "tiny") 
+  (assert-equal '(2 4 6) (mapcar #'times-two '(1 2 3)))
+  (assert-equal '(3 "little" "pigs") (mapcar #'first '((3 2 1)
+                                      ("little" "small" "tiny")
                                       ("pigs" "hogs" "swine")))))
 
 
@@ -26,20 +26,20 @@
     "The mapcar function can be applied to
      more than one list. It applies a function
      to successive elements of the lists."
-  (assert-equal ____ (mapcar #'* '(1 2 3) '(4 5 6)))
-  (assert-equal ____ (mapcar #'list '("lisp" "are") '("koans" "fun"))))
+  (assert-equal '(4 10 18) (mapcar #'* '(1 2 3) '(4 5 6)))
+  (assert-equal '(("lisp" "koans") ("are" "fun")) (mapcar #'list '("lisp" "are") '("koans" "fun"))))
 
 
 (define-test test-transpose-using-mapcar
     "Replace WRONG-FUNCTION with the correct function (don't forget
      the #') to take the 'transpose'."
-  (defun WRONG-FUNCTION-1 (&rest rest) '())
+  (defun WRONG-FUNCTION-1 (&rest rest) rest)
   (defun transpose (L) (apply #'mapcar (cons #'WRONG-FUNCTION-1 L)))
     (assert-equal '((1 4 7)
-                  (2 5 8) 
-                  (3 6 9)) 
-                (transpose '((1 2 3) 
-                             (4 5 6) 
+                  (2 5 8)
+                  (3 6 9))
+                (transpose '((1 2 3)
+                             (4 5 6)
                              (7 8 9))))
   (assert-equal '(("these" "pretzels" "are")
                   ("making" "me" "thirsty"))
@@ -52,21 +52,21 @@
     "The reduce function applies uses a supplied
      binary function to combine the elements of a
      list from left to right."
-  (assert-equal ___  (reduce #'+ '(1 2 3 4)))
-  (assert-equal ___ (reduce #'expt '(2 3 2))))
+  (assert-equal 10  (reduce #'+ '(1 2 3 4)))
+  (assert-equal 64 (reduce #'expt '(2 3 2))))
 
 
 (define-test test-reduce-right-to-left
     "The keyword :from-end allows us to apply
      reduce from right to left."
-  (assert-equal ___ (reduce #'+ '(1 2 3 4) :from-end t))
-  (assert-equal ___ (reduce #'expt '(2 3 2) :from-end t)))
+  (assert-equal 10 (reduce #'+ '(1 2 3 4) :from-end t))
+  (assert-equal 512 (reduce #'expt '(2 3 2) :from-end t)))
 
 
 (define-test test-reduce-with-initial-value
     "We can supply an initial value to reduce."
-  (assert-equal ___ (reduce #'expt '(10 21 34 43) :initial-value 1))
-  (assert-equal ___ (reduce #'expt '(10 21 34 43) :initial-value 0)))
+  (assert-equal 1 (reduce #'expt '(10 21 34 43) :initial-value 1))
+  (assert-equal 0 (reduce #'expt '(10 21 34 43) :initial-value 0)))
 
 
 (defun WRONG-FUNCTION-2 (a b) (a))
@@ -76,7 +76,7 @@
     "mapcar and reduce are a powerful combination.
      insert the correct function names, instead of WRONG-FUNCTION-X
      to define an inner product."
-  (defun inner (x y) 
-    (reduce #'WRONG-FUNCTION-2 (mapcar #'WRONG-FUNCTION-3 x y)))
+  (defun inner (x y)
+    (reduce #'+ (mapcar #'* x y)))
   (assert-equal 32 (inner '(1 2 3) '(4 5 6)))
   (assert-equal 310 (inner '(10 20 30) '(4 3 7))))

koans/strings.lsp

@@ -14,24 +14,24 @@
 
 (define-test test-double-quoted-strings-are-strings
     (let ((my-string "do or do not"))
-      (true-or-false? ___ (typep my-string 'string))
+      (true-or-false? t (typep my-string 'string))
       "strings are the same thing as vectors of characters"
-      (true-or-false? ___ (typep my-string 'array))
+      (true-or-false? t (typep my-string 'array))
       (assert-equal (aref "meat" 2) (aref "fiesta" 5))
       "strings are not integers :p"
-      (true-or-false? ___ (typep my-string 'integer))))
+      (true-or-false? nil (typep my-string 'integer))))
 
 
 (define-test test-multi-line-strings-are-strings
     (let ((my-string "this is
                       a multi
                       line string"))
-      (true-or-false? ___ (typep my-string 'string))))
+      (true-or-false? t (typep my-string 'string))))
 
 
 (define-test test-escape-quotes
     (let ((my-string "this string has one of these \" in it"))
-      (true-or-false? ___ (typep my-string 'string))))
+      (true-or-false? t (typep my-string 'string))))
 
 
 ; This test from common lisp cookbook
@@ -39,19 +39,19 @@
     "since strings are sequences, you may use subseq"
   (let ((my-string "Groucho Marx"))
     (assert-equal "Marx" (subseq my-string 8))
-    (assert-equal (subseq my-string 0 7) ____)
-    (assert-equal (subseq my-string 1 5) ____)))
+    (assert-equal (subseq my-string 0 7) "Groucho")
+    (assert-equal (subseq my-string 1 5) "rouc")))
 
 (define-test test-accessing-individual-characters
   "char literals look like this"
-  (true-or-false? ___ (typep #\a 'character))
-  (true-or-false? ___ (typep "A" 'character))
-  (true-or-false? ___ (typep #\a 'string))
+  (true-or-false? t (typep #\a 'character))
+  (true-or-false? nil (typep "A" 'character))
+  (true-or-false? nil (typep #\a 'string))
   "char is used to access individual characters"
   (let ((my-string "Cookie Monster"))
     (assert-equal (char my-string 0) #\C)
     (assert-equal (char my-string 3) #\k)
-    (assert-equal (char my-string 7) ___)))
+    (assert-equal (char my-string 7) #\M)))
 
 
 (define-test test-concatenating-strings
@@ -59,20 +59,19 @@
   (let ((a "this")
         (b "is")
         (c "unwieldy"))
-    (assert-equal ___ (concatenate 'string a " " b " " c))))
+    (assert-equal "this is unwieldy" (concatenate 'string a " " b " " c))))
 
 
 (define-test test-searching-for-characters
     "you can use position to detect characters in strings
      (or elements of sequences)"
-  (assert-equal ___ (position #\b "abc"))
-  (assert-equal ___ (position #\c "abc"))
-  (assert-equal ___ (find #\d "abc")))
+  (assert-equal 1 (position #\b "abc"))
+  (assert-equal 2 (position #\c "abc"))
+  (assert-equal nil (find #\d "abc")))
 
 
 (define-test test-finding-substrings
     "search finds subsequences"
   (let ((title "A supposedly fun thing I'll never do again"))
     (assert-equal 2 (search "supposedly" title))
-    (assert-equal 12 (search "CHANGETHISWORD" title))))
-
+    (assert-equal 12 (search " fun" title))))

koans/structures.lsp

@@ -31,11 +31,11 @@
   (let ((player-1 (make-basketball-player
                    :name "larry" :team :celtics :number 33)))
     (assert-equal "larry" (basketball-player-name player-1))
-    (assert-equal ___ (basketball-player-team player-1))
-    (assert-equal ___ (basketball-player-number player-1))
+    (assert-equal :celtics (basketball-player-team player-1))
+    (assert-equal 33 (basketball-player-number player-1))
     (assert-equal 'basketball-player (type-of player-1))
     (setf (basketball-player-team player-1) :RETIRED)
-    (assert-equal ___ (basketball-player-team player-1))))
+    (assert-equal :RETIRED (basketball-player-team player-1))))
 
 
 ;; Struct fields can have default values
@@ -45,9 +45,9 @@
 
 (define-test test-struct-defaults
     (let ((player-2 (make-baseball-player)))
-      (assert-equal ___ (baseball-player-position player-2))
-      (assert-equal ___ (baseball-player-team player-2))
-      (assert-equal ___ (baseball-player-name player-2))))
+      (assert-equal :outfield (baseball-player-position player-2))
+      (assert-equal :red-sox (baseball-player-team player-2))
+      (assert-equal nil (baseball-player-name player-2))))
 
 
 ;; The accessor names can get pretty long.  It's possible to specify
@@ -58,8 +58,7 @@
 (define-test test-abbreviated-struct-access
     (let ((player-3 (make-american-football-player
                      :name "Drew Brees" :position :QB :team "Saints")))
-      (assert-equal ___ (nfl-guy-position player-3))))
-
+      (assert-equal :QB (nfl-guy-position player-3))))
 
 ;; Structs can be defined as EXTENSIONS to previous structures.
 ;; This form of inheritance allows composition of objects.
@@ -74,13 +73,13 @@
                        :name "Kobe Bryant"
                        :team :LAKERS
                        :number 24)))
-      (assert-equal ___ (nba-contract-start-year contract-1))
-      (assert-equal ___ (type-of contract-1))
+      (assert-equal 2004 (nba-contract-start-year contract-1))
+      (assert-equal 'NBA-CONTRACT (type-of contract-1))
       ;; do inherited structures follow the rules of type hierarchy?
-      (true-or-false? ___ (typep contract-1 'BASKETBALL-PLAYER))
+      (true-or-false? t (typep contract-1 'BASKETBALL-PLAYER))
       ;; can you access structure fields with the inherited accessors?
-      (assert-equal ___ (nba-contract-team contract-1))
-      (assert-equal ___ (basketball-player-team contract-1))))
+      (assert-equal :LAKERS (nba-contract-team contract-1))
+      (assert-equal :LAKERS (basketball-player-team contract-1))))
 
 
 ;; Copying of structs is handled with the copy-{name} form.  Note that
@@ -90,15 +89,15 @@
     (let ((manning-1 (make-american-football-player :name "Manning" :team '("Colts" "Broncos")))
           (manning-2 (make-american-football-player :name "Manning" :team '("Colts" "Broncos"))))
       ;; manning-1 and manning-2 are different objects
-      (true-or-false? ___ (eq manning-1 manning-2))
+      (true-or-false? nil (eq manning-1 manning-2))
       ;; but manning-1 and manning-2 contain the same information
       ;; (note the equalp instead of eq
-      (true-or-false? ___ (equalp manning-1 manning-2))
+      (true-or-false? t (equalp manning-1 manning-2))
       ;; copied structs are much the same.
-      (true-or-false? ___ (equalp manning-1 (copy-american-football-player manning-1)))
-      (true-or-false? ___ (eq     manning-1 (copy-american-football-player manning-1)))
+      (true-or-false? t (equalp manning-1 (copy-american-football-player manning-1)))
+      (true-or-false? nil (eq     manning-1 (copy-american-football-player manning-1)))
       ;; note that the copying is shallow
       (let ((shallow-copy (copy-american-football-player manning-1)))
         (setf (car (nfl-guy-team manning-1)) "Giants")
-        (assert-equal ___ (car (nfl-guy-team manning-1)))
-        (assert-equal ___ (car (nfl-guy-team shallow-copy))))))
+        (assert-equal "Giants" (car (nfl-guy-team manning-1)))
+        (assert-equal "Giants" (car (nfl-guy-team shallow-copy))))))