hashes all the way

A microbenchmark reveals that alist lookup with assq never beats a hasheq lookup with hash-ref.

quad/quad2/compile.rkt

@@ -26,7 +26,7 @@
 (define/contract (quadify str)
   (string? . -> . (listof quad?))
   (for/list ([c (in-string str)])
-            (make-quad #f (list (cons 'char c)))))
+            (make-quad #f (make-quad-attrs (list (cons 'char c))))))
 
 (define (make-compiler . passes)
   (apply compose1 (reverse (cons quadify passes))))

quad/quad2/quad.rkt

@@ -12,8 +12,8 @@
 (define (quad? x)
   (match x
     [($quad (? quad-tag?)
-             (list (cons symbol? _) ...)
+            (? quad-attrs?)
-             (list _ ...)) #true]
+            (? quad-elems?)) #true]
     [_ #false]))
 
 (struct $quad (tag attrs elems) #:transparent #:mutable)
@@ -24,9 +24,8 @@
                         [_ #false]))
 (define set-quad-tag! set-$quad-tag!)
 (define quad-attrs $quad-attrs)
-(define (quad-attrs? x) (match x
+(define (make-quad-attrs alist) (make-hasheq alist))
-                        [(list (cons (? symbol?) _) ...) #true]
+(define (quad-attrs? x) (hash-eq? x))
-                        [_ #false]))
 (define set-quad-attrs! set-$quad-attrs!)
 (define quad-elems $quad-elems)
 (define (quad-elems? x) (list? x))
@@ -36,11 +35,10 @@
   ((quad-tag? quad-attrs?) #:rest quad-elems? . ->* . quad?)
   ($quad tag attrs elems))
 
-(define (quad-ref q key [default-val #false]) (match (assq key (quad-attrs q))
+(define (quad-ref q key [default-val #false])
-                                             [#false default-val]
+  (hash-ref (quad-attrs q) key default-val))
-                                             [(cons _ val) val]))
 (define (quad-set! q key val)
-  (set-quad-attrs! q (cons (cons key val) (quad-attrs q))))
+  (hash-set! (quad-attrs q) key val))
 
 (define-syntax (define-quad-field stx)
   (syntax-case stx ()
@@ -54,4 +52,4 @@
 (define-quad-field posn)
 (define-quad-field char)
 
-(define q (make-quad 'div '((hello . "world")) "fine"))
+#;(define q (make-quad 'div (make-hasheq '((hello . "world"))) "fine"))