anchor.diff:  
   (defun parse (str)
     "Lex and parse STR"
  -  (parser/parse (parser/lex void str "<stdin>")))
  +  (parser/parse void (parser/lex void str "<stdin>")))
   
   (defun teq? (x y)
     "Check the two values X and Y are equal, unwrapping them using [[const-val]]."
  -  (eq?
  -    (if (list? x) (map const-val x) (const-val x))
  -    (if (list? y) (map const-val y) (const-val y))))
  +  (cond
  +    [(/= (type x) (type y)) false]
  +    [(list? x) (and (= (# x) (# y)) (all id (zip teq? x y)))]
  +    [true (eq? (const-val x) (const-val y))]))
   
   (defun string->key (key) (struct :tag "key" :value key))
   
  
positive.code:   (it "lexes strings"
      (affirm (teq? '("foo") (lex "\"foo\""))
              (teq? '("\"foo\"") (lex "\"\\\"foo\\\"\""))
              (teq? '("A") (lex "\65"))
              (teq? '("A") (lex "\x41"))
              (teq? '("foo\nbar") (lex "\"foo\n bar\""))
              (teq? '("foo\nbar") (lex "   \"foo\n    bar\""))
              (teq? '("foo\n   bar") (lex "   \"foo\n   bar\""))))
  
negative.code:     (affirm (teq? (list (string->symbol "foo")) (lex "foo"))
              (teq? (list (string->symbol "foo-bar")) (lex "foo-bar"))
              (teq? (list (string->symbol "foo-bar!")) (lex "foo-bar!"))
              (teq? (list (string->symbol "foo-\"bar")) (lex "foo-\"bar"))
              (teq? (list (string->symbol "-")) (lex "-"))
              (teq? (list (string->symbol "-.e")) (lex "-.e"))
              (teq? (list (string->symbol "//\\//")) (lex "//\\//"))))
  
    (it "lexes keys"
      (affirm (teq? (list (string->key "foo")) (lex ":foo"))
  