anchor.diff:      (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 "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"))
  
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: 
  (defun parse (str)
    "Lex and parse STR"
    (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]]."
    (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))
  
  