Hash consing

From Wikipedia, the free encyclopedia
Jump to: navigation, search

In computer science, particularly in functional programming, hash consing is a technique used to share values that are structurally equal. The term hash consing originates from implementations of Lisp[1][2] that attempt to reuse cons cells that have been constructed before, avoiding the penalty of memory allocation. Hash consing is most commonly implemented with hash tables storing weak references that may be garbage-collected when the data stored therein contains no references from outside the table.[3][4] Hash consing has been shown to give dramatic performance improvements—both space and time—for symbolic and dynamic programming algorithms.[citation needed] An interesting property of hash consing is that two structures can be tested for equality in constant time, which in turn can improve efficiency of divide and conquer algorithms when data sets contain overlapping blocks.[5]

In other communities a similar idea is known as the Flyweight pattern. When applied to strings this technique is also known as string interning.



Simple, not very efficient, but suitable for demonstration of the concept implementation of a memoizer by means of hash table and weak references in Scheme:

;; weak hashes
(require 'hash-table)

(define (make-weak-table . args)
  (apply make-hash-table args))

(define (weak-table-set! table key data)
  (let ((w (hash-table-ref table key #f)))
    (if w
        (vector-set! w 0 data)
      (let ((w (make-weak-vector 1)))
        (vector-set! w 0 data)
        (hash-table-set! table key w)))))

(define (weak-table-ref table key)
  (let ((w (hash-table-ref table key #f)))
    (if w
        (vector-ref w 0)

;; memoizer factory: for given (side-effect-free) procedure,
;; return a procedure which does the same memoizing some of results
;; in the sense of equal? on the whole list of args
(define (make-weak-memoizer proc)
  (let ((cache (make-weak-table equal?)))
    (lambda args
      (let ((x (weak-table-ref cache args)))
        (if (bwp-object? x)
            (let ((r (apply proc args)))
              (weak-table-set! cache args r)


  1. ^ Deutsch, Laurence Peter (1973). "An Interactive Program Verifier". Palo Alto: Xerox Palo Alto Research Center Terhnical Report CSL-73-1. 
  2. ^ Goto, Eiichi (1974). "Monocopy and associative algorithms in extended Lisp". Tokyo: University of Tokyo Technical Report TR 74-03. 
  3. ^ Allen, John (1978). Anatomy of Lisp. McGraw Hill. ISBN 0-07-001115-X. 
  4. ^ Fillâtre, Jean-Christophe; Conchon, Sylvain (2006). "Workshop on ML". ACM.  |contribution= ignored (help)
  5. ^ Liljenzin, Olle. "Confluently Persistent Sets and Maps". arXiv:1301.3388Freely accessible. 

Further reading[edit]