suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add optional initialization argument to make-hash (and variants)

Browse Source 
svn: r18120
This commit is contained in:
Matthew Flatt 2010-02-17 17:44:29 +00:00
parent 0cab35fdcb
commit 91d725fbb9
3 changed files with 93 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
collects/scribblings/reference/hashes.scrbl
View File

@ -103,53 +103,60 @@ Returns @scheme[#t] if @scheme[hash] retains its keys weakly,
@scheme[#f] if it retains keys strongly.}
@defproc[(make-hash) hash?]{
@defproc[(make-hash [assocs (listof pair?) null]) hash?]{
Creates an empty mutable hash table that holds keys strongly and that
uses @scheme[equal?] to compare keys. See also
@scheme[make-custom-hash].}
Creates a mutable hash table that holds keys strongly and that uses
@scheme[equal?] to compare keys. See also @scheme[make-custom-hash].
The table is initialized with the content of @scheme[assocs]. In each
element of @scheme[assocs], the @scheme[car] is a key, and the
@scheme[cdr] is the corresponding value. The mappings are added to the
table in the order that they appear in @scheme[assocs], so later
mappings can hide earlier mappings.}
@defproc[(make-hasheqv) (and/c hash? hash-eqv?)]{
@defproc[(make-hasheqv [assocs (listof pair?) null]) (and/c hash? hash-eqv?)]{
Creates an empty mutable hash table that holds keys strongly and that
uses @scheme[eqv?] to compare keys.}
Creates a mutable hash table that holds keys strongly and that
uses @scheme[eqv?] to compare keys. The table is initialized with the
content of @scheme[assocs] as in @scheme[make-hash].}
@defproc[(make-hasheq) (and/c hash? hash-eq?)]{
@defproc[(make-hasheq [assocs (listof pair?) null]) (and/c hash? hash-eq?)]{
Creates an empty mutable hash table that holds keys strongly and that
uses @scheme[eq?] to compare keys.}
Creates a mutable hash table that holds keys strongly and that
uses @scheme[eq?] to compare keys. The table is initialized with the
content of @scheme[assocs] as in @scheme[make-hash].}
@defproc[(make-weak-hash) (and/c hash? hash-weak?)]{
@defproc[(make-weak-hash [assocs (listof pair?) null]) (and/c hash? hash-weak?)]{
Creates an empty mutable hash table that holds keys weakly and that
uses @scheme[equal?] to compare keys. See also
@scheme[make-weak-custom-hash].}
Creates a mutable hash table that holds keys weakly and that
uses @scheme[equal?] to compare keys; see also
@scheme[make-weak-custom-hash]. The table is initialized with the
content of @scheme[assocs] as in @scheme[make-hash].}
@defproc[(make-weak-hasheqv) (and/c hash? hash-eqv? hash-weak?)]{
@defproc[(make-weak-hasheqv [assocs (listof pair?) null]) (and/c hash? hash-eqv? hash-weak?)]{
Creates an empty mutable hash table that holds keys weakly and that
uses @scheme[eqv?] to compare keys.}
Creates a mutable hash table that holds keys weakly and that
uses @scheme[eqv?] to compare keys. The table is initialized with the
content of @scheme[assocs] as in @scheme[make-hash].}
@defproc[(make-weak-hasheq) (and/c hash? hash-eq? hash-weak?)]{
@defproc[(make-weak-hasheq [assocs (listof pair?) null]) (and/c hash? hash-eq? hash-weak?)]{
Creates an empty mutable hash table that holds keys weakly and that
uses @scheme[eq?] to compare keys.}
Creates a mutable hash table that holds keys weakly and that
uses @scheme[eq?] to compare keys. The table is initialized with the
content of @scheme[assocs] as in @scheme[make-hash].}
@defproc[(make-immutable-hash [assocs (listof pair?)])
(and/c hash? immutable?)]{
Creates an immutable hash table that compares keys with
@scheme[equal?]. In each element of @scheme[assocs], the @scheme[car]
of each pair is a key, and the @scheme[cdr] is the corresponding
value. The mappings are added to the table in the order that they
appear in @scheme[assocs], so later mappings can hide earlier
mappings.}
@scheme[equal?]. The table is created with the content of
@scheme[assocs] as in @scheme[make-hash].}
@defproc[(make-immutable-hasheqv [assocs (listof pair?)])
(and/c hash? hash-eqv? immutable?)]{

12
collects/tests/mzscheme/basic.ss
View File

@ -1967,12 +1967,12 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; hash tables
(arity-test make-hash 0 0)
(arity-test make-hasheq 0 0)
(arity-test make-hasheqv 0 0)
(arity-test make-weak-hash 0 0)
(arity-test make-weak-hasheq 0 0)
(arity-test make-weak-hasheqv 0 0)
(arity-test make-hash 0 1)
(arity-test make-hasheq 0 1)
(arity-test make-hasheqv 0 1)
(arity-test make-weak-hash 0 1)
(arity-test make-weak-hasheq 0 1)
(arity-test make-weak-hasheqv 0 1)
(define (hash-tests make-hash make-hasheq make-hasheqv
make-weak-hash make-weak-hasheq make-weak-hasheqv

67
src/mzscheme/src/list.c
View File

@ -459,32 +459,32 @@ scheme_init_list (Scheme_Env *env)
scheme_add_global_constant("make-hash",
scheme_make_immed_prim(make_hash,
"make-hash",
0, 0),
0, 1),
env);
scheme_add_global_constant("make-hasheq",
scheme_make_immed_prim(make_hasheq,
"make-hasheq",
0, 0),
0, 1),
env);
scheme_add_global_constant("make-hasheqv",
scheme_make_immed_prim(make_hasheqv,
"make-hasheqv",
0, 0),
0, 1),
env);
scheme_add_global_constant("make-weak-hash",
scheme_make_immed_prim(make_weak_hash,
"make-weak-hash",
0, 0),
0, 1),
env);
scheme_add_global_constant("make-weak-hasheq",
scheme_make_immed_prim(make_weak_hasheq,
"make-weak-hasheq",
0, 0),
0, 1),
env);
scheme_add_global_constant("make-weak-hasheqv",
scheme_make_immed_prim(make_weak_hasheqv,
"make-weak-hasheqv",
0, 0),
0, 1),
env);
scheme_add_global_constant("make-immutable-hash",
scheme_make_immed_prim(make_immutable_hash,
@ -1555,34 +1555,77 @@ Scheme_Bucket_Table *scheme_make_weak_eqv_table(void)
return t;
}
static Scheme_Object *fill_table(Scheme_Object *ht, const char *who,
int argc, Scheme_Object **argv)
{
Scheme_Object *l, *a, *args[3];
if (argc) {
l = argv[0];
if (scheme_proper_list_length(l) >= 0) {
for (; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
a = SCHEME_CAR(l);
if (!SCHEME_PAIRP(a))
break;
}
}
if (!SCHEME_NULLP(l))
scheme_wrong_type(who, "list of pairs", 0, argc, argv);
args[0] = ht;
for (l = argv[0]; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) {
a = SCHEME_CAR(l);
args[1] = SCHEME_CAR(a);
args[2] = SCHEME_CDR(a);
hash_table_put_bang(3, args);
}
}
return ht;
}
static Scheme_Object *make_hash(int argc, Scheme_Object *argv[])
{
return (Scheme_Object *)scheme_make_hash_table_equal();
Scheme_Object *ht;
ht = (Scheme_Object *)scheme_make_hash_table_equal();
return fill_table(ht, "make-hash", argc, argv);
}
static Scheme_Object *make_hasheq(int argc, Scheme_Object *argv[])
{
return (Scheme_Object *)scheme_make_hash_table(SCHEME_hash_ptr);
Scheme_Object *ht;
ht = (Scheme_Object *)scheme_make_hash_table(SCHEME_hash_ptr);
return fill_table(ht, "make-hasheq", argc, argv);
}
static Scheme_Object *make_hasheqv(int argc, Scheme_Object *argv[])
{
return (Scheme_Object *)scheme_make_hash_table_eqv();
Scheme_Object *ht;
ht = (Scheme_Object *)scheme_make_hash_table_eqv();
return fill_table(ht, "make-hasheqv", argc, argv);
}
static Scheme_Object *make_weak_hash(int argc, Scheme_Object *argv[])
{
return (Scheme_Object *)scheme_make_weak_equal_table();
Scheme_Object *ht;
ht = (Scheme_Object *)scheme_make_weak_equal_table();
return fill_table(ht, "make-weak-hash", argc, argv);
}
static Scheme_Object *make_weak_hasheq(int argc, Scheme_Object *argv[])
{
return (Scheme_Object *)scheme_make_bucket_table(20, SCHEME_hash_weak_ptr);
Scheme_Object *ht;
ht = (Scheme_Object *)scheme_make_bucket_table(20, SCHEME_hash_weak_ptr);
return fill_table(ht, "make-weak-hasheq", argc, argv);
}
static Scheme_Object *make_weak_hasheqv(int argc, Scheme_Object *argv[])
{
return (Scheme_Object *)scheme_make_weak_eqv_table();
Scheme_Object *ht;
ht = (Scheme_Object *)scheme_make_weak_eqv_table();
return fill_table(ht, "make-weak-hasheqv", argc, argv);
}
static Scheme_Object *make_immutable_table(const char *who, int kind, int argc, Scheme_Object *argv[])