That's somewhat begging the question, though. Assoc lists aren't hash tables, do...

twopoint718 · on Jan 26, 2009

It's not that tough to make a literal syntax for hash tables with a simple reader macro. This may not be the best way to do it, I'm rather new to lisp, but it only took me about 5 min. (and a peek at "ANSI Common Lisp" 14.3, thanks, PG!):

    (defun ins-hash (h vals)
      (if (oddp (length vals))
          nil
          (if (not (null vals))
              (progn
                (setf (gethash (first vals) h) (second vals))
                (ins-hash h (cddr vals)))
              h)))

    (set-macro-character #\} (get-macro-character #\)))

    (set-dispatch-macro-character #\# #\{
      #'(lambda (stream char1 char2)
          (let ((items (read-delimited-list #\} stream t)))
            (ins-hash (make-hash-table) items))))

    CL-USER> (gethash :b #{:a 1 :b 2 :c 3})
    2
    T

gruseom · on Jan 26, 2009

I don't think it's begging the question. People use the term "hashtable" in a general way to subsume all kinds of associative lookup nowadays. A true hashtable is hardly the best way to represent '((Vincent . 25) (Lincoln . 100)). Your "simple circumstances" happen to be the overwhelming majority of cases one is working with this kind of literal data.

I use alists and hashtables all the time in CL. They're not intended for the same things, and I rarely convert between them.

There are two kinds of CL annoyance: the things that people who use the language to do real work are annoyed by, and the things that people who've dabbled with it enough to write ill-informed blog posts about why they don't want to use CL -- a conclusion they almost certainly started with -- are annoyed by. JRockway, incidentally, has been using CL for a while. He made the mistake, I guess, of attempting to explain something substantial about it to critics who haven't.

Edit: let me say something positive to counteract the Naggumification I seem to be undergoing in responding to these posts. If Clojure attracts the masses because it's shiny and not old like stinky CL, and in order for that to happen people need to convince themselves that hashtables which behave like immutable conses are really the killer feature that Lisp has been lacking all these years, and the net result of all this is lots more people using Lisp, I think that's great.