anchor.diff:          (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)))
  
positive.code:       (assert-equal '(10 20 30 40) stack)
  
        (setf firstval (pop stack))
        (assert-equal ___ firstval)
        (assert-equal ___ stack)))
  
  
  (define-test test-append
  
negative.code:       (assert-equal '(:one) nums)
  
        (setf nums (cons :two nums))
        (assert-equal '(:two :one) nums)
  
        "lists can contain anything, even mixtures of different things"
        (setf nums (cons 333 nums))
        (assert-equal '(333 :two :one) nums)
  
        "lists can of course contain lists"
        (setf nums (cons '("the" "rest") nums))
        (assert-equal '(("the" "rest") 333 :two :one) nums)))
  
  
  (define-test test-push-pop
  