Complete first 10 lessons

koans/arrays.lsp

 
 ;; see http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node157.html
 
-
 (define-test test-basic-array-stuff
     " the first block of code defines an 8x8 array, then fills
       the elements with a checkerboard pattern"
       (dotimes (y 8)
         (if (evenp (+ x y))
             (setf (aref chess-board x y) :black)
-            (setf (aref chess-board x y) :white)
-            )))
+            (setf (aref chess-board x y) :white))))
     (assert-true (typep chess-board 'array))
-    (assert-equal (aref chess-board 0 0) ___)
-    (assert-equal (aref chess-board 2 3) ___)
+    (assert-equal (aref chess-board 0 0) :black)
+    (assert-equal (aref chess-board 2 3) :white)
     "array-rank returns the number of dimensions of the array"
-    (assert-equal ___ (array-rank chess-board))
+    (assert-equal 2 (array-rank chess-board))
     "array-dimensions returns a list of the cardinality of the array dims"
-    (assert-equal ___ (array-dimensions chess-board))
-    (assert-equal ___ (array-total-size chess-board))))
+    (assert-equal '(8 8) (array-dimensions chess-board))
+    (assert-equal 64 (array-total-size chess-board))))
 
 (define-test test-make-your-own-array
     "make your own array that meets the specifications below."
-  (let ((color-cube nil))
+  (let ((color-cube (make-array '(3 3 3))))
+    (setf (aref color-cube 0 1 2) :red)
+    (setf (aref color-cube 2 1 0) :white)
     "you may need to modify your array after you make it"
     (if (typep color-cube '(simple-array T (3 3 3)))
         (progn
 (define-test test-make-array-from-list
   (let ((x))
     (setf x (make-array '(4) :initial-contents '(:one :two :three :four)))
-    (assert-equal (array-dimensions x) ____)
-    (assert-equal ____ (aref x 0))))
+    (assert-equal (array-dimensions x) '(4))
+    (assert-equal :one (aref x 0))))
 
 
 (define-test test-row-major-index
     (setf my-array (make-array '(2 2 2 2)))
     (dotimes (i (* 2 2 2 2))
       (setf (row-major-aref my-array i) i))
-    (assert-equal (aref my-array 0 0 0 0) ____)
-    (assert-equal (aref my-array 1 1 1 1) ____)))
+    (assert-equal (aref my-array 0 0 0 0) 0)
+    (assert-equal (aref my-array 1 1 1 1) 15)))

koans/asserts.lsp

 
 (define-test assert-true
     "t is true.  Replace the blank with a t"
-    (assert-true ___))
+    (assert-true t))
 
 (define-test assert-false
     "nil is false"
-    (assert-false ___))
+    (assert-false nil))
 
 (define-test fill-in-the-blank
     "sometimes you will need to fill the blank to complete"
-    (assert-equal 2 ___))
+    (assert-equal 2 2))
 
 (define-test fill-in-the-blank-string
-    (assert-equal ___ "hello world"))
+    (assert-equal "hello world" "hello world"))
 
 (define-test test-true-or-false
-    "sometimes you will be asked to evaluate whether statements 
+    "sometimes you will be asked to evaluate whether statements
      are true (t) or false (nil)"
-    (true-or-false? ___ (equal 34 34))
-    (true-or-false? ___ (equal 19 78)))
-
-
+    (true-or-false? t (equal 34 34))
+    (true-or-false? nil (equal 19 78)))

koans/atoms-vs-lists.lsp

      white-space or parentheses.  The function 'listp' will return true if
      the input is a list.  The function 'atom' will return true if the
      input is an atom."
-  (true-or-false? ___ (listp '(1 2 3)))
-  (true-or-false? ___ (atom '(1 2 3)))
+  (true-or-false? t (listp '(1 2 3)))
+  (true-or-false? nil (atom '(1 2 3)))
 
-  (true-or-false? ___ (listp '("heres" "some" "strings")))
-  (true-or-false? ___ (atom '("heres" "some" "strings")))
+  (true-or-false? t (listp '("heres" "some" "strings")))
+  (true-or-false? nil (atom '("heres" "some" "strings")))
 
-  (true-or-false? ___ (listp "a string"))
-  (true-or-false? ___ (atom "a string"))
+  (true-or-false? nil (listp "a string"))
+  (true-or-false? t (atom "a string"))
 
-  (true-or-false? ___ (listp 2))
-  (true-or-false? ___ (atom 2))
+  (true-or-false? nil (listp 2))
+  (true-or-false? t (atom 2))
 
-  (true-or-false? ___ (listp '(("first" "list") ("second" "list"))))
-  (true-or-false? ___ (atom '(("first" "list") ("second" "list")))))
+  (true-or-false? t (listp '(("first" "list") ("second" "list"))))
+  (true-or-false? nil (atom '(("first" "list") ("second" "list")))))
 
 
 (define-test test-empty-list-is-both-list-and-atom
     "the empty list, nil, is unique in that it is both a list and an atom"
-  (true-or-false? ___ (listp nil))
-  (true-or-false? ___ (atom nil)))
+  (true-or-false? t (listp nil))
+  (true-or-false? t (atom nil)))
 
 
 (define-test test-keywords
     "symbols like :hello or :like-this are treated differently in lisp.
      Called keywords, they are symbols that evaluate to themselves."
-  (true-or-false? ___ (equal :this-is-a-keyword :this-is-a-keyword))
-  (true-or-false? ___ (equal :this-is-a-keyword ':this-is-a-keyword)))
+  (true-or-false? t (equal :this-is-a-keyword :this-is-a-keyword))
+  (true-or-false? t (equal :this-is-a-keyword ':this-is-a-keyword)))

koans/equality-distinctions.lsp

     "(eq x y) is true if and only if x and y are the same identical object
      eq is like comparing pointers in c.  If the values are EQ, any non-nil
      value may be returned."
-  (true-or-false? ___ (eq 'a 'a))
-  (true-or-false? ___ (eq 3 3.0))
-  (true-or-false? ___ (eq '(1 2) '(1 2)))
-  (true-or-false? ___ (eq "Foo" "Foo"))
-  (true-or-false? ___ (eq "Foo" (copy-seq "Foo")))
-  (true-or-false? ___ (eq "FOO" "Foo")))
+  (true-or-false? t (eq 'a 'a))
+  (true-or-false? nil (eq 3 3.0))
+  (true-or-false? nil (eq '(1 2) '(1 2)))
+  (true-or-false? nil (eq "Foo" "Foo"))
+  (true-or-false? nil (eq "Foo" (copy-seq "Foo")))
+  (true-or-false? nil (eq "FOO" "Foo")))
 
 (define-test test-eql
     "(eql x y) is true if (eq x y)
      also it is true if x and y are numeric of the same type
      and represent the same number.
      (eql x y) also if x and y are the same characters."
-   (true-or-false? ___ (eql 'a 'a))
-   (true-or-false? ___ (eql 3 3))
-   (true-or-false? ___ (eql 3 3.0))
-   (true-or-false? ___ (eql '(1 2) '(1 2)))
-   (true-or-false? ___ (eql  '(:a . :b) '(:a . :b)))
-   (true-or-false? ___ (eql #\S #\S))
-   (true-or-false? ___ (eql "Foo" "Foo"))
-   (true-or-false? ___ (eql "Foo" (copy-seq "Foo")))
-   (true-or-false? ___ (eql "FOO" "Foo")))
+   (true-or-false? t (eql 'a 'a))
+   (true-or-false? t (eql 3 3))
+   (true-or-false? nil (eql 3 3.0))
+   (true-or-false? nil (eql '(1 2) '(1 2)))
+   (true-or-false? nil (eql  '(:a . :b) '(:a . :b)))
+   (true-or-false? t (eql #\S #\S))
+   (true-or-false? nil (eql "Foo" "Foo"))
+   (true-or-false? nil (eql "Foo" (copy-seq "Foo")))
+   (true-or-false? nil (eql "FOO" "Foo")))
 
 (define-test test-equal
     "(equal x y) is true if (eql x y), or
      x and y are lists with equal elements, or
      x and y character or bit arrays with equal elements"
-   (true-or-false? ___ (equal 'a 'a))
-   (true-or-false? ___ (equal 3 3))
-   (true-or-false? ___ (equal 3 3.0))
-   (true-or-false? ___ (equal '(1 2) '(1 2)))
-   (true-or-false? ___ (equal  '(:a . :b) '(:a . :b)))
-   (true-or-false? ___ (equal  '(:a . :b) '(:a . :doesnt-match)))
-   (true-or-false? ___ (equal #\S #\S))
-   (true-or-false? ___ (equal "Foo" "Foo"))
-   (true-or-false? ___ (equal "Foo" (copy-seq "Foo")))
-   (true-or-false? ___ (equal "FOO" "Foo")))
+   (true-or-false? t (equal 'a 'a))
+   (true-or-false? t (equal 3 3))
+   (true-or-false? nil (equal 3 3.0))
+   (true-or-false? t (equal '(1 2) '(1 2)))
+   (true-or-false? t (equal  '(:a . :b) '(:a . :b)))
+   (true-or-false? nil (equal  '(:a . :b) '(:a . :doesnt-match)))
+   (true-or-false? t (equal #\S #\S))
+   (true-or-false? t (equal "Foo" "Foo"))
+   (true-or-false? t (equal "Foo" (copy-seq "Foo")))
+   (true-or-false? nil (equal "FOO" "Foo")))
 
 (define-test test-equalp
     "(equalp x y) if (equal x y) or
      if x and y are arrays with the same dimensions and equal elements
      if x and y are numeric of different types but one may be upgraded to
      the other type without loss and still exhibit equality."
-   (true-or-false? ___ (equalp 'a 'a))
-   (true-or-false? ___ (equalp 3 3))
-   (true-or-false? ___ (equalp 3 3.0))
-   (true-or-false? ___ (equalp '(1 2) '(1 2)))
-   (true-or-false? ___ (equalp  '(:a . :b) '(:a . :b)))
-   (true-or-false? ___ (equalp  '(:a . :b) '(:a . :doesnt-match)))
-   (true-or-false? ___ (equalp #\S #\S))
-   (true-or-false? ___ (equalp "Foo" "Foo"))
-   (true-or-false? ___ (equalp "Foo" (copy-seq "Foo")))
-   (true-or-false? ___ (equalp "FOO" "Foo")))
+   (true-or-false? t (equalp 'a 'a))
+   (true-or-false? t (equalp 3 3))
+   (true-or-false? t (equalp 3 3.0))
+   (true-or-false? t (equalp '(1 2) '(1 2)))
+   (true-or-false? t (equalp  '(:a . :b) '(:a . :b)))
+   (true-or-false? nil (equalp  '(:a . :b) '(:a . :doesnt-match)))
+   (true-or-false? t (equalp #\S #\S))
+   (true-or-false? t (equalp "Foo" "Foo"))
+   (true-or-false? t (equalp "Foo" (copy-seq "Foo")))
+   (true-or-false? t (equalp "FOO" "Foo")))
 
 (define-test test-numeric-equal
     "(= x y) is only for numerics
      and can take multiple arguments
      if x or y is not numeric there will be a compiler error."
-   (true-or-false? ___ (= 99.0 99 99.000))
-   (true-or-false? ___ (= 0 1 -1))
-   (true-or-false? ___ (= (/ 2 3) (/ 6 9) (/ 86 129))))
+   (true-or-false? t (= 99.0 99 99.000))
+   (true-or-false? nil (= 0 1 -1))
+   (true-or-false? t (= (/ 2 3) (/ 6 9) (/ 86 129))))
 
-; EQ, EQL, EQUAL, and EQUALP are general equality predicates.
+; EQ, EQL, EQUAL, and EQUAL are general equality predicates.
 ; Additionally, Lisp also provides the type-specific predicates.
 ; For example, STRING= and STRING-EQUAL are predicates for strings.
 (define-test test-string-equal
   "string-equal is just like string= except that differences in case are ignored."
-  (true-or-false? ___ (string= "Foo" "Foo"))
-  (true-or-false? ___ (string= "Foo" "FOO"))
-  (true-or-false? ___ (string= "together" "frog" :start1 1 :end1 3 :start2 2))
-  (true-or-false? ___ (string-equal "Foo" "FOO"))
-  (true-or-false? ___ (string-equal "together" "FROG" :start1 1 :end1 3 :start2 2)))
+  (true-or-false? t (string= "Foo" "Foo"))
+  (true-or-false? nil (string= "Foo" "FOO"))
+  (true-or-false? t (string= "together" "frog" :start1 1 :end1 3 :start2 2))
+  (true-or-false? t (string-equal "Foo" "FOO"))
+  (true-or-false? t (string-equal "together" "FROG" :start1 1 :end1 3 :start2 2)))

koans/evaluation.lsp

      with the function name the first element of that list."
 
   "in these examples, the function names are +, -, and *"
-  (assert-equal ___ (+ 2 3))
-  (assert-equal ___ (- 1 3))
-  (assert-equal ___ (* 7 4))
+  (assert-equal 5 (+ 2 3))
+  (assert-equal -2 (- 1 3))
+  (assert-equal 28 (* 7 4))
   "'>' and '=' are the boolean functions (predicates) 'greater-than' and
    'equal to'"
-  (assert-equal ___ (> 100 4))
-  (assert-equal ___ (= 3 3))
+  (assert-equal t (> 100 4))
+  (assert-equal t (= 3 3))
   "'NUMBERP' is a predicate which returns true if the argument is a number"
-  (assert-equal ___ (numberp 5))
-  (assert-equal ___ (numberp "five")))
+  (assert-equal t (numberp 5))
+  (assert-equal nil (numberp "five")))
 
 
 (define-test test-evaluation-order
     "Arguments to functions are evaluated before the function"
-  (assert-equal ___ (* (+ 1 2) (- 13 10))))
+  (assert-equal 9 (* (+ 1 2) (- 13 10))))
 
 
 (define-test test-quoting-behavior
      the literal list.
      Evaluating the form (+ 1 2) returns the number 3,
      but evaluating the form '(+ 1 2) returns the list (+ 1 2)"
-  (assert-equal ____ (+ 1 2))
-  (assert-equal ____ '(+ 1 2))
+  (assert-equal 3 (+ 1 2))
+  (assert-equal (quote (+ 1 2)) '(+ 1 2))
   "'LISTP' is a predicate which returns true if the argument is a list"
   " the '(CONTENTS) form defines a list literal containing CONTENTS"
-  (assert-equal ___ (listp '(1 2 3)))
-  (assert-equal ___ (listp 100))
-  (assert-equal ___ (listp "Word to your moms I came to drop bombs"))
-  (assert-equal ___ (listp nil))
-  (assert-equal ___ (listp (+ 1 2)))
-  (assert-equal ___ (listp '(+ 1 2)))
+  (assert-equal t (listp '(1 2 3)))
+  (assert-equal nil (listp 100))
+  (assert-equal nil (listp "Word to your moms I came to drop bombs"))
+  (assert-equal t (listp nil))
+  (assert-equal nil (listp (+ 1 2)))
+  (assert-equal t (listp '(+ 1 2)))
   "equalp is an equality predicate"
-  (assert-equal ___ (equalp 3 (+ 1 2)))
+  (assert-equal t (equalp 3 (+ 1 2)))
   "the '(xyz ghi) syntax is syntactic sugar for the (QUOTE (xyz ghi)) function."
-  (true-or-false? ___ (equalp '(/ 4 0) (quote (/ 4 0)))))
+  (true-or-false? t (equalp '(/ 4 0) (quote (/ 4 0)))))

koans/lists.lsp

         (some-evens nil))
     (setf fruits '(orange pomello clementine))
     (setf some-evens (list (* 2 1) (* 2 2) (* 2 3)))
-    (assert-equal fruits ___)
-    (assert-equal ___ (length some-evens))))
+    (assert-equal fruits (list 'orange 'pomello 'clementine))
+    (assert-equal 3 (length some-evens))))
 
 
 (define-test test-list-cons
       (assert-equal '(:one) nums)
 
       (setf nums (cons :two nums))
-      (assert-equal ___ nums)
+      (assert-equal '(:two :one) nums)
 
       "lists can contain anything, even mixtures of different things"
       (setf nums (cons 333 nums))
-      (assert-equal ___ nums)
+      (assert-equal '(333 :two :one) nums)
 
       "lists can of course contain lists"
       (setf nums (cons '("the" "rest") nums))
-      (assert-equal ___ nums)))
+      (assert-equal '(("the" "rest") 333 :two :one) nums)))
 
 
 (define-test test-push-pop
       (assert-equal '(10 20 30 40) stack)
 
       (setf firstval (pop stack))
-      (assert-equal ___ firstval)
-      (assert-equal ___ stack)))
+      (assert-equal 10 firstval)
+      (assert-equal '(20 30 40) stack)))
 
 
 (define-test test-append
         (xyz '(:x :y :z))
         (abcxyz nil))
     (setf abcxyz (append abc xyz))
-    (assert-equal ___ abc)
-    (assert-equal ___ xyz)
-    (assert-equal ___ abcxyz)))
+    (assert-equal '(:a :b :c) abc)
+    (assert-equal '(:x :y :z) xyz)
+    (assert-equal '(:a :b :c :x :y :z) abcxyz)))
 
 
 (define-test test-accessing-list-elements
     (let ((noms '("peanut" "butter" "and" "jelly")))
       (assert-equal "peanut" (first noms))
-      (assert-equal ___ (second noms))
-      (assert-equal ___ (fourth noms))
+      (assert-equal "butter" (second noms))
+      (assert-equal "jelly" (fourth noms))
       "last returns a singleton list of the final element"
-      (assert-equal ___ (last noms))
+      (assert-equal '("jelly") (last noms))
       (assert-equal "butter" (nth 1 noms)) ; k 1
-      (assert-equal ___ (nth 0 noms))
-      (assert-equal ___ (nth 2 noms))
+      (assert-equal "peanut" (nth 0 noms))
+      (assert-equal "and" (nth 2 noms))
       "'elt' is similar to 'nth', with the arguments reversed"
-      (assert-equal ___ (elt noms 2))))
+      (assert-equal "and" (elt noms 2))))
 
 
 (define-test test-slicing-lists
     (let ((noms '("peanut" "butter" "and" "jelly")))
-      (assert-equal ___ (subseq noms 0 1))
-      (assert-equal ___ (subseq noms 0 2))
-      (assert-equal ___ (subseq noms 2 2))
-      (assert-equal ___ (subseq noms 2))))
+      (assert-equal '("peanut") (subseq noms 0 1))
+      (assert-equal '("peanut" "butter") (subseq noms 0 2))
+      (assert-equal nil (subseq noms 2 2))
+      (assert-equal '("and" "jelly") (subseq noms 2))))
 
 
 (define-test test-list-breakdown
     "car (aka. 'first') returns the first value in a list"
-  (assert-equal ___ (car '(1 2 3)))
-  (assert-equal ___ (car nil))
+  (assert-equal 1 (car '(1 2 3)))
+  (assert-equal nil (car nil))
     "cdr (aka. 'rest') refers to the remainder of the list,
      after the first element"
-  (assert-equal ___ (cdr '(1 2 3)))
-  (assert-equal ___ (cdr nil)))
+  (assert-equal '(2 3) (cdr '(1 2 3)))
+  (assert-equal nil (cdr nil)))

koans/multiple-values.lsp

       (assert-equal x 1)
       (setf x (multiple-value-list (floor 3/2)))
       (assert-equal x '(1 1/2)))
-  (assert-equal (multiple-value-list (floor 99/4)) ____))
+  (assert-equal (multiple-value-list (floor 99/4)) '(24 3/4)))
 
 (defun next-fib (a b)
   (values b (+ a b)))
     (let ((x)
           (y))
       (setf x (next-fib 2 3))
-      (assert-equal x ___)
+      (assert-equal x 3)
       (setf x (multiple-value-list (next-fib 2 3)))
-      (assert-equal x ___)
+      (assert-equal x '(3 5))
       "multiple-value-bind binds the variables in the first form
        to the outputs of the second form.  And then returns the output
        of the third form using those bindings"
       (setf y (multiple-value-bind (b c) (next-fib 3 5) (* b c)))
-      (assert-equal y ___)
+      (assert-equal y 40)
       "multiple-value-setq is like setf, but can set multiple variables"
       (multiple-value-setq (x y) (values :v1 :v2))
       (assert-equal (list x y) '(:v1 :v2))
       (multiple-value-setq (x y) (next-fib 5 8))
-      (assert-equal (list x y) ____)))
+      (assert-equal (list x y) '(8 13))))

koans/nil-false-empty.lsp

 
 (define-test test-t-and-nil-are-opposites
     "not is a function which returns the boolean opposite of its argument"
-   (true-or-false? ___ (not nil))
-   (true-or-false? ___ (not t)))
+   (true-or-false? t (not nil))
+   (true-or-false? nil (not t)))
 
 
 (define-test test-nil-and-empty-list-are-the-same-thing
-  (true-or-false? ___ ())
-  (true-or-false? ___ (not ())))
+  (true-or-false? nil ())
+  (true-or-false? t (not ())))
 
 
 (define-test test-lots-of-things-are-true
    " every value, other than nil, is boolean true"
-   (true-or-false? ___ 5)
-   (true-or-false? ___ (not 5))
-   (true-or-false? ___ "A String")
+   (true-or-false? t 5)
+   (true-or-false? nil (not 5))
+   (true-or-false? t "A String")
    "only nil is nil.  Everything else is effectively true."
    "the empty string"
-   (true-or-false? ___ "")
+   (true-or-false? t "")
    "a list containing a nil"
-   (true-or-false? ___ '(nil))
+   (true-or-false? t '(nil))
    "an array with no elements"
-   (true-or-false? ___ (make-array '(0)))
+   (true-or-false? t (make-array '(0)))
    "the number zero"
-   (true-or-false? ___ 0))
+   (true-or-false? t 0))
 
 
 (define-test test-and
    "and can take multiple arguments"
-   (true-or-false? ___ (and t t t t t))
-   (true-or-false? ___ (and t t nil t t))
+   (true-or-false? t (and t t t t t))
+   (true-or-false? nil (and t t nil t t))
    "if no nils, and returns the last value"
-   (assert-equal ___ (and t t t t t 5)))
+   (assert-equal 5 (and t t t t t 5)))
 
 
 (define-test test-or
    "or can also take multiple arguments"
-   (true-or-false? ____  (or nil nil nil t nil))
+   (true-or-false? t  (or nil nil nil t nil))
    "or returns the first non nil value, or nil if there are none."
-   (assert-equal ____ (or nil nil nil))
-   (assert-equal ____ (or 1 2 3 4 5)))
+   (assert-equal nil (or nil nil nil))
+   (assert-equal 1 (or 1 2 3 4 5)))

koans/special-forms.lsp

     "setf is used to assign values to symbols.  These symbols may refer to
      variables with lexical or dynamic scope."
   (setf my-name "David")
-  (assert-equal my-name ____)
+  (assert-equal my-name "David")
   " In SBCL, if the symbol isn't defined as a variable, via a top-level defvar
   or let statement, the setf call may result in a warning."
   (setf my-clones-name my-name)
-  (assert-equal "David" ____)
+  (assert-equal "David" my-clones-name)
   (setf a 5)
   (setf b 10)
-  (setf c ___)
+  (setf c 50)
   (assert-equal 50 c))
 
 
      lexical form.  After which, the previous value, if it exists, is visible again."
   (setf a 10)
   (setf b 20)
-  (assert-equal a ___)
-  (assert-equal b ___)
+  (assert-equal a 10)
+  (assert-equal b 20)
   (let ((a 1111)
         (b 2222))
-    (assert-equal a ___)
-    (assert-equal b ___))
-  (assert-equal a ___)
-  (assert-equal b ___))
+    (assert-equal a 1111)
+    (assert-equal b 2222))
+  (assert-equal a 10)
+  (assert-equal b 20))
 
 
 (define-test test-let-default-value
     "let vars have a default value"
     (let ((x))
-      (assert-equal ___ x)))
+      (assert-equal nil x)))
 
 (define-test test-let-bindings-are-parallel
     "When defining the bindings in the let form, later bindings may not depend
   (setf a 100)
   (let ((a 5)
         (b (* 10 a)))
-    (assert-equal b ___)))
+    (assert-equal b 1000)))
 
 (define-test test-let*-bindings-are-series
     "let* is like let, but successive bindings may use values of previous ones"
   (setf a 100)
   (let* ((a 5)
          (b (* 10 a)))
-    (assert-equal b ___))
-  (assert-equal a ___))
+    (assert-equal b 50))
+  (assert-equal a 100))
 
 
 (define-test write-your-own-let-statement
   (setf a 100)
   (setf b 23)
   (setf c 456)
-  (let ((a 0)
-        (b __)
-        (c __))
+  (let ((a a)
+        (b (* a 2))
+        (c "Jellyfish"))
     (assert-equal a 100)
     (assert-equal b 200)
     (assert-equal c "Jellyfish"))
-  (let* ((a 0))
+  (let* ((a 121)
+         (b 200)
+         (c (+ a (/ b a))))
     (assert-equal a 121)
     (assert-equal b 200)
     (assert-equal c (+ a (/ b a)))))
         (cond ((> a 0) :positive)
               ((< a 0) :negative)
               (t :zero)))
-  (assert-equal ____ c))
+  (assert-equal :positive c))
 
 
 (defun cartoon-dads (input)
   " you should be able to complete this cond statement"
   (cond ((equal input :this-one-doesnt-happen) :fancy-cat)
+        ((equal input :bart) :homer)
+        ((equal input :stewie) :peter)
+        ((equal input :stan) :randy)
         (t :unknown)))
 
 (define-test test-your-own-cond-statement

koans/vectors.lsp

 
 (define-test test-vector-types
   " #(x y z) defines a vector literal containing x y z"
-  (true-or-false? ___ (typep #(1 11 111) 'vector))
-  (assert-equal ___ (aref #(1 11 111) 1)))
+  (true-or-false? t (typep #(1 11 111) 'vector))
+  (assert-equal 11 (aref #(1 11 111) 1)))
 
 
 (define-test test-length-works-on-vectors
-  (assert-equal (length #(1 2 3)) ___ ))
+  (assert-equal (length #(1 2 3)) 3 ))
 
 
 (define-test test-bit-vector
     "#*0011 defines a bit vector literal with four elements, 0, 0, 1 and 1"
-  (assert-equal #*0011 (make-array '4 :element-type 'bit))
-  (true-or-false? ____ (typep #*1001 'bit-vector))
-  (assert-equal ____ (aref #*1001 1)))
+  (assert-equal #*0011 (make-array '4 :element-type 'bit :initial-contents '(0 0 1 1)))
+  (true-or-false? t (typep #*1001 'bit-vector))
+  (assert-equal 0 (aref #*1001 1)))
 
 
 (define-test test-some-bitwise-operations
-    (assert-equal ___ (bit-and #*1100 #*1010))
-    (assert-equal ___ (bit-ior #*1100 #*1010))
-    (assert-equal ___ (bit-xor #*1100 #*1010)))
+    (assert-equal #*1000 (bit-and #*1100 #*1010))
+    (assert-equal #*1110 (bit-ior #*1100 #*1010))
+    (assert-equal #*0110 (bit-xor #*1100 #*1010)))
 
 
 (defun list-to-bit-vector (my-list)
-  nil)
+  (make-array (length my-list) :element-type 'bit :initial-contents my-list))
 
 (define-test test-list-to-bit-vector
     "you must complete list-to-bit-vector"
   (assert-equal (aref (list-to-bit-vector '(0)) 0) 0)
   (assert-equal (aref (list-to-bit-vector '(0 1)) 1) 1)
   (assert-equal (length (list-to-bit-vector '(0 0 1 1 0 0 1 1))) 8))
-
-