marcuskammer/cl-sites
1
0
Fork 0
Code Activity
cl-sites/guile.html_node/Hash-Table-Reference.html

334 lines
32 KiB
HTML
Raw Normal View History

Add guile manual
2024-12-17 12:49:28 +01:00
<!DOCTYPE html>
<html>
<!-- Created by GNU Texinfo 7.1, https://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<!-- This manual documents Guile version 3.0.10.
Copyright (C) 1996-1997, 2000-2005, 2009-2023 Free Software Foundation,
Inc.
Copyright (C) 2021 Maxime Devos
Copyright (C) 2024 Tomas Volf
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A
copy of the license is included in the section entitled "GNU Free
Documentation License." -->
<title>Hash Table Reference (Guile Reference Manual)</title>
<meta name="description" content="Hash Table Reference (Guile Reference Manual)">
<meta name="keywords" content="Hash Table Reference (Guile Reference Manual)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content=".texi2any-real">
<meta name="viewport" content="width=device-width,initial-scale=1">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Hash-Tables.html" rel="up" title="Hash Tables">
<link href="Hash-Table-Examples.html" rel="prev" title="Hash Table Examples">
<style type="text/css">
<!--
a.copiable-link {visibility: hidden; text-decoration: none; line-height: 0em}
div.example {margin-left: 3.2em}
span:hover a.copiable-link {visibility: visible}
strong.def-name {font-family: monospace; font-weight: bold; font-size: larger}
-->
</style>
<link rel="stylesheet" type="text/css" href="https://www.gnu.org/software/gnulib/manual.css">
</head>
<body lang="en">
<div class="subsubsection-level-extent" id="Hash-Table-Reference">
<div class="nav-panel">
<p>
Previous: <a href="Hash-Table-Examples.html" accesskey="p" rel="prev">Hash Table Examples</a>, Up: <a href="Hash-Tables.html" accesskey="u" rel="up">Hash Tables</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<h4 class="subsubsection" id="Hash-Table-Reference-1"><span>6.6.22.2 Hash Table Reference<a class="copiable-link" href="#Hash-Table-Reference-1"> &para;</a></span></h4>
<p>Like the association list functions, the hash table functions come in
several varieties, according to the equality test used for the keys.
Plain <code class="code">hash-</code> functions use <code class="code">equal?</code>, <code class="code">hashq-</code>
functions use <code class="code">eq?</code>, <code class="code">hashv-</code> functions use <code class="code">eqv?</code>, and
the <code class="code">hashx-</code> functions use an application supplied test.
</p>
<p>A single <code class="code">make-hash-table</code> creates a hash table suitable for use
with any set of functions, but it&rsquo;s imperative that just one set is
then used consistently, or results will be unpredictable.
</p>
<p>Hash tables are implemented as a vector indexed by a hash value formed
from the key, with an association list of key/value pairs for each
bucket in case distinct keys hash together. Direct access to the
pairs in those lists is provided by the <code class="code">-handle-</code> functions.
</p>
<p>When the number of entries in a hash table goes above a threshold, the
vector is made larger and the entries are rehashed, to prevent the
bucket lists from becoming too long and slowing down accesses. When the
number of entries goes below a threshold, the vector is shrunk to save
space.
</p>
<p>For the <code class="code">hashx-</code> &ldquo;extended&rdquo; routines, an application supplies a
<var class="var">hash</var> function producing an integer index like <code class="code">hashq</code> etc
below, and an <var class="var">assoc</var> alist search function like <code class="code">assq</code> etc
(see <a class="pxref" href="Retrieving-Alist-Entries.html">Retrieving Alist Entries</a>). Here&rsquo;s an example of such
functions implementing case-insensitive hashing of string keys,
</p>
<div class="example">
<pre class="example-preformatted">(use-modules (srfi srfi-1)
(srfi srfi-13))
(define (my-hash str size)
(remainder (string-hash-ci str) size))
(define (my-assoc str alist)
(find (lambda (pair) (string-ci=? str (car pair))) alist))
(define my-table (make-hash-table))
(hashx-set! my-hash my-assoc my-table &quot;foo&quot; 123)
(hashx-ref my-hash my-assoc my-table &quot;FOO&quot;)
&rArr; 123
</pre></div>
<p>In a <code class="code">hashx-</code> <var class="var">hash</var> function the aim is to spread keys
across the vector, so bucket lists don&rsquo;t become long. But the actual
values are arbitrary as long as they&rsquo;re in the range 0 to
<em class="math"><var class="var">size</var>-1</em>. Helpful functions for forming a hash value, in
addition to <code class="code">hashq</code> etc below, include <code class="code">symbol-hash</code>
(see <a class="pxref" href="Symbol-Keys.html">Symbols as Lookup Keys</a>), <code class="code">string-hash</code> and <code class="code">string-hash-ci</code>
(see <a class="pxref" href="String-Comparison.html">String Comparison</a>), and <code class="code">char-set-hash</code>
(see <a class="pxref" href="Character-Set-Predicates_002fComparison.html">Character Set Predicates/Comparison</a>).
</p>
<br>
<dl class="first-deffn">
<dt class="deffn" id="index-make_002dhash_002dtable"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">make-hash-table</strong> <var class="def-var-arguments">[size]</var><a class="copiable-link" href="#index-make_002dhash_002dtable"> &para;</a></span></dt>
<dd><p>Create a new hash table object, with an optional minimum
vector <var class="var">size</var>.
</p>
<p>When <var class="var">size</var> is given, the table vector will still grow and shrink
automatically, as described above, but with <var class="var">size</var> as a minimum.
If an application knows roughly how many entries the table will hold
then it can use <var class="var">size</var> to avoid rehashing when initial entries are
added.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-alist_002d_003ehash_002dtable"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">alist-&gt;hash-table</strong> <var class="def-var-arguments">alist</var><a class="copiable-link" href="#index-alist_002d_003ehash_002dtable"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-alist_002d_003ehashq_002dtable"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">alist-&gt;hashq-table</strong> <var class="def-var-arguments">alist</var><a class="copiable-link" href="#index-alist_002d_003ehashq_002dtable"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-alist_002d_003ehashv_002dtable"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">alist-&gt;hashv-table</strong> <var class="def-var-arguments">alist</var><a class="copiable-link" href="#index-alist_002d_003ehashv_002dtable"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-alist_002d_003ehashx_002dtable"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">alist-&gt;hashx-table</strong> <var class="def-var-arguments">hash assoc alist</var><a class="copiable-link" href="#index-alist_002d_003ehashx_002dtable"> &para;</a></span></dt>
<dd><p>Convert <var class="var">alist</var> into a hash table. When keys are repeated in
<var class="var">alist</var>, the leftmost association takes precedence.
</p>
<div class="example">
<pre class="example-preformatted">(use-modules (ice-9 hash-table))
(alist-&gt;hash-table '((foo . 1) (bar . 2)))
</pre></div>
<p>When converting to an extended hash table, custom <var class="var">hash</var> and
<var class="var">assoc</var> procedures must be provided.
</p>
<div class="example">
<pre class="example-preformatted">(alist-&gt;hashx-table hash assoc '((foo . 1) (bar . 2)))
</pre></div>
</dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dtable_003f"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-table?</strong> <var class="def-var-arguments">obj</var><a class="copiable-link" href="#index-hash_002dtable_003f"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005ftable_005fp"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_table_p</strong> <var class="def-var-arguments">(obj)</var><a class="copiable-link" href="#index-scm_005fhash_005ftable_005fp"> &para;</a></span></dt>
<dd><p>Return <code class="code">#t</code> if <var class="var">obj</var> is a abstract hash table object.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dclear_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-clear!</strong> <var class="def-var-arguments">table</var><a class="copiable-link" href="#index-hash_002dclear_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005fclear_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_clear_x</strong> <var class="def-var-arguments">(table)</var><a class="copiable-link" href="#index-scm_005fhash_005fclear_005fx"> &para;</a></span></dt>
<dd><p>Remove all items from <var class="var">table</var> (without triggering a resize).
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dref"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-ref</strong> <var class="def-var-arguments">table key [dflt]</var><a class="copiable-link" href="#index-hash_002dref"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashq_002dref"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashq-ref</strong> <var class="def-var-arguments">table key [dflt]</var><a class="copiable-link" href="#index-hashq_002dref"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashv_002dref"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashv-ref</strong> <var class="def-var-arguments">table key [dflt]</var><a class="copiable-link" href="#index-hashv_002dref"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashx_002dref"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashx-ref</strong> <var class="def-var-arguments">hash assoc table key [dflt]</var><a class="copiable-link" href="#index-hashx_002dref"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005fref"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_ref</strong> <var class="def-var-arguments">(table, key, dflt)</var><a class="copiable-link" href="#index-scm_005fhash_005fref"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashq_005fref"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashq_ref</strong> <var class="def-var-arguments">(table, key, dflt)</var><a class="copiable-link" href="#index-scm_005fhashq_005fref"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashv_005fref"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashv_ref</strong> <var class="def-var-arguments">(table, key, dflt)</var><a class="copiable-link" href="#index-scm_005fhashv_005fref"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashx_005fref"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashx_ref</strong> <var class="def-var-arguments">(hash, assoc, table, key, dflt)</var><a class="copiable-link" href="#index-scm_005fhashx_005fref"> &para;</a></span></dt>
<dd><p>Lookup <var class="var">key</var> in the given hash <var class="var">table</var>, and return the
associated value. If <var class="var">key</var> is not found, return <var class="var">dflt</var>, or
<code class="code">#f</code> if <var class="var">dflt</var> is not given.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dset_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-set!</strong> <var class="def-var-arguments">table key val</var><a class="copiable-link" href="#index-hash_002dset_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashq_002dset_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashq-set!</strong> <var class="def-var-arguments">table key val</var><a class="copiable-link" href="#index-hashq_002dset_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashv_002dset_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashv-set!</strong> <var class="def-var-arguments">table key val</var><a class="copiable-link" href="#index-hashv_002dset_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashx_002dset_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashx-set!</strong> <var class="def-var-arguments">hash assoc table key val</var><a class="copiable-link" href="#index-hashx_002dset_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005fset_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_set_x</strong> <var class="def-var-arguments">(table, key, val)</var><a class="copiable-link" href="#index-scm_005fhash_005fset_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashq_005fset_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashq_set_x</strong> <var class="def-var-arguments">(table, key, val)</var><a class="copiable-link" href="#index-scm_005fhashq_005fset_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashv_005fset_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashv_set_x</strong> <var class="def-var-arguments">(table, key, val)</var><a class="copiable-link" href="#index-scm_005fhashv_005fset_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashx_005fset_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashx_set_x</strong> <var class="def-var-arguments">(hash, assoc, table, key, val)</var><a class="copiable-link" href="#index-scm_005fhashx_005fset_005fx"> &para;</a></span></dt>
<dd><p>Associate <var class="var">val</var> with <var class="var">key</var> in the given hash <var class="var">table</var>. If
<var class="var">key</var> is already present then it&rsquo;s associated value is changed.
If it&rsquo;s not present then a new entry is created.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dremove_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-remove!</strong> <var class="def-var-arguments">table key</var><a class="copiable-link" href="#index-hash_002dremove_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashq_002dremove_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashq-remove!</strong> <var class="def-var-arguments">table key</var><a class="copiable-link" href="#index-hashq_002dremove_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashv_002dremove_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashv-remove!</strong> <var class="def-var-arguments">table key</var><a class="copiable-link" href="#index-hashv_002dremove_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashx_002dremove_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashx-remove!</strong> <var class="def-var-arguments">hash assoc table key</var><a class="copiable-link" href="#index-hashx_002dremove_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005fremove_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_remove_x</strong> <var class="def-var-arguments">(table, key)</var><a class="copiable-link" href="#index-scm_005fhash_005fremove_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashq_005fremove_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashq_remove_x</strong> <var class="def-var-arguments">(table, key)</var><a class="copiable-link" href="#index-scm_005fhashq_005fremove_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashv_005fremove_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashv_remove_x</strong> <var class="def-var-arguments">(table, key)</var><a class="copiable-link" href="#index-scm_005fhashv_005fremove_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashx_005fremove_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashx_remove_x</strong> <var class="def-var-arguments">(hash, assoc, table, key)</var><a class="copiable-link" href="#index-scm_005fhashx_005fremove_005fx"> &para;</a></span></dt>
<dd><p>Remove any association for <var class="var">key</var> in the given hash <var class="var">table</var>.
If <var class="var">key</var> is not in <var class="var">table</var> then nothing is done.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash</strong> <var class="def-var-arguments">key size</var><a class="copiable-link" href="#index-hash"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashq"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashq</strong> <var class="def-var-arguments">key size</var><a class="copiable-link" href="#index-hashq"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashv"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashv</strong> <var class="def-var-arguments">key size</var><a class="copiable-link" href="#index-hashv"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash</strong> <var class="def-var-arguments">(key, size)</var><a class="copiable-link" href="#index-scm_005fhash"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashq"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashq</strong> <var class="def-var-arguments">(key, size)</var><a class="copiable-link" href="#index-scm_005fhashq"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashv"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashv</strong> <var class="def-var-arguments">(key, size)</var><a class="copiable-link" href="#index-scm_005fhashv"> &para;</a></span></dt>
<dd><p>Return a hash value for <var class="var">key</var>. This is a number in the range
<em class="math">0</em> to <em class="math"><var class="var">size</var>-1</em>, which is suitable for use in a hash
table of the given <var class="var">size</var>.
</p>
<p>Note that <code class="code">hashq</code> and <code class="code">hashv</code> may use internal addresses of
objects, so if an object is garbage collected and re-created it can
have a different hash value, even when the two are notionally
<code class="code">eq?</code>. For instance with symbols,
</p>
<div class="example">
<pre class="example-preformatted">(hashq 'something 123) &rArr; 19
(gc)
(hashq 'something 123) &rArr; 62
</pre></div>
<p>In normal use this is not a problem, since an object entered into a
hash table won&rsquo;t be garbage collected until removed. It&rsquo;s only if
hashing calculations are somehow separated from normal references that
its lifetime needs to be considered.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dget_002dhandle"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-get-handle</strong> <var class="def-var-arguments">table key</var><a class="copiable-link" href="#index-hash_002dget_002dhandle"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashq_002dget_002dhandle"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashq-get-handle</strong> <var class="def-var-arguments">table key</var><a class="copiable-link" href="#index-hashq_002dget_002dhandle"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashv_002dget_002dhandle"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashv-get-handle</strong> <var class="def-var-arguments">table key</var><a class="copiable-link" href="#index-hashv_002dget_002dhandle"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashx_002dget_002dhandle"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashx-get-handle</strong> <var class="def-var-arguments">hash assoc table key</var><a class="copiable-link" href="#index-hashx_002dget_002dhandle"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005fget_005fhandle"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_get_handle</strong> <var class="def-var-arguments">(table, key)</var><a class="copiable-link" href="#index-scm_005fhash_005fget_005fhandle"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashq_005fget_005fhandle"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashq_get_handle</strong> <var class="def-var-arguments">(table, key)</var><a class="copiable-link" href="#index-scm_005fhashq_005fget_005fhandle"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashv_005fget_005fhandle"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashv_get_handle</strong> <var class="def-var-arguments">(table, key)</var><a class="copiable-link" href="#index-scm_005fhashv_005fget_005fhandle"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashx_005fget_005fhandle"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashx_get_handle</strong> <var class="def-var-arguments">(hash, assoc, table, key)</var><a class="copiable-link" href="#index-scm_005fhashx_005fget_005fhandle"> &para;</a></span></dt>
<dd><p>Return the <code class="code">(<var class="var">key</var> . <var class="var">value</var>)</code> pair for <var class="var">key</var> in the
given hash <var class="var">table</var>, or <code class="code">#f</code> if <var class="var">key</var> is not in
<var class="var">table</var>.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dcreate_002dhandle_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-create-handle!</strong> <var class="def-var-arguments">table key init</var><a class="copiable-link" href="#index-hash_002dcreate_002dhandle_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashq_002dcreate_002dhandle_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashq-create-handle!</strong> <var class="def-var-arguments">table key init</var><a class="copiable-link" href="#index-hashq_002dcreate_002dhandle_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashv_002dcreate_002dhandle_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashv-create-handle!</strong> <var class="def-var-arguments">table key init</var><a class="copiable-link" href="#index-hashv_002dcreate_002dhandle_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hashx_002dcreate_002dhandle_0021"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hashx-create-handle!</strong> <var class="def-var-arguments">hash assoc table key init</var><a class="copiable-link" href="#index-hashx_002dcreate_002dhandle_0021"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005fcreate_005fhandle_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_create_handle_x</strong> <var class="def-var-arguments">(table, key, init)</var><a class="copiable-link" href="#index-scm_005fhash_005fcreate_005fhandle_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashq_005fcreate_005fhandle_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashq_create_handle_x</strong> <var class="def-var-arguments">(table, key, init)</var><a class="copiable-link" href="#index-scm_005fhashq_005fcreate_005fhandle_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashv_005fcreate_005fhandle_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashv_create_handle_x</strong> <var class="def-var-arguments">(table, key, init)</var><a class="copiable-link" href="#index-scm_005fhashv_005fcreate_005fhandle_005fx"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhashx_005fcreate_005fhandle_005fx"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hashx_create_handle_x</strong> <var class="def-var-arguments">(hash, assoc, table, key, init)</var><a class="copiable-link" href="#index-scm_005fhashx_005fcreate_005fhandle_005fx"> &para;</a></span></dt>
<dd><p>Return the <code class="code">(<var class="var">key</var> . <var class="var">value</var>)</code> pair for <var class="var">key</var> in the
given hash <var class="var">table</var>. If <var class="var">key</var> is not in <var class="var">table</var> then
create an entry for it with <var class="var">init</var> as the value, and return that
pair.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dmap_002d_003elist"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-map-&gt;list</strong> <var class="def-var-arguments">proc table</var><a class="copiable-link" href="#index-hash_002dmap_002d_003elist"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-hash_002dfor_002deach"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-for-each</strong> <var class="def-var-arguments">proc table</var><a class="copiable-link" href="#index-hash_002dfor_002deach"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005fmap_005fto_005flist"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_map_to_list</strong> <var class="def-var-arguments">(proc, table)</var><a class="copiable-link" href="#index-scm_005fhash_005fmap_005fto_005flist"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005ffor_005feach"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_for_each</strong> <var class="def-var-arguments">(proc, table)</var><a class="copiable-link" href="#index-scm_005fhash_005ffor_005feach"> &para;</a></span></dt>
<dd><p>Apply <var class="var">proc</var> to the entries in the given hash <var class="var">table</var>. Each
call is <code class="code">(<var class="var">proc</var> <var class="var">key</var> <var class="var">value</var>)</code>. <code class="code">hash-map-&gt;list</code>
returns a list of the results from these calls, <code class="code">hash-for-each</code>
discards the results and returns an unspecified value.
</p>
<p>Calls are made over the table entries in an unspecified order, and for
<code class="code">hash-map-&gt;list</code> the order of the values in the returned list is
unspecified. Results will be unpredictable if <var class="var">table</var> is modified
while iterating.
</p>
<p>For example the following returns a new alist comprising all the
entries from <code class="code">mytable</code>, in no particular order.
</p>
<div class="example">
<pre class="example-preformatted">(hash-map-&gt;list cons mytable)
</pre></div>
</dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dfor_002deach_002dhandle"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-for-each-handle</strong> <var class="def-var-arguments">proc table</var><a class="copiable-link" href="#index-hash_002dfor_002deach_002dhandle"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005ffor_005feach_005fhandle"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_for_each_handle</strong> <var class="def-var-arguments">(proc, table)</var><a class="copiable-link" href="#index-scm_005fhash_005ffor_005feach_005fhandle"> &para;</a></span></dt>
<dd><p>Apply <var class="var">proc</var> to the entries in the given hash <var class="var">table</var>. Each
call is <code class="code">(<var class="var">proc</var> <var class="var">handle</var>)</code>, where <var class="var">handle</var> is a
<code class="code">(<var class="var">key</var> . <var class="var">value</var>)</code> pair. Return an unspecified value.
</p>
<p><code class="code">hash-for-each-handle</code> differs from <code class="code">hash-for-each</code> only in
the argument list of <var class="var">proc</var>.
</p></dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dfold"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-fold</strong> <var class="def-var-arguments">proc init table</var><a class="copiable-link" href="#index-hash_002dfold"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005ffold"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_fold</strong> <var class="def-var-arguments">(proc, init, table)</var><a class="copiable-link" href="#index-scm_005fhash_005ffold"> &para;</a></span></dt>
<dd><p>Accumulate a result by applying <var class="var">proc</var> to the elements of the
given hash <var class="var">table</var>. Each call is <code class="code">(<var class="var">proc</var> <var class="var">key</var>
<var class="var">value</var> <var class="var">prior-result</var>)</code>, where <var class="var">key</var> and <var class="var">value</var> are
from the <var class="var">table</var> and <var class="var">prior-result</var> is the return from the
previous <var class="var">proc</var> call. For the first call, <var class="var">prior-result</var> is
the given <var class="var">init</var> value.
</p>
<p>Calls are made over the table entries in an unspecified order.
Results will be unpredictable if <var class="var">table</var> is modified while
<code class="code">hash-fold</code> is running.
</p>
<p>For example, the following returns a count of how many keys in
<code class="code">mytable</code> are strings.
</p>
<div class="example">
<pre class="example-preformatted">(hash-fold (lambda (key value prior)
(if (string? key) (1+ prior) prior))
0 mytable)
</pre></div>
</dd></dl>
<dl class="first-deffn">
<dt class="deffn" id="index-hash_002dcount"><span class="category-def">Scheme Procedure: </span><span><strong class="def-name">hash-count</strong> <var class="def-var-arguments">pred table</var><a class="copiable-link" href="#index-hash_002dcount"> &para;</a></span></dt>
<dt class="deffnx def-cmd-deffn" id="index-scm_005fhash_005fcount"><span class="category-def">C Function: </span><span><strong class="def-name">scm_hash_count</strong> <var class="def-var-arguments">(pred, table)</var><a class="copiable-link" href="#index-scm_005fhash_005fcount"> &para;</a></span></dt>
<dd><p>Return the number of elements in the given hash <var class="var">table</var> that cause
<code class="code">(<var class="var">pred</var> <var class="var">key</var> <var class="var">value</var>)</code> to return true. To quickly
determine the total number of elements, use <code class="code">(const #t)</code> for
<var class="var">pred</var>.
</p></dd></dl>
</div>
<hr>
<div class="nav-panel">
<p>
Previous: <a href="Hash-Table-Examples.html">Hash Table Examples</a>, Up: <a href="Hash-Tables.html">Hash Tables</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>
Copy permalink