This WG2 proposal defines an interface to hash tables, which are widely recognized as a fundamental data structure for a wide variety of applications. A hash table is a data structure that:
Hash tables themselves don't really need defending: almost all dynamically typed languages, from awk to JavaScript to Lua to Perl to Python to Common Lisp, and including many Scheme implementations, have them in some form as a fundamental data structure. Therefore, what needs to be defended is not the data structure but the procedures. The present proposal is at an intermediate level. It supports a great many convenience procedures on top of the basic hash table interfaces provided by SRFI 69 and R6RS. Nothing in it adds power to what those interfaces provide, but it does add convenience in the form of pre-debugged routines to do various common things, and even some things not so commonly done but useful.
There is no mandated support for thread safety, immutability, or weakness, though there is a semi-portable hook for specifying these features.
The names used in the present proposal are mostly derived from SRFI 69, with the following changes:
The relatively few hash table procedures in R6RS are all available in the present proposal under somewhat different names. The present proposal adopts SRFI 69's term hash-table rather than R6RS's hashtable, because of the universal use of "hash table" rather than "hashtable" in other languages and in technical prose generally. Besides, the English word hashtable obviously means something that can be ... hashted.
In addition, the hashtable-ref and hashtable-update! of R6RS correspond to the hash-table-ref/default and hash-table-update!/default of both SRFI 69 and the present proposal.
It would be trivial to provide the R6RS names (or for that matter the SRFI 69 names) on top of the present proposal. The only substantive difference is that R6RS hashtable-values and hashtable-entries return vectors, whereas in the present proposal hash-table-values and hash-table-entries return lists.
SRFI 69 provides reflective procedures that, given a hash table, returns its equality predicate and hash function, as well as procedures that expose the implementation's hash functions suitable for the equality predicates eq?, equal?, string=?, and string-ci=?. The second of these can also be used for eqv?. However, if the eq? hash function directly exposes the address of the key, and the garbage collector moves the hash table, it must also rehash its keys. In such implementations, the hash-by-identity procedure is not idempotent, which makes it dangerous to use outside the context of implementation-provided hash tables.
R6RS eliminates this issue by providing separate constructors for eq? and eqv? hash tables, and refusing to expose the hash functions for them. However, the presents proposal takes the radical option of providing neither reflection nor implementation-based hash functions. They can of course be provided by implementations as extensions with suitable warnings against inappropriate uses.
As usual, the Common Lisp names are completely different from the Scheme names. Common Lisp provides the following capabilities that are not in the present proposal:
The procedures in the present proposal are drawn primarily from SRFI 69 and R6RS. In addition, the following sources are acknowledged:
The procedures hash-table=?, hash-table-set-entries!, hash-table-replace!, hash-table-replace!/default, hash-table-search!, hash-table-map, hash-table-update-each!, hash-table-intersection!, and hash-table-difference! were added for completeness.
The native hash tables of MIT, Guile, SISC, Bigloo, Scheme48, SLIB, RScheme, Scheme 7, Scheme 9, Rep, and FemtoLisp were also investigated, but no additional procedures were incorporated.
The slash in the names of some procedures can be pronounced "with".
Some of the language of the present proposal is copied from SRFI 69 with thanks to its author, Panu Kalliokoski. However, he is not responsible for what I have made of it.
The procedures in the present proposal are in the (scheme hash-tables) and (srfi xxx) libraries (or (srfi :xxx) on R6RS). However, the library in the sample implementation is named (hash-tables).
All references to "executing in expected amortized constant time" presuppose that a satisfactory hash function has been supplied by the user. Arbitrary or non-idempotent hash functions can make a hash of the implementation.
Hash tables are allowed to cache the results of calling the equality and hash functions, so programs cannot rely on the hash function being called exactly once for every primitive hash table operation: it may be called zero, one, or more times.
No procedure passed to hash-table-find, hash-table-count, hash-table-map, hash-table-for-each, hash-table-update-each!, hash-table-map->list, or hash-table-fold may mutate the hash table being walked, with the exception of changing the value of the association currently being processed.
Here is an index to the procedures of this specification:
(make-hash-table equality [ hash ] [ arg ... ])
Returns a newly allocated hash table whose equality predicate is equality and hash function is hash. The equality predicate accepts two arguments and returns a truth value. The hash function accepts one argument in the domain of the equality predicate and returns a non-negative exact integer. It is the programmer's responsibility to ensure that two objects passed to the hash function return the same value if the same objects passed to the equality predicate return true; however, the converse is not required.
The ability to omit the hash argument is severely limited. If equality is eq?, eqv?, equal?, string=?, or string-ci=?, then if hash is not provided, a suitable implementation-provided procedure will be used; the implementation may use its own procedure in any case. The implementation may extend this list. But if any other equality predicate is provided without a hash function, an error should be signaled.
The meaning of the remaining arguments is implementation-dependent. However, implementations which support the ability to specify the initial capacity of a hash table should interpret a non-negative exact integer as the specification of that capacity. In addition, if the symbols immutable, thread-safe, weak-keys or weak-values are present, implementations should create immutable hash tables, mutable thread-safe hash tables, hash tables with weak keys, and hash tables with weak values respectively. In an implementation which does not support these features, an error should be signaled if they are requested. To avoid collision with the hash argument, none of these arguments can be procedures.
(SRFI 69 make-hash-table; R6RS make-eq-hashtable, make-eqv-hashtable, and make-hashtable; Common Lisp make-hash-table)
(hash-table equality hash ( key value ) ...)
Returns a newly allocated hash table, created as if by make-hash-table, whose equality procedure is equality and hash function is hash. For each pair of arguments, an association is added to the new hash table with key as its key and value as its value.
(hash-table-unfold continue? mapper successor seed equality [ hash ])
Create a new hash table as if by make-hash-table. If the result of applying the predicate continue? to seed is #f, return the hash table. Otherwise, apply the procedure mapper to seed. Mapper returns two values, which are inserted into the hash table as the key and the value respectively. Then get a new seed by applying the procedure successor to seed, and repeat this algorithm.
(hash-table? obj)
Returns #t if obj is a hash table, and #f otherwise. (SRFI 69 hash-table?; R6RS hashtable?; Common Lisp hash-table-p)
(hash-table-contains? hash-table key)
Returns #t if there is any association to key in hash-table, and #f otherwise. Must execute in expected amortized constant time. (SRFI 69 hash-table-exists?; R6RS hashtable-contains?)
(hash-table=? value= hash-table1 hash-table2)
Returns #t if hash-table1 and hash-table2 have the same size, the same keys (in the sense of their common equality predicate) and the same values (in the sense of the value= predicate) for each key, and #f otherwise. It is an error to compare two hash tables that have distinct equality predicates.
The following procedures, given a key, return the corresponding value.
(hash-table-ref hash-table key [ failure [ success ] ])
Extracts the value associated to key in hash-table, invokes the procedure success on it, and returns its result. Otherwise, invokes the procedure failure on no arguments and returns its result. If success is not provided and is required, the value itself is returned. If failure is not provided but is required, an error that satisfies hash-table-not-found? is signaled. Must execute in expected amortized O(1) time, not counting the time to call the procedures. (SRFI 69 hash-table-ref)
(hash-table-ref/default hash-table key default)
Semantically equivalent to, but may be more efficient than, the following code: (hash-table-ref hash-table key (lambda () default))
(SRFI 69 hash-table-ref/default, R6RS hashtable-ref; Common Lisp gethash)
The following procedures alter the associations in a hash table either unconditionally, or conditionally on the presence or absence of a specified key.
(hash-table-set! hash-table key value)
Creates a new association in hash-table that associates key with value. If there is a previous association for key, it is deleted. It is an error if key is not a valid argument to the equality predicate of hash-table. Returns an unspecified value. Must execute in expected amortized constant time. (SRFI 69 hash-table-set!; R6RS hashtable-set!)
(hash-table-set-all! hash-table ( key value ) ...)
Repeatedly mutates hash-table, setting each key to the value that follows it.
(hash-table-set-entries! hash-table keyslist valueslist)
Repeatedly mutates hash-table, setting each element of keyslist to the corresponding element of valueslist in the order given.
(hash-table-set-alist! hash-table alist)
Repeatedly mutates hash-table using the associations of alist in the order given.
(hash-table-delete! hash-table key)
Deletes any association to key in hash-table and returns true if there was an association for key, false if not. Must execute in expected amortized constant time. (SRFI 69 hash-table-delete!; R6RS hashtable-delete!; Common Lisp remhash)
(hash-table-delete-keys! hash-table keylist)
Semantically equivalent to, but may be implemented more efficiently than, the following code:
(for-each (lambda (key) (hash-table-delete hash-table key)) keylist)
(hash-table-extend! hash-table key [ failure [ success ] ])
Invokes hash-table-ref with the given arguments and returns what it returns. If key was not found in hash-table, its value is set to the result being returned.
(hash-table-extend!/default hash-table key default)
Invokes hash-table-ref/default with the given arguments and returns what it returns. If key was not found in hash-table, its association is set to the result being returned.
(hash-table-replace! hash-table key [ failure [ success ] ])
Invokes hash-table-ref with the given arguments and returns what it returns. If key was found in hash-table, its value is set to the result being returned.
(hash-table-replace!/default hash-table key [ default ])
Invokes hash-table-ref/default with the given arguments and returns what it returns. If key was found in hash-table, its value is set to the result being returned.
(hash-table-update! hash-table key updater [ failure [ ''success ] ])
Semantically equivalent to, but may be implemented more efficiently than, the following code:
(hash-table-set! hash-table key (updater (hash-table-ref hash-table key failure success)))
Must execute in expected amortized constant time. Returns an unspecified value. (SRFI 69 hash-table-update!/default; R6RS hashtable-update!)
(hash-table-update!/default hash-table key updater default)
Semantically equivalent to, but may be implemented more efficiently than, the following code:
(hash-table-set! hash-table key (updater (hash-table-ref/default hash-table key default)))
Must execute in expected amortized constant time. Returns an unspecified value. (SRFI 69 hash-table-update!)
(hash-table-push! hash-table key value)
Semantically equivalent to, but may be implemented more efficiently than, the following code:
(hash-table-update!/default hash-table key (lambda (x) (cons value x)) '())
(hash-table-pop! hash-table key)
If an association with key is found in hash-table, then return the car of the value, and update the value to its own cdr. If the value is not found or is not a pair, signal an error.
(hash-table-search! hash-table key failure success)
Search hash-table for key. If it is not found, invoke the failure procedure with one argument, a unary add procedure which if invoked will insert a new association between key and its argument. If key is found, invoke the success procedure with three arguments: the value found, a unary set procedure that updates the association to have the value specified as its argument, and a nullary delete procedure that deletes the association. Returns whatever success or failure returns, as the case may be.
These procedures process the associations of the hash table in arbitrary order.
(hash-table-clear! hash-table)
Delete all the associations from hash-table. Should execute in expected amortized constant time. (R6RS hashtable-clear!; Common Lisp clrhash)
(hash-table-size hash-table)
Returns the number of associations in hash-table as an exact integer. Should execute in expected amortized constant time. (SRFI 69 hash-table-size, R6RS hashtable-size; Common Lisp hash-table-count.)
Returns the number of keys in hash-table.
(hash-table-keys hash-table)
Returns a newly allocated list of all the keys in hash-table in an unspecified order. (SRFI 69 hash-table-keys; R6RS hashtable-keys returns a vector)
(hash-table-values hash-table)
Returns a newly allocated list of all the keys in hash-table in an unspecified order, not necessarily the same order as hash-table-keys. (SRFI 69 hash-table-values)
(hash-table-entries hash-table)
Returns two values, a newly allocated list of all the keys in hash-table in an unspecified order and a newly allocated of all the values in hash-table in the corresponding order. (R6RS hash-table-entries returns vectors)
(hash-table-find hash-table proc)
For each association of hash-table, invoke proc on its key and value in an unspecified order. If proc returns true, then return the value. If proc always returns #f, return #f.
(hash-table-count hash-table pred)
For each association of hash-table, invoke pred on its key and value in an unspecified order. Return the number of calls to pred which returned true.
These procedures process the associations of the hash table in arbitrary order.
(hash-table-map equality hash proc merger hash-table)
Returns a newly allocated hash table as if by make-hash-table. Calls proc for every association in hash-table with two arguments: the key of the association and the value of the association. The two values returned by proc are inserted into the new hash table as a key and value.
When the key being added already exists in the hash table, the procedure merger is called with arguments oldkey oldvalue newkey newvalue and returns the value to be associated with that key.
(hash-table-for-each proc hash-table)
Calls proc for every association in hash-table with two arguments: the key of the association and the value of the association. The value returned by proc is discarded.Returns an unspecified value. (SRFI 69 hash-table-walk with the arguments reversed; Common Lisp maphash)
(hash-table-update-each! proc hash-table)
Calls proc for every association in hash-table with two arguments: the key of the association and the value of the association. The value returned by proc is used to update the association. Returns an unspecified value.
(hash-table-map->list proc hash-table)
Calls proc for every association in hash-table with two arguments: the key of the association and the value of the association. The value returned by proc is accumulated into a list, which is returned.
(hash-table-fold proc init hash-table)
Calls proc for every association in hash-table with three arguments: the key of the association, the value of the association, and an accumulated value val. Val is init for the first invocation of procedure, and for subsequent invocations of procedure, the returned value of the previous invocation. The value returned by hash-table-fold is the return value of the last invocation of proc. (SRFI 69 hash-table-fold has the hash-table as the first argument)
(hash-table-copy hash-table)
Returns a newly allocated hash table with the same properties and associations as hash-table. (SRFI 69 hash-table-copy; R6RS hashtable-copy, passing #t as the second argument)
(hash-table->alist hash-table)
Returns an alist with the same associations as hash-table in an unspecified order.
(alist->hash-table alist equality hash)
Returns a newly allocated hash-table as if by make-hash-table, initializing it from the associations of alist. (SRFI 69 alist->hash-table)
The following procedures allow hash tables to be used as functions with mutable behavior. In this way, for example, lists can be processed by map using the procedure returned from a hash table by hash-table-accessor.
(hash-table-accessor hash-table [ failure [ success ] ])
Curried version of hash-table-ref. Returns a procedure of one argument, a key, which returns what hash-table-ref returns when invoked with the hashtable argument, the passed key, and the failure and success arguments.
(hash-table-accessor/default hash-table default)
Curried version of hash-table-ref/default. Returns a procedure of one argument, a key, which returns what hash-table-ref/default returns when invoked with the hashtable argument, the passed key, and the default argument.
(hash-table-union! hash-table1 hash-table2 [ merger ])
Adds the associations of hash-table2 to hash-table1 and returns hash-table1. The values are merged using the result of invoking the merger procedure, which accepts the arguments key1 value1 key2 value2 and defaults to (lambda (key1 value1 key2 value2) value2). (SRFI 69 hash-table-merge!)
(hash-table-intersection! hash-table1 hash-table2 [ merger ])
Deletes the associations from hash-table1 which don't also appear in hash-table2 and returns hash-table1, and merges the values of those that appear in both hash tables using the result of invoking the merger procedure, which accepts the arguments key1 value1 key2 value2 and defaults to (lambda (key1 value1 key2 value2) value2).
(hash-table-difference! hash-table1 hash-table2)
Deletes the associations of hash-table1 whose keys are also present in hash-table2 and returns hash-table1.
(hash-table-not-found? obj)
Returns #t if obj is an object raised by the hash-table-ref procedure or any other procedure that accesses hash tables when the key is not found and there is no failure procedure, and #f otherwise.
The sample implementation (not yet written) is designed to be easily layered over any hash table implementation that supports either SRFI 69 or R6RS (there is an implementation of SRFI 69 on top of R6RS, It was originally intended to support all the native hash table systems mentioned in [#Sources Sources] above as well. However, this turned out not to be practical for the following reasons:
As a result, the sample implementation assumes the existence of a SRFI 69 implementation, and imports just the core procedures make-hash-table, hash-table?, hash-table-ref/default, hash-table-set!, hash-table-delete!, hash-table-size, hash-table-walk, and hash-table-copy. New implementers who need to support the present proposal from scratch can take the implementations of these procedures from the SRFI 69 implementation and add them to this implementation.
To layer the implementation directly on top of R6RS, the corresponding procedures need to be imported from (rnrs hashtables). See the file hash-tables.sls in the implementation. It should also be possible to adapt the sample implementation for use on Racket, MIT, Gambit, and Bigloo.