anchor.diff:    (it "lexes handles comments"
       (affirm (teq? '() (lex "; foo bar"))
               (teq? '(foo) (lex "; foo bar\nfoo"))))
  +
  +  (it "parses constants"
  +    (affirm (teq? '(23) (parse "23"))
  +            (teq? '("foo") (parse "\"foo\""))
  +            (teq? '(23 foo "foo" 23) (parse "23 foo \"foo\" 23"))
  +            (teq? '((23)) (parse "(23)"))))
  +
  +  (it "parses lists"
  +    (affirm (teq? '((((23)))) (parse "(((23)))"))
  +            (teq? '((foo bar) foo (((foo)))) (parse "(foo bar) foo (((foo)))"))
  +            (teq? '((foo (bar)) (((foo)))) (parse "[foo {bar}] [{(foo)}]"))))
  +
  +  (it "parses unquotes"
  +    (affirm (teq? '((quote foo)) (parse "'foo"))
  +            (teq? '((quote (foo))) (parse "'(foo)"))
  +            (teq? '((syntax-quote foo)) (parse "`foo"))
  +            (teq? '((syntax-quote (foo))) (parse "`(foo)"))))
  +
  +  (it "parses unquotes"
  +    (affirm (teq? '((unquote foo)) (parse ",foo"))
  +            (teq? '((unquote (foo))) (parse ",(foo)"))
  +            (teq? '((unquote-splice foo)) (parse ",@foo"))
  +            (teq? '((unquote-splice (foo))) (parse ",@(foo)"))))
   )
  
positive.code: 
  (defun parse (str)
    "Lex and parse STR"
    (parser/parse (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))))
  
  (defun string->key (key) (struct :tag "key" :value key))
  
  
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"))
  