klisp

an open source interpreter for the Kernel Programming Language.
git clone http://git.hanabi.in/repos/klisp.git
Log | Files | Refs | README
commit ebe4587d2c89dd974afb76337cdcbad35a997db5
parent 827ae80a4e0a6a27f605ea2fec842152e6c7feac
Author: Andres Navarro <canavarro82@gmail.com>
Date:   Tue, 20 Dec 2011 00:10:34 -0300

Added/updated most missing/incomplete ground features in the manual. Added u8? type predicate.  TODO finish port section, and add a sections for each of system, errors, modules, vectors, bytevectors & keywords.

Diffstat:

Mdoc/html/Alphabetical-Index.html | 571++++++++++++++++++++++++++++++++++++++++++-------------------------------------


Mdoc/html/Booleans.html | 20+++++++++++---------


Mdoc/html/Characters.html | 60+++++++++++++++++++++++++++++++++---------------------------


Mdoc/html/Combiners.html | 35+++++++++++++++++++++++++----------


Mdoc/html/Continuations.html | 24++++++++++++------------


Mdoc/html/Control.html | 42+++++++++++++++++++++++++++++++++++++++++-


Mdoc/html/Encapsulations.html | 4++--


Mdoc/html/Environments.html | 56++++++++++++++++++++++++++++++++++----------------------


Mdoc/html/Equivalence.html | 4++--


Mdoc/html/Keyed-Variables.html | 10+++++-----


Mdoc/html/Numbers.html | 203+++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------


Mdoc/html/Pairs-and-lists.html | 169+++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------


Mdoc/html/Ports.html | 145+++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------


Mdoc/html/Promises.html | 19++++++++++++++-----


Mdoc/html/Strings.html | 110++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------


Mdoc/html/Symbols.html | 15++++++++++-----


Mdoc/klisp.info | 825++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------


Mdoc/src/booleans.texi | 20+++++++++++---------


Mdoc/src/characters.texi | 18++++++++++++------


Mdoc/src/combiners.texi | 14++++++++++++++


Mdoc/src/control.texi | 40+++++++++++++++++++++++++++++++++++++++-


Mdoc/src/environments.texi | 15+++++++++++++--


Mdoc/src/equivalence.texi | 4++--


Mdoc/src/numbers.texi | 116+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------


Mdoc/src/pairs_lists.texi | 55++++++++++++++++++++++++++++++++++++++++++++++++++-----


Mdoc/src/ports.texi | 55++++++++++++++++++++++++++++++++++++++++++++++++++-----


Mdoc/src/promises.texi | 9+++++++++


Mdoc/src/strings.texi | 63++++++++++++++++++++++++++++++++++++++++++++++++---------------


Mdoc/src/symbols.texi | 15++++++++++-----


Msrc/kgnumbers.c | 3+++


Msrc/kgpairs_lists.c | 2--


31 files changed, 1820 insertions(+), 921 deletions(-)

diff --git a/doc/html/Alphabetical-Index.html b/doc/html/Alphabetical-Index.html
@@ -36,304 +36,343 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 
 <ul class="index-fn" compact>
 <li><a href="Booleans.html#index-g_t_0024and_003f-18"><code>$and?</code></a>: <a href="Booleans.html#Booleans">Booleans</a></li>
-<li><a href="Environments.html#index-g_t_0024bindings_002d_003eenvironment-111"><code>$bindings-&gt;environment</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Environments.html#index-g_t_0024binds_003f-102"><code>$binds?</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024bindings_002d_003eenvironment-121"><code>$bindings-&gt;environment</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024binds_003f-112"><code>$binds?</code></a>: <a href="Environments.html#Environments">Environments</a></li>
 <li><a href="Control.html#index-g_t_0024cond-32"><code>$cond</code></a>: <a href="Control.html#Control">Control</a></li>
-<li><a href="Environments.html#index-g_t_0024define_0021-100"><code>$define!</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024define_0021-110"><code>$define!</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Promises.html#index-g_t_0024delay-160"><code>$delay</code></a>: <a href="Promises.html#Promises">Promises</a></li>
 <li><a href="Control.html#index-g_t_0024if-30"><code>$if</code></a>: <a href="Control.html#Control">Control</a></li>
-<li><a href="Environments.html#index-g_t_0024import_0021-114"><code>$import!</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Combiners.html#index-g_t_0024lambda-123"><code>$lambda</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Promises.html#index-g_t_0024lazy-144"><code>$lazy</code></a>: <a href="Promises.html#Promises">Promises</a></li>
-<li><a href="Environments.html#index-g_t_0024let-101"><code>$let</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Environments.html#index-g_t_0024let_002a-105"><code>$let*</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Environments.html#index-g_t_0024let_002dredirect-108"><code>$let-redirect</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Environments.html#index-g_t_0024let_002dsafe-109"><code>$let-safe</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Continuations.html#index-g_t_0024let_002fcc-136"><code>$let/cc</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Environments.html#index-g_t_0024letrec-106"><code>$letrec</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Environments.html#index-g_t_0024letrec_002a-107"><code>$letrec*</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024import_0021-125"><code>$import!</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Combiners.html#index-g_t_0024lambda-134"><code>$lambda</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Promises.html#index-g_t_0024lazy-158"><code>$lazy</code></a>: <a href="Promises.html#Promises">Promises</a></li>
+<li><a href="Environments.html#index-g_t_0024let-111"><code>$let</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024let_002a-115"><code>$let*</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024let_002dredirect-118"><code>$let-redirect</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024let_002dsafe-119"><code>$let-safe</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Continuations.html#index-g_t_0024let_002fcc-150"><code>$let/cc</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Environments.html#index-g_t_0024letrec-116"><code>$letrec</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024letrec_002a-117"><code>$letrec*</code></a>: <a href="Environments.html#Environments">Environments</a></li>
 <li><a href="Booleans.html#index-g_t_0024or_003f-19"><code>$or?</code></a>: <a href="Booleans.html#Booleans">Booleans</a></li>
-<li><a href="Environments.html#index-g_t_0024provide_0021-113"><code>$provide!</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Environments.html#index-g_t_0024remote_002deval-110"><code>$remote-eval</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024provide_0021-124"><code>$provide!</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-g_t_0024remote_002deval-120"><code>$remote-eval</code></a>: <a href="Environments.html#Environments">Environments</a></li>
 <li><a href="Control.html#index-g_t_0024sequence-31"><code>$sequence</code></a>: <a href="Control.html#Control">Control</a></li>
-<li><a href="Environments.html#index-g_t_0024set_0021-112"><code>$set!</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Combiners.html#index-g_t_0024vau-120"><code>$vau</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Numbers.html#index-g_t_002a-167"><code>*</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-g_t_002b-166"><code>+</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-g_t_002d-168"><code>-</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-g_t_002f-194"><code>/</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-g_t_003c_003d_003f-163"><code>&lt;=?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-g_t_003c_003f-162"><code>&lt;?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-g_t_003d_003f-161"><code>=?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-g_t_003e_003d_003f-165"><code>&gt;=?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-g_t_003e_003f-164"><code>&gt;?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-abs-180"><code>abs</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-acos-209"><code>acos</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Environments.html#index-g_t_0024set_0021-123"><code>$set!</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Control.html#index-g_t_0024unless-38"><code>$unless</code></a>: <a href="Control.html#Control">Control</a></li>
+<li><a href="Combiners.html#index-g_t_0024vau-131"><code>$vau</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Control.html#index-g_t_0024when-37"><code>$when</code></a>: <a href="Control.html#Control">Control</a></li>
+<li><a href="Numbers.html#index-g_t_002a-184"><code>*</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-g_t_002b-183"><code>+</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-g_t_002d-185"><code>-</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-g_t_002f-211"><code>/</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-g_t_003c_003d_003f-180"><code>&lt;=?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-g_t_003c_003f-179"><code>&lt;?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-g_t_003d_003f-178"><code>=?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-g_t_003e_003d_003f-182"><code>&gt;=?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-g_t_003e_003f-181"><code>&gt;?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-abs-197"><code>abs</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-acos-228"><code>acos</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
 <li><a href="Booleans.html#index-and_003f-16"><code>and?</code></a>: <a href="Booleans.html#Booleans">Booleans</a></li>
-<li><a href="Pairs-and-lists.html#index-append-82"><code>append</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-append_0021-90"><code>append!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-append-92"><code>append</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-append_0021-100"><code>append!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
 <li><a href="A-Sample-Applicative-Description.html#index-applicative-descriptions-8">applicative descriptions</a>: <a href="A-Sample-Applicative-Description.html#A-Sample-Applicative-Description">A Sample Applicative Description</a></li>
-<li><a href="Combiners.html#index-applicative_003f-119"><code>applicative?</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Combiners.html#index-applicatives-116">applicatives</a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Combiners.html#index-apply-124"><code>apply</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Continuations.html#index-apply_002dcontinuation-135"><code>apply-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Numbers.html#index-asin-208"><code>asin</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Pairs-and-lists.html#index-assoc-85"><code>assoc</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-assq-92"><code>assq</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Numbers.html#index-atan-210"><code>atan</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Ports.html#index-binary_002dport_003f-263"><code>binary-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Combiners.html#index-applicative_003f-130"><code>applicative?</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Combiners.html#index-applicatives-127">applicatives</a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Combiners.html#index-apply-135"><code>apply</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Continuations.html#index-apply_002dcontinuation-149"><code>apply-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Numbers.html#index-asin-227"><code>asin</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-assoc-95"><code>assoc</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-assq-102"><code>assq</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-atan-229"><code>atan</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-binary_002dport_003f-292"><code>binary-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
 <li><a href="Booleans.html#index-boolean_003f-14"><code>boolean?</code></a>: <a href="Booleans.html#Booleans">Booleans</a></li>
 <li><a href="Booleans.html#index-booleans-13">booleans</a>: <a href="Booleans.html#Booleans">Booleans</a></li>
-<li><a href="Pairs-and-lists.html#index-caaaar-60"><code>caaaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-caaadr-61"><code>caaadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-caaar-52"><code>caaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-caadar-62"><code>caadar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-caaddr-63"><code>caaddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-caadr-53"><code>caadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-caar-48"><code>caar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cadaar-64"><code>cadaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cadadr-65"><code>cadadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cadar-54"><code>cadar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-caddar-66"><code>caddar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cadddr-67"><code>cadddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-caddr-55"><code>caddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cadr-49"><code>cadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Ports.html#index-call_002dwith_002dinput_002dfile-281"><code>call-with-input-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-call_002dwith_002doutput_002dfile-282"><code>call-with-output-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Continuations.html#index-call_002fcc-129"><code>call/cc</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Pairs-and-lists.html#index-car-46"><code>car</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdaaar-68"><code>cdaaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdaadr-69"><code>cdaadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdaar-56"><code>cdaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdadar-70"><code>cdadar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdaddr-71"><code>cdaddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdadr-57"><code>cdadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdar-50"><code>cdar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cddaar-72"><code>cddaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cddadr-73"><code>cddadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cddar-58"><code>cddar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdddar-74"><code>cdddar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cddddr-75"><code>cddddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdddr-59"><code>cdddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cddr-51"><code>cddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-cdr-47"><code>cdr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Numbers.html#index-ceiling-198"><code>ceiling</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Characters.html#index-char_002d_003einteger-256"><code>char-&gt;integer</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dalphabetic_003f-249"><code>char-alphabetic?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dci_003c_003d_003f-246"><code>char-ci&lt;=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dci_003c_003f-245"><code>char-ci&lt;?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dci_003d_003f-244"><code>char-ci=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dci_003e_003d_003f-248"><code>char-ci&gt;=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dci_003e_003f-247"><code>char-ci&gt;?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002ddowncase-255"><code>char-downcase</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dlower_002dcase_003f-253"><code>char-lower-case?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dnumeric_003f-250"><code>char-numeric?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Ports.html#index-char_002dready_003f-288"><code>char-ready?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Characters.html#index-char_002dupcase-254"><code>char-upcase</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dupper_002dcase_003f-252"><code>char-upper-case?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_002dwhitespace_003f-251"><code>char-whitespace?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_003c_003d_003f-241"><code>char&lt;=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_003c_003f-240"><code>char&lt;?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_003d_003f-239"><code>char=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_003e_003d_003f-243"><code>char&gt;=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_003e_003f-242"><code>char&gt;?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-char_003f-238"><code>char?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Characters.html#index-characters-237">characters</a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Ports.html#index-close_002dinput_002dfile-274"><code>close-input-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-close_002dinput_002dport-276"><code>close-input-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-close_002doutput_002dfile-275"><code>close-output-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-close_002doutput_002dport-277"><code>close-output-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-close_002dport-278"><code>close-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Combiners.html#index-combiner_003f-126"><code>combiner?</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Combiners.html#index-combiners-115">combiners</a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Pairs-and-lists.html#index-cons-40"><code>cons</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Continuations.html#index-continuation_002d_003eapplicative-132"><code>continuation-&gt;applicative</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Continuations.html#index-continuation_003f-128"><code>continuation?</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Continuations.html#index-continuations-127">continuations</a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Strings.html#index-bytevector_002d_003estring-261"><code>bytevector-&gt;string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Control.html#index-bytevector_002dfor_002deach-36"><code>bytevector-for-each</code></a>: <a href="Control.html#Control">Control</a></li>
+<li><a href="Combiners.html#index-bytevector_002dmap-139"><code>bytevector-map</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Ports.html#index-bytevector_002dport_003f-295"><code>bytevector-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Pairs-and-lists.html#index-caaaar-67"><code>caaaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-caaadr-68"><code>caaadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-caaar-59"><code>caaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-caadar-69"><code>caadar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-caaddr-70"><code>caaddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-caadr-60"><code>caadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-caar-55"><code>caar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cadaar-71"><code>cadaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cadadr-72"><code>cadadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cadar-61"><code>cadar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-caddar-73"><code>caddar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cadddr-74"><code>cadddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-caddr-62"><code>caddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cadr-56"><code>cadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Ports.html#index-call_002dwith_002dinput_002dfile-319"><code>call-with-input-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-call_002dwith_002doutput_002dfile-320"><code>call-with-output-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Continuations.html#index-call_002fcc-143"><code>call/cc</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Pairs-and-lists.html#index-car-53"><code>car</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdaaar-75"><code>cdaaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdaadr-76"><code>cdaadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdaar-63"><code>cdaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdadar-77"><code>cdadar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdaddr-78"><code>cdaddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdadr-64"><code>cdadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdar-57"><code>cdar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cddaar-79"><code>cddaar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cddadr-80"><code>cddadr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cddar-65"><code>cddar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdddar-81"><code>cdddar</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cddddr-82"><code>cddddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdddr-66"><code>cdddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cddr-58"><code>cddr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-cdr-54"><code>cdr</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-ceiling-215"><code>ceiling</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Characters.html#index-char_002d_003einteger-285"><code>char-&gt;integer</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dalphabetic_003f-278"><code>char-alphabetic?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dci_003c_003d_003f-275"><code>char-ci&lt;=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dci_003c_003f-274"><code>char-ci&lt;?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dci_003d_003f-273"><code>char-ci=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dci_003e_003d_003f-277"><code>char-ci&gt;=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dci_003e_003f-276"><code>char-ci&gt;?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002ddowncase-284"><code>char-downcase</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dlower_002dcase_003f-282"><code>char-lower-case?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dnumeric_003f-279"><code>char-numeric?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Ports.html#index-char_002dready_003f-327"><code>char-ready?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Characters.html#index-char_002dupcase-283"><code>char-upcase</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dupper_002dcase_003f-281"><code>char-upper-case?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_002dwhitespace_003f-280"><code>char-whitespace?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_003c_003d_003f-270"><code>char&lt;=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_003c_003f-269"><code>char&lt;?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_003d_003f-268"><code>char=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_003e_003d_003f-272"><code>char&gt;=?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_003e_003f-271"><code>char&gt;?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-char_003f-267"><code>char?</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Characters.html#index-characters-266">characters</a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Ports.html#index-close_002dinput_002dfile-311"><code>close-input-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-close_002dinput_002dport-313"><code>close-input-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-close_002doutput_002dfile-312"><code>close-output-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-close_002doutput_002dport-314"><code>close-output-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-close_002dport-315"><code>close-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Combiners.html#index-combiner_003f-140"><code>combiner?</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Combiners.html#index-combiners-126">combiners</a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Pairs-and-lists.html#index-cons-47"><code>cons</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Continuations.html#index-continuation_002d_003eapplicative-146"><code>continuation-&gt;applicative</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Continuations.html#index-continuation_003f-142"><code>continuation?</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Continuations.html#index-continuations-141">continuations</a>: <a href="Continuations.html#Continuations">Continuations</a></li>
 <li><a href="Control.html#index-control-27">control</a>: <a href="Control.html#Control">Control</a></li>
-<li><a href="Pairs-and-lists.html#index-copy_002des-91"><code>copy-es</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-copy_002des_002dimmutable_0021-43"><code>copy-es-immutable!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Numbers.html#index-cos-206"><code>cos</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Pairs-and-lists.html#index-countable_002dlist_003f-88"><code>countable-list?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Ports.html#index-delete_002dfile-298"><code>delete-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-denominator-196"><code>denominator</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-copy_002des-101"><code>copy-es</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-copy_002des_002dimmutable_0021-50"><code>copy-es-immutable!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-cos-225"><code>cos</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-countable_002dlist_003f-98"><code>countable-list?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Ports.html#index-delete_002dfile-337"><code>delete-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-denominator-213"><code>denominator</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
 <li><a href="Format-of-Descriptions.html#index-description-format-7">description format</a>: <a href="Format-of-Descriptions.html#Format-of-Descriptions">Format of Descriptions</a></li>
-<li><a href="Ports.html#index-display-291"><code>display</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-div-170"><code>div</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-div_002dand_002dmod-172"><code>div-and-mod</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-div0-173"><code>div0</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-div0_002dand_002dmod0-175"><code>div0-and-mod0</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-display-330"><code>display</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-div-187"><code>div</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-div_002dand_002dmod-189"><code>div-and-mod</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-div0-190"><code>div0</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-div0_002dand_002dmod0-192"><code>div0-and-mod0</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
 <li><a href="Evaluation-Notation.html#index-documentation-notation-4">documentation notation</a>: <a href="Evaluation-Notation.html#Evaluation-Notation">Evaluation Notation</a></li>
-<li><a href="Pairs-and-lists.html#index-empty-list-36">empty list</a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Encapsulations.html#index-encapsulations-139">encapsulations</a>: <a href="Encapsulations.html#Encapsulations">Encapsulations</a></li>
-<li><a href="Pairs-and-lists.html#index-encycle_0021-78"><code>encycle!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Environments.html#index-environment_003f-96"><code>environment?</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Environments.html#index-environments-94">environments</a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Ports.html#index-eof_002dobject_003f-285"><code>eof-object?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Pairs-and-lists.html#index-empty-list-41">empty list</a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Encapsulations.html#index-encapsulations-153">encapsulations</a>: <a href="Encapsulations.html#Encapsulations">Encapsulations</a></li>
+<li><a href="Pairs-and-lists.html#index-encycle_0021-88"><code>encycle!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Environments.html#index-environment_003f-106"><code>environment?</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-environments-104">environments</a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Ports.html#index-eof_002dobject_003f-324"><code>eof-object?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
 <li><a href="Equivalence.html#index-eq_003f-21"><code>eq?</code></a>: <a href="Equivalence.html#Equivalence">Equivalence</a></li>
 <li><a href="Equivalence.html#index-equal_003f-22"><code>equal?</code></a>: <a href="Equivalence.html#Equivalence">Equivalence</a></li>
 <li><a href="Equivalence.html#index-equivalence-20">equivalence</a>: <a href="Equivalence.html#Equivalence">Equivalence</a></li>
 <li><a href="Error-Messages.html#index-error-message-notation-6">error message notation</a>: <a href="Error-Messages.html#Error-Messages">Error Messages</a></li>
-<li><a href="Continuations.html#index-error_002dcontinuation-134"><code>error-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Environments.html#index-eval-98"><code>eval</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Continuations.html#index-error_002dcontinuation-148"><code>error-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Environments.html#index-eval-108"><code>eval</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-eval_002dstring-122"><code>eval-string</code></a>: <a href="Environments.html#Environments">Environments</a></li>
 <li><a href="Evaluation-Notation.html#index-evaluation-notation-3">evaluation notation</a>: <a href="Evaluation-Notation.html#Evaluation-Notation">Evaluation Notation</a></li>
-<li><a href="Numbers.html#index-even_003f-179"><code>even?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-exact_003f-157"><code>exact?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Continuations.html#index-exit-138"><code>exit</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Numbers.html#index-exp-203"><code>exp</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-expt-212"><code>expt</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Continuations.html#index-extend_002dcontinuation-130"><code>extend-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Ports.html#index-file_002dexists_003f-297"><code>file-exists?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Pairs-and-lists.html#index-filter-84"><code>filter</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-finite_002dlist_003f-87"><code>finite-list?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Numbers.html#index-finite_003f-156"><code>finite?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-floor-197"><code>floor</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Ports.html#index-flush_002doutput_002dport-296"><code>flush-output-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-even_003f-196"><code>even?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-exact_002dinteger_003f-169"><code>exact-integer?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-exact_003f-174"><code>exact?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Continuations.html#index-exit-152"><code>exit</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Numbers.html#index-exp-222"><code>exp</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-expt-221"><code>expt</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Continuations.html#index-extend_002dcontinuation-144"><code>extend-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Ports.html#index-file_002dexists_003f-336"><code>file-exists?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-file_002dport_003f-293"><code>file-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Pairs-and-lists.html#index-filter-94"><code>filter</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-finite_002dlist_003f-97"><code>finite-list?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-finite_003f-173"><code>finite?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-floor-214"><code>floor</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-flush_002doutput_002dport-335"><code>flush-output-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
 <li><a href="Some-Terms.html#index-fonts-2">fonts</a>: <a href="Some-Terms.html#Some-Terms">Some Terms</a></li>
 <li><a href="A-Sample-Applicative-Description.html#index-foo-11"><code>foo</code></a>: <a href="A-Sample-Applicative-Description.html#A-Sample-Applicative-Description">A Sample Applicative Description</a></li>
 <li><a href="Control.html#index-for_002deach-33"><code>for-each</code></a>: <a href="Control.html#Control">Control</a></li>
-<li><a href="Promises.html#index-force-143"><code>force</code></a>: <a href="Promises.html#Promises">Promises</a></li>
-<li><a href="Numbers.html#index-gcd-184"><code>gcd</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Environments.html#index-get_002dcurrent_002denvironment-103"><code>get-current-environment</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Ports.html#index-get_002dcurrent_002derror_002dport-269"><code>get-current-error-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-get_002dcurrent_002dinput_002dport-267"><code>get-current-input-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-get_002dcurrent_002doutput_002dport-268"><code>get-current-output-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Pairs-and-lists.html#index-get_002dlist_002dmetrics-76"><code>get-list-metrics</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Ports.html#index-get_002dmodule-284"><code>get-module</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-get_002dreal_002dexact_002dbounds-186"><code>get-real-exact-bounds</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-get_002dreal_002dexact_002dprimary-188"><code>get-real-exact-primary</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-get_002dreal_002dinternal_002dbounds-185"><code>get-real-internal-bounds</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-get_002dreal_002dinternal_002dprimary-187"><code>get-real-internal-primary</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-get_002dstring_002darithmetic-193"><code>get-string-arithmetic</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Continuations.html#index-guard_002dcontinuation-131"><code>guard-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Continuations.html#index-guard_002ddynamic_002dextent-137"><code>guard-dynamic-extent</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Environments.html#index-ignore-95">ignore</a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Environments.html#index-ignore_003f-97"><code>ignore?</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Promises.html#index-force-157"><code>force</code></a>: <a href="Promises.html#Promises">Promises</a></li>
+<li><a href="Numbers.html#index-gcd-201"><code>gcd</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Environments.html#index-get_002dcurrent_002denvironment-113"><code>get-current-environment</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Ports.html#index-get_002dcurrent_002derror_002dport-302"><code>get-current-error-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-get_002dcurrent_002dinput_002dport-300"><code>get-current-input-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-get_002dcurrent_002doutput_002dport-301"><code>get-current-output-port</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Pairs-and-lists.html#index-get_002dlist_002dmetrics-86"><code>get-list-metrics</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Ports.html#index-get_002dmodule-323"><code>get-module</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-get_002dreal_002dexact_002dbounds-203"><code>get-real-exact-bounds</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-get_002dreal_002dexact_002dprimary-205"><code>get-real-exact-primary</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-get_002dreal_002dinternal_002dbounds-202"><code>get-real-internal-bounds</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-get_002dreal_002dinternal_002dprimary-204"><code>get-real-internal-primary</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-get_002dstring_002darithmetic-210"><code>get-string-arithmetic</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Continuations.html#index-guard_002dcontinuation-145"><code>guard-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Continuations.html#index-guard_002ddynamic_002dextent-151"><code>guard-dynamic-extent</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Environments.html#index-ignore-105">ignore</a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Environments.html#index-ignore_003f-107"><code>ignore?</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Pairs-and-lists.html#index-immutable_002dpair_003f-45"><code>immutable-pair?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Strings.html#index-immutable_002dstring_003f-234"><code>immutable-string?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
 <li><a href="Control.html#index-inert-28">inert</a>: <a href="Control.html#Control">Control</a></li>
 <li><a href="Control.html#index-inert_003f-29"><code>inert?</code></a>: <a href="Control.html#Control">Control</a></li>
-<li><a href="Numbers.html#index-inexact_003f-158"><code>inexact?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Ports.html#index-input_002dport_003f-260"><code>input-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Characters.html#index-integer_002d_003echar-257"><code>integer-&gt;char</code></a>: <a href="Characters.html#Characters">Characters</a></li>
-<li><a href="Numbers.html#index-integer_003f-153"><code>integer?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-inexact_003f-175"><code>inexact?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-input_002dport_003f-289"><code>input-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Characters.html#index-integer_002d_003echar-286"><code>integer-&gt;char</code></a>: <a href="Characters.html#Characters">Characters</a></li>
+<li><a href="Numbers.html#index-integer_003f-168"><code>integer?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
 <li><a href="Interpreter.html#index-interpreter-12">interpreter</a>: <a href="Interpreter.html#Interpreter">Interpreter</a></li>
 <li><a href="Kernel-History.html#index-Kernel-history-1">Kernel history</a>: <a href="Kernel-History.html#Kernel-History">Kernel History</a></li>
-<li><a href="Keyed-Variables.html#index-keyed-dynamic-variables-147">keyed dynamic variables</a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
-<li><a href="Keyed-Variables.html#index-keyed-static-variables-149">keyed static variables</a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
-<li><a href="Keyed-Variables.html#index-keyed-variables-146">keyed variables</a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
-<li><a href="Numbers.html#index-lcm-183"><code>lcm</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Pairs-and-lists.html#index-length-80"><code>length</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-list-44"><code>list</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-list_002a-45"><code>list*</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Strings.html#index-list_002d_003estring-236"><code>list-&gt;string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Pairs-and-lists.html#index-list_002dneighbors-83"><code>list-neighbors</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-list_002dref-81"><code>list-ref</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-list_002dtail-77"><code>list-tail</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-lists-37">lists</a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Ports.html#index-load-283"><code>load</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-log-204"><code>log</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Encapsulations.html#index-make_002dencapsulation_002dtype-140"><code>make-encapsulation-type</code></a>: <a href="Encapsulations.html#Encapsulations">Encapsulations</a></li>
-<li><a href="Environments.html#index-make_002denvironment-99"><code>make-environment</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Numbers.html#index-make_002dinexact-189"><code>make-inexact</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Environments.html#index-make_002dkernel_002dstandard_002denvironment-104"><code>make-kernel-standard-environment</code></a>: <a href="Environments.html#Environments">Environments</a></li>
-<li><a href="Keyed-Variables.html#index-make_002dkeyed_002ddynamic_002dvariable-148"><code>make-keyed-dynamic-variable</code></a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
-<li><a href="Keyed-Variables.html#index-make_002dkeyed_002dstatic_002dvariable-150"><code>make-keyed-static-variable</code></a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
-<li><a href="Strings.html#index-make_002dstring-225"><code>make-string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Combiners.html#index-map-125"><code>map</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Pairs-and-lists.html#index-map-79"><code>map</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Numbers.html#index-max-181"><code>max</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Pairs-and-lists.html#index-member_003f-86"><code>member?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Promises.html#index-memoize-145"><code>memoize</code></a>: <a href="Promises.html#Promises">Promises</a></li>
-<li><a href="Pairs-and-lists.html#index-memq_003f-93"><code>memq?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Numbers.html#index-min-182"><code>min</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-mod-171"><code>mod</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-mod0-174"><code>mod0</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-negative_003f-177"><code>negative?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Ports.html#index-newline-290"><code>newline</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Pairs-and-lists.html#index-nil-35">nil</a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Keyed-Variables.html#index-keyed-dynamic-variables-162">keyed dynamic variables</a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
+<li><a href="Keyed-Variables.html#index-keyed-static-variables-164">keyed static variables</a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
+<li><a href="Keyed-Variables.html#index-keyed-variables-161">keyed variables</a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
+<li><a href="Numbers.html#index-lcm-200"><code>lcm</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-length-90"><code>length</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-list-51"><code>list</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-list_002a-52"><code>list*</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Strings.html#index-list_002d_003estring-257"><code>list-&gt;string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Pairs-and-lists.html#index-list_002dcopy-84"><code>list-copy</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-list_002dneighbors-93"><code>list-neighbors</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-list_002dref-91"><code>list-ref</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-list_002dtail-87"><code>list-tail</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-lists-42">lists</a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Ports.html#index-load-321"><code>load</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-log-223"><code>log</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Encapsulations.html#index-make_002dencapsulation_002dtype-154"><code>make-encapsulation-type</code></a>: <a href="Encapsulations.html#Encapsulations">Encapsulations</a></li>
+<li><a href="Environments.html#index-make_002denvironment-109"><code>make-environment</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Numbers.html#index-make_002dinexact-206"><code>make-inexact</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Environments.html#index-make_002dkernel_002dstandard_002denvironment-114"><code>make-kernel-standard-environment</code></a>: <a href="Environments.html#Environments">Environments</a></li>
+<li><a href="Keyed-Variables.html#index-make_002dkeyed_002ddynamic_002dvariable-163"><code>make-keyed-dynamic-variable</code></a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
+<li><a href="Keyed-Variables.html#index-make_002dkeyed_002dstatic_002dvariable-165"><code>make-keyed-static-variable</code></a>: <a href="Keyed-Variables.html#Keyed-Variables">Keyed Variables</a></li>
+<li><a href="Pairs-and-lists.html#index-make_002dlist-83"><code>make-list</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Strings.html#index-make_002dstring-246"><code>make-string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Combiners.html#index-map-136"><code>map</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Pairs-and-lists.html#index-map-89"><code>map</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-max-198"><code>max</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-member_003f-96"><code>member?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Promises.html#index-memoize-159"><code>memoize</code></a>: <a href="Promises.html#Promises">Promises</a></li>
+<li><a href="Pairs-and-lists.html#index-memq_003f-103"><code>memq?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-min-199"><code>min</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-mod-188"><code>mod</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-mod0-191"><code>mod0</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-mutable_002dpair_003f-46"><code>mutable-pair?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Strings.html#index-mutable_002dstring_003f-235"><code>mutable-string?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Numbers.html#index-negative_003f-194"><code>negative?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-newline-329"><code>newline</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Pairs-and-lists.html#index-nil-40">nil</a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
 <li><a href="Booleans.html#index-not_003f-15"><code>not?</code></a>: <a href="Booleans.html#Booleans">Booleans</a></li>
-<li><a href="Pairs-and-lists.html#index-null_003f-39"><code>null?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Numbers.html#index-number_003f-152"><code>number?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-numbers-151">numbers</a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-numerator-195"><code>numerator</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-null_003f-44"><code>null?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-number_002d_003estring-231"><code>number-&gt;string</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-number_003f-167"><code>number?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-numbers-166">numbers</a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-numerator-212"><code>numerator</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
 <li><a href="A-Sample-Applicative-Description.html#index-object-descriptions-10">object descriptions</a>: <a href="A-Sample-Applicative-Description.html#A-Sample-Applicative-Description">A Sample Applicative Description</a></li>
-<li><a href="Numbers.html#index-odd_003f-178"><code>odd?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Ports.html#index-open_002dbinary_002dinput_002dfile-271"><code>open-binary-input-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-open_002dbinary_002doutput_002dfile-273"><code>open-binary-output-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-open_002dinput_002dfile-270"><code>open-input-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-open_002doutput_002dfile-272"><code>open-output-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-odd_003f-195"><code>odd?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-open_002dbinary_002dinput_002dfile-304"><code>open-binary-input-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-open_002dbinary_002doutput_002dfile-306"><code>open-binary-output-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-open_002dinput_002dbytevector-308"><code>open-input-bytevector</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-open_002dinput_002dfile-303"><code>open-input-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-open_002dinput_002dstring-307"><code>open-input-string</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-open_002doutput_002dbytevector-310"><code>open-output-bytevector</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-open_002doutput_002dfile-305"><code>open-output-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-open_002doutput_002dstring-309"><code>open-output-string</code></a>: <a href="Ports.html#Ports">Ports</a></li>
 <li><a href="A-Sample-Applicative-Description.html#index-operative-descriptions-9">operative descriptions</a>: <a href="A-Sample-Applicative-Description.html#A-Sample-Applicative-Description">A Sample Applicative Description</a></li>
-<li><a href="Combiners.html#index-operative_003f-118"><code>operative?</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Combiners.html#index-operatives-117">operatives</a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Combiners.html#index-operative_003f-129"><code>operative?</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Combiners.html#index-operatives-128">operatives</a>: <a href="Combiners.html#Combiners">Combiners</a></li>
 <li><a href="Booleans.html#index-or_003f-17"><code>or?</code></a>: <a href="Booleans.html#Booleans">Booleans</a></li>
-<li><a href="Ports.html#index-output_002dport_003f-261"><code>output-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Pairs-and-lists.html#index-pair_003f-38"><code>pair?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-pairs-34">pairs</a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Ports.html#index-peek_002dchar-287"><code>peek-char</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-peek_002du8-293"><code>peek-u8</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-port_003f-259"><code>port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-ports-258">ports</a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-positive_003f-176"><code>positive?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-output_002dport_003f-290"><code>output-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Pairs-and-lists.html#index-pair_003f-43"><code>pair?</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-pairs-39">pairs</a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Ports.html#index-peek_002dchar-326"><code>peek-char</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-peek_002du8-332"><code>peek-u8</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-port_002dopen_003f-296"><code>port-open?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-port_003f-288"><code>port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-ports-287">ports</a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-positive_003f-193"><code>positive?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
 <li><a href="Printing-Notation.html#index-printing-notation-5">printing notation</a>: <a href="Printing-Notation.html#Printing-Notation">Printing Notation</a></li>
-<li><a href="Promises.html#index-promise_003f-142"><code>promise?</code></a>: <a href="Promises.html#Promises">Promises</a></li>
-<li><a href="Promises.html#index-promises-141">promises</a>: <a href="Promises.html#Promises">Promises</a></li>
-<li><a href="Numbers.html#index-rational_003f-154"><code>rational?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-rationalize-201"><code>rationalize</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Ports.html#index-read-279"><code>read</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-read_002dchar-286"><code>read-char</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-read_002du8-292"><code>read-u8</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-real_002d_003eexact-191"><code>real-&gt;exact</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-real_002d_003einexact-190"><code>real-&gt;inexact</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-real_003f-155"><code>real?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Pairs-and-lists.html#index-reduce-89"><code>reduce</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Ports.html#index-rename_002dfile-299"><code>rename-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-robust_003f-159"><code>robust?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Continuations.html#index-root_002dcontinuation-133"><code>root-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
-<li><a href="Numbers.html#index-round-200"><code>round</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Pairs-and-lists.html#index-set_002dcar_0021-41"><code>set-car!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Pairs-and-lists.html#index-set_002dcdr_0021-42"><code>set-cdr!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
-<li><a href="Numbers.html#index-simplest_002drational-202"><code>simplest-rational</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-sin-205"><code>sin</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Numbers.html#index-sqrt-211"><code>sqrt</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Strings.html#index-string-226"><code>string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002d_003eimmutable_002dstring-234"><code>string-&gt;immutable-string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002d_003elist-235"><code>string-&gt;list</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Promises.html#index-promise_003f-156"><code>promise?</code></a>: <a href="Promises.html#Promises">Promises</a></li>
+<li><a href="Promises.html#index-promises-155">promises</a>: <a href="Promises.html#Promises">Promises</a></li>
+<li><a href="Numbers.html#index-rational_003f-171"><code>rational?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-rationalize-218"><code>rationalize</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-read-316"><code>read</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-read_002dchar-325"><code>read-char</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-read_002du8-331"><code>read-u8</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-real_002d_003eexact-208"><code>real-&gt;exact</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-real_002d_003einexact-207"><code>real-&gt;inexact</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-real_003f-172"><code>real?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-reduce-99"><code>reduce</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Ports.html#index-rename_002dfile-338"><code>rename-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-require-322"><code>require</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Pairs-and-lists.html#index-reverse-85"><code>reverse</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-robust_003f-176"><code>robust?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Continuations.html#index-root_002dcontinuation-147"><code>root-continuation</code></a>: <a href="Continuations.html#Continuations">Continuations</a></li>
+<li><a href="Numbers.html#index-round-217"><code>round</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Pairs-and-lists.html#index-set_002dcar_0021-48"><code>set-car!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Pairs-and-lists.html#index-set_002dcdr_0021-49"><code>set-cdr!</code></a>: <a href="Pairs-and-lists.html#Pairs-and-lists">Pairs and lists</a></li>
+<li><a href="Numbers.html#index-simplest_002drational-219"><code>simplest-rational</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-sin-224"><code>sin</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-sqrt-220"><code>sqrt</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Strings.html#index-string-247"><code>string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002d_003ebytevector-260"><code>string-&gt;bytevector</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002d_003eimmutable_002dstring-255"><code>string-&gt;immutable-string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002d_003elist-256"><code>string-&gt;list</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Numbers.html#index-string_002d_003enumber-230"><code>string-&gt;number</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
 <li><a href="Symbols.html#index-string_002d_003esymbol-26"><code>string-&gt;symbol</code></a>: <a href="Symbols.html#Symbols">Symbols</a></li>
-<li><a href="Strings.html#index-string_002dappend-232"><code>string-append</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dci_003c_003d_003f-222"><code>string-ci&lt;=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dci_003c_003f-221"><code>string-ci&lt;?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dci_003d_003f-220"><code>string-ci=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dci_003e_003d_003f-224"><code>string-ci&gt;=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dci_003e_003f-223"><code>string-ci&gt;?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dcopy-233"><code>string-copy</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dfill_0021-230"><code>string-fill!</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dlength-227"><code>string-length</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dref-228"><code>string-ref</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_002dset_0021-229"><code>string-set!</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_003c_003d_003f-217"><code>string&lt;=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_003c_003f-216"><code>string&lt;?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_003d_003f-215"><code>string=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_003e_003d_003f-219"><code>string&gt;=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_003e_003f-218"><code>string&gt;?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-string_003f-214"><code>string?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-strings-213">strings</a>: <a href="Strings.html#Strings">Strings</a></li>
-<li><a href="Strings.html#index-substring-231"><code>substring</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002d_003evector-258"><code>string-&gt;vector</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dappend-253"><code>string-append</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dci_003c_003d_003f-243"><code>string-ci&lt;=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dci_003c_003f-242"><code>string-ci&lt;?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dci_003d_003f-241"><code>string-ci=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dci_003e_003d_003f-245"><code>string-ci&gt;=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dci_003e_003f-244"><code>string-ci&gt;?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dcopy-254"><code>string-copy</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002ddowncase-263"><code>string-downcase</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dfill_0021-251"><code>string-fill!</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dfoldcase-265"><code>string-foldcase</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Control.html#index-string_002dfor_002deach-34"><code>string-for-each</code></a>: <a href="Control.html#Control">Control</a></li>
+<li><a href="Strings.html#index-string_002dlength-248"><code>string-length</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Combiners.html#index-string_002dmap-137"><code>string-map</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Ports.html#index-string_002dport_003f-294"><code>string-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Strings.html#index-string_002dref-249"><code>string-ref</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dset_0021-250"><code>string-set!</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dtitlecase-264"><code>string-titlecase</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_002dupcase-262"><code>string-upcase</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_003c_003d_003f-238"><code>string&lt;=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_003c_003f-237"><code>string&lt;?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_003d_003f-236"><code>string=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_003e_003d_003f-240"><code>string&gt;=?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_003e_003f-239"><code>string&gt;?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-string_003f-233"><code>string?</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-strings-232">strings</a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Strings.html#index-substring-252"><code>substring</code></a>: <a href="Strings.html#Strings">Strings</a></li>
 <li><a href="Symbols.html#index-symbol_002d_003estring-25"><code>symbol-&gt;string</code></a>: <a href="Symbols.html#Symbols">Symbols</a></li>
 <li><a href="Symbols.html#index-symbol_003f-24"><code>symbol?</code></a>: <a href="Symbols.html#Symbols">Symbols</a></li>
 <li><a href="Symbols.html#index-symbols-23">symbols</a>: <a href="Symbols.html#Symbols">Symbols</a></li>
-<li><a href="Numbers.html#index-tan-207"><code>tan</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Ports.html#index-textual_002dport_003f-262"><code>textual-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-truncate-199"><code>truncate</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Ports.html#index-u8_002dready_003f-294"><code>u8-ready?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-undefined_003f-160"><code>undefined?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Combiners.html#index-unwrap-122"><code>unwrap</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Ports.html#index-with_002derror_002dto_002dfile-266"><code>with-error-to-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-with_002dinput_002dfrom_002dfile-264"><code>with-input-from-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-with_002doutput_002dto_002dfile-265"><code>with-output-to-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-with_002dstrict_002darithmetic-192"><code>with-strict-arithmetic</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
-<li><a href="Combiners.html#index-wrap-121"><code>wrap</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
-<li><a href="Ports.html#index-write-280"><code>write</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-write_002dchar-289"><code>write-char</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Ports.html#index-write_002du8-295"><code>write-u8</code></a>: <a href="Ports.html#Ports">Ports</a></li>
-<li><a href="Numbers.html#index-zero_003f-169"><code>zero?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-tan-226"><code>tan</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-textual_002dport_003f-291"><code>textual-port?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-truncate-216"><code>truncate</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Ports.html#index-u8_002dready_003f-333"><code>u8-ready?</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-u8_003f-170"><code>u8?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Numbers.html#index-undefined_003f-177"><code>undefined?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Combiners.html#index-unwrap-133"><code>unwrap</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Strings.html#index-vector_002d_003estring-259"><code>vector-&gt;string</code></a>: <a href="Strings.html#Strings">Strings</a></li>
+<li><a href="Control.html#index-vector_002dfor_002deach-35"><code>vector-for-each</code></a>: <a href="Control.html#Control">Control</a></li>
+<li><a href="Combiners.html#index-vector_002dmap-138"><code>vector-map</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Ports.html#index-with_002derror_002dto_002dfile-299"><code>with-error-to-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-with_002dinput_002dfrom_002dfile-297"><code>with-input-from-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-with_002doutput_002dto_002dfile-298"><code>with-output-to-file</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-with_002dstrict_002darithmetic-209"><code>with-strict-arithmetic</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
+<li><a href="Combiners.html#index-wrap-132"><code>wrap</code></a>: <a href="Combiners.html#Combiners">Combiners</a></li>
+<li><a href="Ports.html#index-write-317"><code>write</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-write_002dchar-328"><code>write-char</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-write_002dsimple-318"><code>write-simple</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Ports.html#index-write_002du8-334"><code>write-u8</code></a>: <a href="Ports.html#Ports">Ports</a></li>
+<li><a href="Numbers.html#index-zero_003f-186"><code>zero?</code></a>: <a href="Numbers.html#Numbers">Numbers</a></li>
 </ul><!-- Print the tables of contents -->
 
 <div class="shortcontents">
diff --git a/doc/html/Booleans.html b/doc/html/Booleans.html
@@ -74,11 +74,12 @@ end of the list is reached (which is immediate if <code>&lt;list&gt;</code> is
 <code>nil</code>), the operative returns true.  If an operand evaluates to
 false, no further operand evaluations are performed, and the operative
 returns false.  If <code>&lt;list&gt;</code> is acyclic, and the last operand is
-<!-- TODO cross ref tail-contect -->
-evaluated, it is evaluated as a tail context.  If <code>&lt;list&gt;</code> is
-cyclic, an unbounded number of operand evaluations may be
-performed.  If any of the operands evaluates to a non-boolean value, an
-error is signaled (even if it's the last one). 
+<!-- TODO cross ref tail-context -->
+evaluated, it is evaluated in a special type of tail context that
+checks that the passed value is a boolean.  If <code>&lt;list&gt;</code> is
+cyclic, an unbounded number of operand evaluations may be performed. 
+If any of the operands evaluates to a non-boolean value, an error is
+signaled (even if it's the last one). 
 </p></blockquote></div>
 
 <div class="defun">
@@ -91,10 +92,11 @@ end of the list is reached (which is immediate if <code>&lt;list&gt;</code> is
 true, no further operand evaluations are performed, and the operative
 returns true.  If <code>&lt;list&gt;</code> is acyclic, and the last operand is
 <!-- TODO cross ref tail-context -->
-evaluated, it is evaluated as a tail context.  If <code>&lt;list&gt;</code> is
-cyclic, an unbounded number of operand evaluations may be
-performed.  If any of the operands evaluates to a non-boolean value, an
-error is signaled (even if it's the last one). 
+evaluated, it is evaluated in a special type of tail context that
+checks that the passed value is a boolean.  If <code>&lt;list&gt;</code> is
+cyclic, an unbounded number of operand evaluations may be performed. 
+If any of the operands evaluates to a non-boolean value, an error is
+signaled (even if it's the last one). 
 </p></blockquote></div>
 
 <!-- *-texinfo-*- -->
diff --git a/doc/html/Characters.html b/doc/html/Characters.html
@@ -34,63 +34,69 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">16 Characters</h2>
 
-<p><a name="index-characters-237"></a>
+<p><a name="index-characters-266"></a>
   A character is an object that represents an ASCII character (for
 now, only ASCII is supported in klisp, in the future, full UNICODE
-will be supported).  The external representation of characters
-consists of a leading &ldquo;#\&rdquo; and the character or character name.  The
-only supported names for now are &ldquo;newline&rdquo; and &ldquo;space&rdquo; (both from
-r5rs scheme).  Characters are immutable.  The character type is
-encapsulated.
+will be supported).
+
+   <p>The external representation of characters consists of a leading &ldquo;#\&rdquo;
+and the character or character name or &ldquo;#\x&rdquo; followed by the hex
+unicode code point (only ASCII supported for now).  The supported
+names for now are &ldquo;null&rdquo;, &ldquo;alarm&rdquo;, &ldquo;backspace&rdquo;, &ldquo;tab&rdquo;,
+&ldquo;newline&rdquo;, &ldquo;return&rdquo;, &ldquo;escape&rdquo;, &ldquo;space&rdquo;, &ldquo;delete&rdquo;, &ldquo;vtab&rdquo;,
+and &ldquo;formfeed&rdquo; (this is a combination of the ones accepted in r6rs
+and r7rs).
+
+   <p>Characters are immutable.  The character type is encapsulated.
 
    <p>SOURCE NOTE: This section is still missing from the report.  The
-features defined here were taken mostly from r5rs scheme.
+features defined here were taken mostly from r7rs.
 
 <div class="defun">
-&mdash; Applicative: <b>char?</b> (<var>char? . objects</var>)<var><a name="index-char_003f-238"></a></var><br>
+&mdash; Applicative: <b>char?</b> (<var>char? . objects</var>)<var><a name="index-char_003f-267"></a></var><br>
 <blockquote><p>  The primitive type predicate for type character.  <code>char?</code>
 returns true iff all the objects in <code>objects</code> are of type
 character. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>char=?</b> (<var>char=? . chars</var>)<var><a name="index-char_003d_003f-239"></a></var><br>
-&mdash; Applicative: <b>char&lt;?</b> (<var>char&lt;? . chars</var>)<var><a name="index-char_003c_003f-240"></a></var><br>
-&mdash; Applicative: <b>char&lt;=?</b> (<var>char&lt;=? . chars</var>)<var><a name="index-char_003c_003d_003f-241"></a></var><br>
-&mdash; Applicative: <b>char&gt;?</b> (<var>char&gt;? . chars</var>)<var><a name="index-char_003e_003f-242"></a></var><br>
-&mdash; Applicative: <b>char&gt;=?</b> (<var>char&gt;=? . chars</var>)<var><a name="index-char_003e_003d_003f-243"></a></var><br>
+&mdash; Applicative: <b>char=?</b> (<var>char=? . chars</var>)<var><a name="index-char_003d_003f-268"></a></var><br>
+&mdash; Applicative: <b>char&lt;?</b> (<var>char&lt;? . chars</var>)<var><a name="index-char_003c_003f-269"></a></var><br>
+&mdash; Applicative: <b>char&lt;=?</b> (<var>char&lt;=? . chars</var>)<var><a name="index-char_003c_003d_003f-270"></a></var><br>
+&mdash; Applicative: <b>char&gt;?</b> (<var>char&gt;? . chars</var>)<var><a name="index-char_003e_003f-271"></a></var><br>
+&mdash; Applicative: <b>char&gt;=?</b> (<var>char&gt;=? . chars</var>)<var><a name="index-char_003e_003d_003f-272"></a></var><br>
 <blockquote><p>  These predicates compare any number of characters using their
 ASCII value for the comparison. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>char-ci=?</b> (<var>char-ci=? . chars</var>)<var><a name="index-char_002dci_003d_003f-244"></a></var><br>
-&mdash; Applicative: <b>char-ci&lt;?</b> (<var>char-ci&lt;? . chars</var>)<var><a name="index-char_002dci_003c_003f-245"></a></var><br>
-&mdash; Applicative: <b>char-ci&lt;=?</b> (<var>char-ci&lt;=? . chars</var>)<var><a name="index-char_002dci_003c_003d_003f-246"></a></var><br>
-&mdash; Applicative: <b>char-ci&gt;?</b> (<var>char-ci&gt;? . chars</var>)<var><a name="index-char_002dci_003e_003f-247"></a></var><br>
-&mdash; Applicative: <b>char-ci&gt;=?</b> (<var>char-ci&gt;=? . chars</var>)<var><a name="index-char_002dci_003e_003d_003f-248"></a></var><br>
+&mdash; Applicative: <b>char-ci=?</b> (<var>char-ci=? . chars</var>)<var><a name="index-char_002dci_003d_003f-273"></a></var><br>
+&mdash; Applicative: <b>char-ci&lt;?</b> (<var>char-ci&lt;? . chars</var>)<var><a name="index-char_002dci_003c_003f-274"></a></var><br>
+&mdash; Applicative: <b>char-ci&lt;=?</b> (<var>char-ci&lt;=? . chars</var>)<var><a name="index-char_002dci_003c_003d_003f-275"></a></var><br>
+&mdash; Applicative: <b>char-ci&gt;?</b> (<var>char-ci&gt;? . chars</var>)<var><a name="index-char_002dci_003e_003f-276"></a></var><br>
+&mdash; Applicative: <b>char-ci&gt;=?</b> (<var>char-ci&gt;=? . chars</var>)<var><a name="index-char_002dci_003e_003d_003f-277"></a></var><br>
 <blockquote><p>  These predicates convert the chars to lowercase and then compare
 their ASCII values. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>char-alphabetic?</b> (<var>char-alphabetic? . chars</var>)<var><a name="index-char_002dalphabetic_003f-249"></a></var><br>
-&mdash; Applicative: <b>char-numeric?</b> (<var>char-numeric? . chars</var>)<var><a name="index-char_002dnumeric_003f-250"></a></var><br>
-&mdash; Applicative: <b>char-whitespace?</b> (<var>char-whitespace? . chars</var>)<var><a name="index-char_002dwhitespace_003f-251"></a></var><br>
+&mdash; Applicative: <b>char-alphabetic?</b> (<var>char-alphabetic? . chars</var>)<var><a name="index-char_002dalphabetic_003f-278"></a></var><br>
+&mdash; Applicative: <b>char-numeric?</b> (<var>char-numeric? . chars</var>)<var><a name="index-char_002dnumeric_003f-279"></a></var><br>
+&mdash; Applicative: <b>char-whitespace?</b> (<var>char-whitespace? . chars</var>)<var><a name="index-char_002dwhitespace_003f-280"></a></var><br>
 <blockquote><p>  These predicates return true iff all of their arguments are
 respectively &ldquo;alphabetic&rdquo;, &ldquo;numeric&rdquo;, or &ldquo;whitespace&rdquo;. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>char-upper-case?</b> (<var>char-upper-case? . chars</var>)<var><a name="index-char_002dupper_002dcase_003f-252"></a></var><br>
-&mdash; Applicative: <b>char-lower-case?</b> (<var>char-lower-case? . chars</var>)<var><a name="index-char_002dlower_002dcase_003f-253"></a></var><br>
+&mdash; Applicative: <b>char-upper-case?</b> (<var>char-upper-case? . chars</var>)<var><a name="index-char_002dupper_002dcase_003f-281"></a></var><br>
+&mdash; Applicative: <b>char-lower-case?</b> (<var>char-lower-case? . chars</var>)<var><a name="index-char_002dlower_002dcase_003f-282"></a></var><br>
 <blockquote><p>  These predicates return true iff all of their arguments are
 respectively &ldquo;upper case, or &ldquo;lower case&rdquo;. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>char-upcase</b> (<var>char-upcase char</var>)<var><a name="index-char_002dupcase-254"></a></var><br>
-&mdash; Applicative: <b>char-downcase</b> (<var>char-downcase char</var>)<var><a name="index-char_002ddowncase-255"></a></var><br>
+&mdash; Applicative: <b>char-upcase</b> (<var>char-upcase char</var>)<var><a name="index-char_002dupcase-283"></a></var><br>
+&mdash; Applicative: <b>char-downcase</b> (<var>char-downcase char</var>)<var><a name="index-char_002ddowncase-284"></a></var><br>
 <blockquote><p>  These applicatives return a character <code>char2</code> so that:
      <pre class="example">          (char-ci=? char char2) &rArr; #t
 </pre>
@@ -102,8 +108,8 @@ respectively &ldquo;upper case, or &ldquo;lower case&rdquo;.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>char-&gt;integer</b> (<var>char-&gt;integer char</var>)<var><a name="index-char_002d_003einteger-256"></a></var><br>
-&mdash; Applicative: <b>integer-&gt;char</b> (<var>integer-&gt;char k</var>)<var><a name="index-integer_002d_003echar-257"></a></var><br>
+&mdash; Applicative: <b>char-&gt;integer</b> (<var>char-&gt;integer char</var>)<var><a name="index-char_002d_003einteger-285"></a></var><br>
+&mdash; Applicative: <b>integer-&gt;char</b> (<var>integer-&gt;char k</var>)<var><a name="index-integer_002d_003echar-286"></a></var><br>
 <blockquote><p>  These applicatives convert between ASCII values (as exact integers
 between 0 and 127) and characters.  If an integer that is out of range
 for ASCII characters is passed to <code>integer-&gt;char</code>, an error is
diff --git a/doc/html/Combiners.html b/doc/html/Combiners.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">9 Combiners</h2>
 
-<p><a name="index-combiners-115"></a><a name="index-applicatives-116"></a><a name="index-operatives-117"></a>
+<p><a name="index-combiners-126"></a><a name="index-applicatives-127"></a><a name="index-operatives-128"></a>
   There are two types of combiners in Kernel, operative and
 applicative. Both types are encapsulated. All combiners are immutable. 
 Two applicatives are <code>eq?</code> iff their underlying combiners are
@@ -47,21 +47,21 @@ iff they are <code>eq?</code>.
 <!-- TODO add xref for eq? and equal? -->
 
 <div class="defun">
-&mdash; Applicative: <b>operative?</b> (<var>operative? . objects</var>)<var><a name="index-operative_003f-118"></a></var><br>
+&mdash; Applicative: <b>operative?</b> (<var>operative? . objects</var>)<var><a name="index-operative_003f-129"></a></var><br>
 <blockquote><p>  The primitive type predicate for type operative. <code>operative?</code>
 returns true iff all the objects in <code>objects</code> are of type
 operative. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>applicative?</b> (<var>applicative? . objects</var>)<var><a name="index-applicative_003f-119"></a></var><br>
+&mdash; Applicative: <b>applicative?</b> (<var>applicative? . objects</var>)<var><a name="index-applicative_003f-130"></a></var><br>
 <blockquote><p>  The primitive type predicate for type applicative. 
 <code>applicative?</code> returns true iff all the objects in
 <code>objects</code> are of type applicative. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$vau</b> (<var>$vau &lt;formals&gt; &lt;eformal&gt; . &lt;objects&gt;</var>)<var><a name="index-g_t_0024vau-120"></a></var><br>
+&mdash; Operative: <b>$vau</b> (<var>$vau &lt;formals&gt; &lt;eformal&gt; . &lt;objects&gt;</var>)<var><a name="index-g_t_0024vau-131"></a></var><br>
 <blockquote><!-- TODO add xref to formal parameter tree -->
         <p><code>&lt;formals&gt;</code> should be a formal parameter tree; <code>&lt;eformal&gt;</code>
 should be either a symbol or <code>#ignore</code>.  If <code>&lt;formals&gt;</code> does
@@ -110,19 +110,19 @@ operative is compound.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>wrap</b> (<var>wrap combiner</var>)<var><a name="index-wrap-121"></a></var><br>
+&mdash; Applicative: <b>wrap</b> (<var>wrap combiner</var>)<var><a name="index-wrap-132"></a></var><br>
 <blockquote><p>  The <code>wrap</code> applicative returns an applicative whose underlying
 combiner is <code>combiner</code>. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>unwrap</b> (<var>unwrap applicative</var>)<var><a name="index-unwrap-122"></a></var><br>
+&mdash; Applicative: <b>unwrap</b> (<var>unwrap applicative</var>)<var><a name="index-unwrap-133"></a></var><br>
 <blockquote><p>  The <code>unwrap</code> applicative returns the underlying combiner of
 <code>applicative</code>. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$lambda</b> (<var>$lambda &lt;formals&gt; . &lt;objects&gt;</var>)<var><a name="index-g_t_0024lambda-123"></a></var><br>
+&mdash; Operative: <b>$lambda</b> (<var>$lambda &lt;formals&gt; . &lt;objects&gt;</var>)<var><a name="index-g_t_0024lambda-134"></a></var><br>
 <blockquote><p>  <code>&lt;formals&gt;</code> should be a formal parameter tree.
 
         <p>The <code>$lambda</code> operative is defined by the following equivalence:
@@ -132,7 +132,7 @@ combiner is <code>combiner</code>.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>apply</b> (<var>apply applicative object </var>[<var>environment</var>])<var><a name="index-apply-124"></a></var><br>
+&mdash; Applicative: <b>apply</b> (<var>apply applicative object </var>[<var>environment</var>])<var><a name="index-apply-135"></a></var><br>
 <blockquote><p>  Applicative <code>apply</code> combines the underlying combiner of
 <code>applicative</code> with <code>object</code> in a tail context with dynamic
 environment <code>environment</code> (if the long form is used) or in an
@@ -148,7 +148,7 @@ empty environment (if the short form is used).
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>map</b> (<var>map applicative . lists</var>)<var><a name="index-map-125"></a></var><br>
+&mdash; Applicative: <b>map</b> (<var>map applicative . lists</var>)<var><a name="index-map-136"></a></var><br>
 <blockquote><p>  <code>lists</code> must be a nonempty list of lists; if there are two or
 <!-- TODO add xref to length -->
 more, they must all have the same length. If <code>lists</code> is empty, or
@@ -177,7 +177,22 @@ times.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>combiner?</b> (<var>combiner? . objects</var>)<var><a name="index-combiner_003f-126"></a></var><br>
+&mdash; Applicative: <b>string-map</b> (<var>string-map applicative . strings</var>)<var><a name="index-string_002dmap-137"></a></var><br>
+&mdash; Applicative: <b>vector-map</b> (<var>vector-map applicative . vectors</var>)<var><a name="index-vector_002dmap-138"></a></var><br>
+&mdash; Applicative: <b>bytevector-map</b> (<var>bytevector-map applicative . bytevectors</var>)<var><a name="index-bytevector_002dmap-139"></a></var><br>
+<blockquote><p><code>strings</code>, <code>vectors</code>, or <code>bytevectors</code> should be
+non-empty lists of the corresponding type and all elements should be
+of the same length.
+
+        <p>These applicatives behave as <code>map</code> except that the list of
+elements passed to <code>applicative</code> are the n-th chars, objects, or
+uint8s of the strings, vectors or bytevectors passed as arguments.
+
+        <p>SOURCE NOTE: These are taken from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>combiner?</b> (<var>combiner? . objects</var>)<var><a name="index-combiner_003f-140"></a></var><br>
 <blockquote><p>  The primitive type predicate for type combiner. <code>combiner?</code>
 returns true iff all the objects in <code>objects</code> are of type
 combiner (i.e. applicative or operative). 
diff --git a/doc/html/Continuations.html b/doc/html/Continuations.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">10 Continuations</h2>
 
-<p><a name="index-continuations-127"></a>
+<p><a name="index-continuations-141"></a>
   A continuation is a plan for all future computation, parameterized
 by a value to be provided, and contingent on the states of all mutable
 data structures (which notably may include environments). When the
@@ -71,14 +71,14 @@ The continuation type is encapsulated.
 
 <!-- TODO add dynamic extent & guard selection/interception to the intro -->
 <div class="defun">
-&mdash; Applicative: <b>continuation?</b> (<var>continuation? . objects</var>)<var><a name="index-continuation_003f-128"></a></var><br>
+&mdash; Applicative: <b>continuation?</b> (<var>continuation? . objects</var>)<var><a name="index-continuation_003f-142"></a></var><br>
 <blockquote><p>  The primitive type predicate for type continuation. 
 <code>continuation?</code> returns true iff all the objects in
 <code>objects</code> are of type continuation. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>call/cc</b> (<var>call/cc combiner</var>)<var><a name="index-call_002fcc-129"></a></var><br>
+&mdash; Applicative: <b>call/cc</b> (<var>call/cc combiner</var>)<var><a name="index-call_002fcc-143"></a></var><br>
 <blockquote><p>  Calls <code>combiner</code> in the dynamic environment as a tail context,
 passing as sole operand to it the continuation to which <code>call/cc</code>
 would normally return its result.  (That is, constructs such a
@@ -87,7 +87,7 @@ combination and evaluates it in the dynamic environment.)
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>extend-continuation</b> (<var>extend-continuation continuation applicative </var>[<var>environment</var>])<var><a name="index-extend_002dcontinuation-130"></a></var><br>
+&mdash; Applicative: <b>extend-continuation</b> (<var>extend-continuation continuation applicative </var>[<var>environment</var>])<var><a name="index-extend_002dcontinuation-144"></a></var><br>
 <blockquote><p>  The <code>extend-continuation</code> applicative constructs and returns a
 new child of <code>continuation</code> that, when it normally receives a
 value v, calls the underlying combiner of <code>applicative</code> with
@@ -102,7 +102,7 @@ normally to be returned to <code>continuation</code>.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>guard-continuation</b> (<var>guard-continuation entry-guards continuation exit-guards</var>)<var><a name="index-guard_002dcontinuation-131"></a></var><br>
+&mdash; Applicative: <b>guard-continuation</b> (<var>guard-continuation entry-guards continuation exit-guards</var>)<var><a name="index-guard_002dcontinuation-145"></a></var><br>
 <blockquote><p>  <code>entry-guards</code> and <code>exit-guards</code> should each be a list of
 clauses; each clause should be a list of length two, whose first
 element is a continuation, and whose second element is an applicative
@@ -137,7 +137,7 @@ independent of any subsequent mutations to the arguments.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>continuation-&gt;applicative</b> (<var>continuation-&gt;applicative continuation</var>)<var><a name="index-continuation_002d_003eapplicative-132"></a></var><br>
+&mdash; Applicative: <b>continuation-&gt;applicative</b> (<var>continuation-&gt;applicative continuation</var>)<var><a name="index-continuation_002d_003eapplicative-146"></a></var><br>
 <blockquote><p>  Returns an applicative whose underlying operative abnormally passes
 its operand tree to <code>continuation</code>, thus: A series of
 interceptors are selected to handle the abnormal pass, and a
@@ -149,7 +149,7 @@ passed to the derived continuation.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Variable: <b>root-continuation</b><var><a name="index-root_002dcontinuation-133"></a></var><br>
+&mdash; Variable: <b>root-continuation</b><var><a name="index-root_002dcontinuation-147"></a></var><br>
 <blockquote><p>  This continuation is the ancestor of all other continuations. When
 it normally receives a value, it terminates the Kernel session. (For
 example, if the system is running a read-eval-print loop, it exits the
@@ -158,7 +158,7 @@ loop.)
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Variable: <b>error-continuation</b><var><a name="index-error_002dcontinuation-134"></a></var><br>
+&mdash; Variable: <b>error-continuation</b><var><a name="index-error_002dcontinuation-148"></a></var><br>
 <blockquote><p>  The dynamic extent of this continuation is mutually disjoint from
 the dynamic extent in which Kernel computation usually occurs (such as
 the dynamic extent in which the Kernel system would run a
@@ -183,7 +183,7 @@ dynamic extent of <code>error-continuation</code>.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>apply-continuation</b> (<var>apply-continuation continuation object</var>)<var><a name="index-apply_002dcontinuation-135"></a></var><br>
+&mdash; Applicative: <b>apply-continuation</b> (<var>apply-continuation continuation object</var>)<var><a name="index-apply_002dcontinuation-149"></a></var><br>
 <blockquote><p>  Applicative <code>apply-continuation</code> converts its first argument to
 an applicative as if by <code>continuation-&gt;applicative</code>, and then
 applies it as usual.
@@ -195,7 +195,7 @@ applies it as usual.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$let/cc</b> (<var>$let/cc &lt;symbol&gt; . &lt;objects&gt;</var>)<var><a name="index-g_t_0024let_002fcc-136"></a></var><br>
+&mdash; Operative: <b>$let/cc</b> (<var>$let/cc &lt;symbol&gt; . &lt;objects&gt;</var>)<var><a name="index-g_t_0024let_002fcc-150"></a></var><br>
 <blockquote><p>  A child environment <code>e</code> of the dynamic environment is created,
 containing a binding of <code>&lt;symbol&gt;</code> to the continuation to which
 the result of the call to <code>$let/cc</code> should normally return; then,
@@ -210,7 +210,7 @@ if <code>&lt;objects&gt;</code> is empty the result is inert.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>guard-dynamic-extent</b> (<var>guard-dynamic-extent entry-guards combiner exit-guards</var>)<var><a name="index-guard_002ddynamic_002dextent-137"></a></var><br>
+&mdash; Applicative: <b>guard-dynamic-extent</b> (<var>guard-dynamic-extent entry-guards combiner exit-guards</var>)<var><a name="index-guard_002ddynamic_002dextent-151"></a></var><br>
 <blockquote><p>  This applicative extends the current continuation with the specified
 guards, and calls <code>combiner</code> in the dynamic extent of the new
 continuation, with no operands and the dynamic environment of the call
@@ -218,7 +218,7 @@ to <code>guard-dynamic-extent</code>.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>exit</b> (<var>exit </var>[<var>object</var>])<var><a name="index-exit-138"></a></var><br>
+&mdash; Applicative: <b>exit</b> (<var>exit </var>[<var>object</var>])<var><a name="index-exit-152"></a></var><br>
 <blockquote><!-- TODO add xref -->
         <p>Applicative <code>exit</code> initiates an abnormal transfer of
 <code>object</code> (or <code>#inert</code> if <code>object</code> was not specified),
diff --git a/doc/html/Control.html b/doc/html/Control.html
@@ -81,7 +81,7 @@ the behaviour of the <code>$cond</code> operative:
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>for-each</b> (<var>for-each . lists</var>)<var><a name="index-for_002deach-33"></a></var><br>
+&mdash; Applicative: <b>for-each</b> (<var>for-each applicative . lists</var>)<var><a name="index-for_002deach-33"></a></var><br>
 <blockquote><p><code>lists</code> must be a nonempty list of lists; if there are two or
 more, they should all be the same length. If lists is empty, or if all
 of its elements are not lists of the same length, an error is
@@ -94,6 +94,46 @@ element-wise applications, the results of the applications are
 discarded and the result returned by <code>for-each</code> is inert. 
 </p></blockquote></div>
 
+<div class="defun">
+&mdash; Applicative: <b>string-for-each</b> (<var>string-for-each applicative . strings</var>)<var><a name="index-string_002dfor_002deach-34"></a></var><br>
+&mdash; Applicative: <b>vector-for-each</b> (<var>vector-for-each applicative. vectors</var>)<var><a name="index-vector_002dfor_002deach-35"></a></var><br>
+&mdash; Applicative: <b>bytevector-for-each</b> (<var>bytevector-for-each applicative . bytevectors</var>)<var><a name="index-bytevector_002dfor_002deach-36"></a></var><br>
+<blockquote><p><code>strings</code>, <code>vectors</code>, or <code>bytevectors</code> should be
+non-empty lists of the corresponding type and all elements should be
+of the same length.
+
+        <p>These applicatives behave as <code>for-each</code> except that the list of
+elements passed to <code>applicative</code> are the n-th chars, objects, or
+uint8s of the strings, vectors or bytevectors passed as arguments.
+
+        <p>SOURCE NOTE: These are taken from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Operative: <b>$when</b> (<var>$when &lt;test&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024when-37"></a></var><br>
+&mdash; Operative: <b>$unless</b> (<var>$unless &lt;test&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024unless-38"></a></var><br>
+<blockquote><p><code>body</code> should be a list of expressions.
+
+        <p>These operatives behave as one-armed <code>$if</code>s with an implicit
+<code>$sequence</code>, except that they always discard the last value and
+the result returned is inert.
+
+        <p>So both <code>$when</code>, and <code>$unless</code> evaluate <code>&lt;test&gt;</code> in the
+dynamic environment.  If the result is non boolean an error is
+signaled.  In <code>$when</code> if the result is false and in
+<code>$unless</code> if the result is true, the expressions in <code>&lt;body&gt;</code>
+are not evaluated and an inert value is returned.  Otherwise, the
+expressions in <code>&lt;body&gt;</code> are evaluated sequentially in the dynamic
+environment.  If <code>&lt;body&gt;</code> is a non cyclic list, the last
+expression in <code>&lt;body&gt;</code> is evaluated in a special type of tail
+context, that, upon receiving a value discards it and returns an inert
+value instead.  If <code>&lt;body&gt;</code> is a cyclic list, element evaluation
+continues indefinitely, with elements in the cycle being evaluated
+repeatedly. 
+<!-- TODO xref tail-context -->
+SOURCE NOTE: These are taken from r7rs. 
+</p></blockquote></div>
+
 <!-- *-texinfo-*- -->
    </body></html>
 
diff --git a/doc/html/Encapsulations.html b/doc/html/Encapsulations.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">11 Encapsulations</h2>
 
-<p><a name="index-encapsulations-139"></a>
+<p><a name="index-encapsulations-153"></a>
 An encapsulation is an object that refers to another object, called
 its content.  The Kernel data type encapsulation is encapsulated.  Two
 encapsulations are <code>equal?</code> iff they are <code>eq?</code>. 
@@ -42,7 +42,7 @@ Encapsulations are immutable.
 
 <!-- TODO this is a little spartan... maybe add some more content -->
 <div class="defun">
-&mdash; Applicative: <b>make-encapsulation-type</b> (<var>make-encapsulation-type</var>)<var><a name="index-make_002dencapsulation_002dtype-140"></a></var><br>
+&mdash; Applicative: <b>make-encapsulation-type</b> (<var>make-encapsulation-type</var>)<var><a name="index-make_002dencapsulation_002dtype-154"></a></var><br>
 <blockquote><p>  Returns a list of the form <code>(e p? d)</code>, where <code>e</code>,
 <code>p</code>?, and <code>d</code> are applicatives, as follows.  Each call to
 <code>make-encapsulation-type</code> returns different applicatives
diff --git a/doc/html/Environments.html b/doc/html/Environments.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">8 Environments</h2>
 
-<p><a name="index-environments-94"></a><a name="index-ignore-95"></a>
+<p><a name="index-environments-104"></a><a name="index-ignore-105"></a>
   An environment consists of a set of bindings, and a list of zero or
 more references to other environments called its parents. 
 <!-- TODO add xref to lookup algo & ground env -->
@@ -55,28 +55,28 @@ external representation <code>#ignore</code>.  The ignore type is
 encapsulated.
 
 <div class="defun">
-&mdash; Applicative: <b>environment?</b> (<var>environment? . objects</var>)<var><a name="index-environment_003f-96"></a></var><br>
+&mdash; Applicative: <b>environment?</b> (<var>environment? . objects</var>)<var><a name="index-environment_003f-106"></a></var><br>
 <blockquote><p>  The primitive type predicate for type environment. 
 <code>environment?</code> returns true iff all the objects in <code>objects</code>
 are of type environment. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>ignore?</b> (<var>ignore? . objects</var>)<var><a name="index-ignore_003f-97"></a></var><br>
+&mdash; Applicative: <b>ignore?</b> (<var>ignore? . objects</var>)<var><a name="index-ignore_003f-107"></a></var><br>
 <blockquote><p>  The primitive type predicate for type ignore.  <code>ignore?</code>
 returns true iff all the objects in <code>objects</code> are of type ignore. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>eval</b> (<var>eval expression environment</var>)<var><a name="index-eval-98"></a></var><br>
+&mdash; Applicative: <b>eval</b> (<var>eval expression environment</var>)<var><a name="index-eval-108"></a></var><br>
 <blockquote><!-- TODO add xref to tail context -->
      <!-- TODO add xref to evaluation description -->
-        <p>The <code>eval</code> applicative evaluates <code>expression</code> as a tail
-context in <code>environment</code>, and returns the resulting value. 
+        <p>The <code>eval</code> applicative evaluates <code>expression</code> in
+<code>environment</code>, as a tail context, returning the resulting value. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>make-environment</b> (<var>make-environment . environments</var>)<var><a name="index-make_002denvironment-99"></a></var><br>
+&mdash; Applicative: <b>make-environment</b> (<var>make-environment . environments</var>)<var><a name="index-make_002denvironment-109"></a></var><br>
 <blockquote><p>  The applicative constructs and returns a new environment, with
 initially no local bindings, and parent environments the environments
 listed in <code>environments</code>. The constructed environment internally
@@ -92,7 +92,7 @@ the parents.  No two objects returned by different calls to
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$define!</b> (<var>$define! &lt;definiend&gt; &lt;expression&gt;</var>)<var><a name="index-g_t_0024define_0021-100"></a></var><br>
+&mdash; Operative: <b>$define!</b> (<var>$define! &lt;definiend&gt; &lt;expression&gt;</var>)<var><a name="index-g_t_0024define_0021-110"></a></var><br>
 <blockquote><!-- TODO move formal parameter tree definition to the intro -->
      <!-- TODO move matching definition to the intro -->
         <p><code>&lt;definiend&gt;</code> should be a formal parameter tree, as described
@@ -140,7 +140,7 @@ fails). The car of <code>t</code> is matched to the car of <code>o</code> in
         </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$let</b> (<var>$let &lt;bindings&gt; . &lt;objects&gt;</var>)<var><a name="index-g_t_0024let-101"></a></var><br>
+&mdash; Operative: <b>$let</b> (<var>$let &lt;bindings&gt; . &lt;objects&gt;</var>)<var><a name="index-g_t_0024let-111"></a></var><br>
 <blockquote><!-- TODO add xref to formal parameter tree -->
         <p><code>&lt;bindings&gt;</code> should be a finite list of
 formal-parameter-tree/expression pairings, each of the form
@@ -164,7 +164,7 @@ to right, with the last (if any) evaluated as a tail context, or if
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$binds?</b> (<var>$binds? &lt;exp&gt; . &lt;symbols&gt;</var>)<var><a name="index-g_t_0024binds_003f-102"></a></var><br>
+&mdash; Operative: <b>$binds?</b> (<var>$binds? &lt;exp&gt; . &lt;symbols&gt;</var>)<var><a name="index-g_t_0024binds_003f-112"></a></var><br>
 <blockquote><p>  Operative <code>$binds</code> evaluates <code>&lt;exp&gt;</code> in the dynamic
 environment; call the result <code>env</code>.  <code>env</code> must be an
 environment.  The operative is a predicate that returns true iff all
@@ -172,13 +172,13 @@ its later operands, <code>&lt;symbols&gt;</code>, are visibly bound in <code>env
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>get-current-environment</b> (<var>get-current-environment</var>)<var><a name="index-get_002dcurrent_002denvironment-103"></a></var><br>
+&mdash; Applicative: <b>get-current-environment</b> (<var>get-current-environment</var>)<var><a name="index-get_002dcurrent_002denvironment-113"></a></var><br>
 <blockquote><p>  The <code>get-current-environment</code> applicative returns the dynamic
 environment in which it is called. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>make-kernel-standard-environment</b> (<var>make-kernel-standard-environment</var>)<var><a name="index-make_002dkernel_002dstandard_002denvironment-104"></a></var><br>
+&mdash; Applicative: <b>make-kernel-standard-environment</b> (<var>make-kernel-standard-environment</var>)<var><a name="index-make_002dkernel_002dstandard_002denvironment-114"></a></var><br>
 <blockquote><!-- TODO add xref to ground environment/standard environment -->
         <p>The <code>make-kernel-standard-environment</code> applicative returns a
 standard environment; that is, a child of the ground environment with
@@ -186,7 +186,7 @@ no local bindings.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$let*</b> (<var>$let* &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024let_002a-105"></a></var><br>
+&mdash; Operative: <b>$let*</b> (<var>$let* &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024let_002a-115"></a></var><br>
 <blockquote><!-- TODO add xref to formal ptree -->
         <p><code>&lt;bindings&gt;</code> should be a finite list of
 formal-parameter-tree/expression pairings, each of the form
@@ -203,7 +203,7 @@ parameter tree; <code>&lt;body&gt;</code> should be a list of expressions.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$letrec</b> (<var>$letrec &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024letrec-106"></a></var><br>
+&mdash; Operative: <b>$letrec</b> (<var>$letrec &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024letrec-116"></a></var><br>
 <blockquote><!-- add xref for $let -->
         <p><code>&lt;bindings&gt;</code> and <code>&lt;body&gt;</code> should be as described for
 <code>$let</code>.
@@ -215,7 +215,7 @@ parameter tree; <code>&lt;body&gt;</code> should be a list of expressions.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$letrec*</b> (<var>$letrec* &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024letrec_002a-107"></a></var><br>
+&mdash; Operative: <b>$letrec*</b> (<var>$letrec* &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024letrec_002a-117"></a></var><br>
 <blockquote><!-- TODO add xref to $let* -->
         <p><code>&lt;bindings&gt;</code> and <code>&lt;body&gt;</code> should be as described for
 <code>$let*</code>.
@@ -229,7 +229,7 @@ parameter tree; <code>&lt;body&gt;</code> should be a list of expressions.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$let-redirect</b> (<var>$let-redirect &lt;exp&gt; &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024let_002dredirect-108"></a></var><br>
+&mdash; Operative: <b>$let-redirect</b> (<var>$let-redirect &lt;exp&gt; &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024let_002dredirect-118"></a></var><br>
 <blockquote><!-- TODO add xref to $let -->
         <p><code>&lt;bindings&gt;</code> and <code>&lt;body&gt;</code> should be as described for
 <code>$let</code>.
@@ -242,7 +242,7 @@ parameter tree; <code>&lt;body&gt;</code> should be a list of expressions.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$let-safe</b> (<var>$let-safe &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024let_002dsafe-109"></a></var><br>
+&mdash; Operative: <b>$let-safe</b> (<var>$let-safe &lt;bindings&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024let_002dsafe-119"></a></var><br>
 <blockquote><!-- TODO add xref to $let -->
         <p><code>&lt;bindings&gt;</code> and <code>&lt;body&gt;</code> should be as described for
 <code>$let</code>.
@@ -255,7 +255,7 @@ parameter tree; <code>&lt;body&gt;</code> should be a list of expressions.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$remote-eval</b> (<var>$remote-eval &lt;exp1&gt; &lt;exp2&gt;</var>)<var><a name="index-g_t_0024remote_002deval-110"></a></var><br>
+&mdash; Operative: <b>$remote-eval</b> (<var>$remote-eval &lt;exp1&gt; &lt;exp2&gt;</var>)<var><a name="index-g_t_0024remote_002deval-120"></a></var><br>
 <blockquote><!-- TODO add xref to tail context -->
         <p>Operative <code>$remote-eval</code> evaluates <code>&lt;exp2&gt;</code> in the dynamic
 environment, then evaluates <code>&lt;exp1&gt;</code> as a tail context in the
@@ -263,7 +263,7 @@ environment that must result from the first evaluation.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$bindings-&gt;environment</b> (<var>$bindings-&gt;environment . &lt;bindings&gt;</var>)<var><a name="index-g_t_0024bindings_002d_003eenvironment-111"></a></var><br>
+&mdash; Operative: <b>$bindings-&gt;environment</b> (<var>$bindings-&gt;environment . &lt;bindings&gt;</var>)<var><a name="index-g_t_0024bindings_002d_003eenvironment-121"></a></var><br>
 <blockquote><!-- TODO add xref to $let -->
         <p><code>&lt;bindings&gt;</code> should be as described for <code>$let</code>.
 
@@ -275,7 +275,19 @@ environment that must result from the first evaluation.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$set!</b> (<var>$set! &lt;exp1&gt; &lt;formals&gt; &lt;exp2&gt;</var>)<var><a name="index-g_t_0024set_0021-112"></a></var><br>
+&mdash; Applicative: <b>eval-string</b> (<var>eval-string string environment</var>)<var><a name="index-eval_002dstring-122"></a></var><br>
+<blockquote><p><code>string</code> should be the external representation of a single
+object.  If none or more than one external representation is found in
+<code>string</code> then an error is signaled.
+
+        <p>Applicative <code>eval-string</code> reads an external representation from
+string, and evaluates the resulting object in <code>environment</code>, as a
+tail context, returning the resulting value. 
+<!-- TODO add xref to tail context. -->
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Operative: <b>$set!</b> (<var>$set! &lt;exp1&gt; &lt;formals&gt; &lt;exp2&gt;</var>)<var><a name="index-g_t_0024set_0021-123"></a></var><br>
 <blockquote><!-- TODO add xref to $define! -->
      <!-- TODO add xref to matching algo -->
         <p><code>&lt;formals&gt;</code> should be as described for the <code>$define!</code>
@@ -289,7 +301,7 @@ The result returned by <code>$set!</code> is inert.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$provide!</b> (<var>$provide! &lt;symbols&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024provide_0021-113"></a></var><br>
+&mdash; Operative: <b>$provide!</b> (<var>$provide! &lt;symbols&gt; . &lt;body&gt;</var>)<var><a name="index-g_t_0024provide_0021-124"></a></var><br>
 <blockquote><p>  <code>&lt;symbols&gt;</code> must be a finite list of symbols, containing no
 duplicates.  <code>&lt;body&gt;</code> must be a finite list.
 
@@ -309,7 +321,7 @@ result of looking it up in <code>e</code>.  The result returned by
         </blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$import!</b> (<var>$import! &lt;exp&gt; . &lt;symbols&gt;</var>)<var><a name="index-g_t_0024import_0021-114"></a></var><br>
+&mdash; Operative: <b>$import!</b> (<var>$import! &lt;exp&gt; . &lt;symbols&gt;</var>)<var><a name="index-g_t_0024import_0021-125"></a></var><br>
 <blockquote><p>  <code>&lt;symbols&gt;</code> must be a list of symbols.
 
         <p>The <code>$import!</code> operative evaluates <code>&lt;exp&gt;</code> in the dynamic
diff --git a/doc/html/Equivalence.html b/doc/html/Equivalence.html
@@ -44,7 +44,7 @@ equivalence in the presence of mutation (<code>eq?</code>).
 &mdash; Applicative: <b>eq?</b> (<var>eq? . objects</var>)<var><a name="index-eq_003f-21"></a></var><br>
 <blockquote><p>  Predicate <code>eq?</code> returns true iff all of <code>objects</code> are
 effectively the same object, even in the presence of mutation. 
-<!-- todo maybe add more content here, specifical to klisp -->
+<!-- todo maybe add more content here, specific to klisp -->
 </p></blockquote></div>
 
 <div class="defun">
@@ -53,7 +53,7 @@ effectively the same object, even in the presence of mutation.
 &ldquo;look&rdquo; the same as long as nothing is mutated.  This is a weaker
 predicate than <code>eq?</code>; that is, <code>equal?</code> must return true
 whenever <code>eq?</code> would return true. 
-<!-- todo maybe add more content here, specifical to klisp -->
+<!-- todo maybe add more content here, specific to klisp -->
 </p></blockquote></div>
 
 <!-- *-texinfo-*- -->
diff --git a/doc/html/Keyed-Variables.html b/doc/html/Keyed-Variables.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">13 Keyed Variables</h2>
 
-<p><a name="index-keyed-variables-146"></a>
+<p><a name="index-keyed-variables-161"></a>
   A keyed variable is a device that associates a non-symbolic key (in
 the form of an accessor applicative) with a value depending on the
 context in which lookup occurs.  Kernel provides two types of keyed
@@ -44,14 +44,14 @@ environment.
 
 <h3 class="section">13.1 Keyed Dynamic Variables</h3>
 
-<p><a name="index-keyed-dynamic-variables-147"></a><!-- add cf xref static -->
+<p><a name="index-keyed-dynamic-variables-162"></a><!-- add cf xref static -->
 <!-- TODO add xref to dynamic extent -->
   A keyed dynamic variable is a device that associates a non-symbolic
 key (in the form of an accessor applicative) with a value depending on
 the dynamic extent in which lookup occurs.
 
 <div class="defun">
-&mdash; Applicative: <b>make-keyed-dynamic-variable</b> (<var>make-keyed-dynamic-variable</var>)<var><a name="index-make_002dkeyed_002ddynamic_002dvariable-148"></a></var><br>
+&mdash; Applicative: <b>make-keyed-dynamic-variable</b> (<var>make-keyed-dynamic-variable</var>)<var><a name="index-make_002dkeyed_002ddynamic_002dvariable-163"></a></var><br>
 <blockquote><p>  Returns a list of the form <code>(b a)</code>, where <code>b</code> and <code>a</code>
 are applicatives, as follows.  Each call to
 <code>make-keyed-dynamic-variable</code> returns different <code>b</code> and
@@ -74,13 +74,13 @@ call to <code>a</code> is not within the dynamic extent of any call to
 
 <h3 class="section">13.2 Keyed Static Variables</h3>
 
-<p><a name="index-keyed-static-variables-149"></a>  A keyed static variable is a device that binds data in an
+<p><a name="index-keyed-static-variables-164"></a>  A keyed static variable is a device that binds data in an
 environment by a non-symbolic key, where the key is an accessor
 applicative. 
 <!-- add cf xref dynamic -->
 
 <div class="defun">
-&mdash; Applicative: <b>make-keyed-static-variable</b> (<var>make-keyed-static-variable</var>)<var><a name="index-make_002dkeyed_002dstatic_002dvariable-150"></a></var><br>
+&mdash; Applicative: <b>make-keyed-static-variable</b> (<var>make-keyed-static-variable</var>)<var><a name="index-make_002dkeyed_002dstatic_002dvariable-165"></a></var><br>
 <blockquote><p>  Returns a list of the form <code>(b a)</code>, where <code>b</code> and <code>a</code>
 are applicatives, as follows.  Each call to <code>make-keyed-static-variable</code>
 returns different <code>b</code> and <code>a</code>.
diff --git a/doc/html/Numbers.html b/doc/html/Numbers.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">14 Numbers</h2>
 
-<p><a name="index-numbers-151"></a>
+<p><a name="index-numbers-166"></a>
 All numbers are immutable, and <code>equal?</code> iff <code>eq?</code>.  The
 number type is encapsulated.
 
@@ -90,74 +90,93 @@ narrow-arithmetic keyed dynamic variable.
 point.  No bounding or robustness info is kept.
 
 <div class="defun">
-&mdash; Applicative: <b>number?</b> (<var>number? . objects</var>)<var><a name="index-number_003f-152"></a></var><br>
+&mdash; Applicative: <b>number?</b> (<var>number? . objects</var>)<var><a name="index-number_003f-167"></a></var><br>
 <blockquote><p>  The primitive type predicate for type number.  <code>number?</code>
 returns true iff all the objects in <code>objects</code> are of type number. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>integer?</b> (<var>integer? . objects</var>)<var><a name="index-integer_003f-153"></a></var><br>
+&mdash; Applicative: <b>integer?</b> (<var>integer? . objects</var>)<var><a name="index-integer_003f-168"></a></var><br>
 <blockquote><p>  The primitive type predicate for number subtype integer. 
 <code>integer?</code>  returns true iff all the objects in <code>objects</code>
 are of type integer. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>rational?</b> (<var>rational? . objects</var>)<var><a name="index-rational_003f-154"></a></var><br>
+&mdash; Applicative: <b>exact-integer?</b> (<var>exact-integer? . objects</var>)<var><a name="index-exact_002dinteger_003f-169"></a></var><br>
+<blockquote><p>  The primitive type predicate for number subtype exact integer. 
+<code>exact-integer?</code>  returns true iff all the objects in
+<code>objects</code> are of type integer and exact.
+
+        <p>SOURCE NOTE: this is from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>u8?</b> (<var>u8? . objects</var>)<var><a name="index-u8_003f-170"></a></var><br>
+<blockquote><p>The primitive type predicate for number subtype exact integer between
+0 and 255.  This is the subtype used in bytevectors.  <code>u8?</code>
+returns true iff all the objects in <code>objects</code> are of type
+integer, are exact, and lie between 0 and 255 inclusive.
+
+        <p>SOURCE NOTE: this is handy for use with bytevectors. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>rational?</b> (<var>rational? . objects</var>)<var><a name="index-rational_003f-171"></a></var><br>
 <blockquote><p>  The primitive type predicate for number subtype rational. 
 <code>rational?</code>  returns true iff all the objects in <code>objects</code>
 are of type rational. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>real?</b> (<var>real? . objects</var>)<var><a name="index-real_003f-155"></a></var><br>
+&mdash; Applicative: <b>real?</b> (<var>real? . objects</var>)<var><a name="index-real_003f-172"></a></var><br>
 <blockquote><p>  The primitive type predicate for number subtype real. 
 <code>real?</code>  returns true iff all the objects in <code>objects</code>
 are of type real. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>finite?</b> (<var>finite? . numbers</var>)<var><a name="index-finite_003f-156"></a></var><br>
+&mdash; Applicative: <b>finite?</b> (<var>finite? . numbers</var>)<var><a name="index-finite_003f-173"></a></var><br>
 <blockquote><p>  Predicate <code>finite?</code> returns true iff all the numbers in
 <code>numbers</code> are finite. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>exact?</b> (<var>exact? . numbers</var>)<var><a name="index-exact_003f-157"></a></var><br>
+&mdash; Applicative: <b>exact?</b> (<var>exact? . numbers</var>)<var><a name="index-exact_003f-174"></a></var><br>
 <blockquote><p>  Predicate <code>exact?</code> returns true iff all the numbers in
 <code>numbers</code> are exact. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>inexact?</b> (<var>inexact? . numbers</var>)<var><a name="index-inexact_003f-158"></a></var><br>
+&mdash; Applicative: <b>inexact?</b> (<var>inexact? . numbers</var>)<var><a name="index-inexact_003f-175"></a></var><br>
 <blockquote><p>  Predicate <code>inexact?</code> returns true iff all the numbers in
 <code>numbers</code> are inexact. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>robust?</b> (<var>robust? . numbers</var>)<var><a name="index-robust_003f-159"></a></var><br>
+&mdash; Applicative: <b>robust?</b> (<var>robust? . numbers</var>)<var><a name="index-robust_003f-176"></a></var><br>
 <blockquote><p>  Predicate <code>robust?</code> returns true iff all the numbers in
 <code>numbers</code> are robust. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>undefined?</b> (<var>undefined? . numbers</var>)<var><a name="index-undefined_003f-160"></a></var><br>
+&mdash; Applicative: <b>undefined?</b> (<var>undefined? . numbers</var>)<var><a name="index-undefined_003f-177"></a></var><br>
 <blockquote><p>  Predicate <code>undefined?</code> returns true iff all the numbers in
 <code>numbers</code> are undefined. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>=?</b> (<var>=? . numbers</var>)<var><a name="index-g_t_003d_003f-161"></a></var><br>
+&mdash; Applicative: <b>=?</b> (<var>=? . numbers</var>)<var><a name="index-g_t_003d_003f-178"></a></var><br>
 <blockquote><p>  Applicative <code>=?</code> is a predicate that returns true iff all its
 arguments are numerically equal to each other.  If any of its
 arguments has no primary value, an error is signaled. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>&lt;?</b> (<var>&lt;? . reals</var>)<var><a name="index-g_t_003c_003f-162"></a></var><br>
-&mdash; Applicative: <b>&lt;=?</b> (<var>&lt;=? . reals</var>)<var><a name="index-g_t_003c_003d_003f-163"></a></var><br>
-&mdash; Applicative: <b>&gt;?</b> (<var>&gt;? . reals</var>)<var><a name="index-g_t_003e_003f-164"></a></var><br>
-&mdash; Applicative: <b>&gt;=?</b> (<var>&gt;=? . reals</var>)<var><a name="index-g_t_003e_003d_003f-165"></a></var><br>
+&mdash; Applicative: <b>&lt;?</b> (<var>&lt;? . reals</var>)<var><a name="index-g_t_003c_003f-179"></a></var><br>
+&mdash; Applicative: <b>&lt;=?</b> (<var>&lt;=? . reals</var>)<var><a name="index-g_t_003c_003d_003f-180"></a></var><br>
+&mdash; Applicative: <b>&gt;?</b> (<var>&gt;? . reals</var>)<var><a name="index-g_t_003e_003f-181"></a></var><br>
+&mdash; Applicative: <b>&gt;=?</b> (<var>&gt;=? . reals</var>)<var><a name="index-g_t_003e_003d_003f-182"></a></var><br>
 <blockquote><p>  Each of these applicatives is a predicate that returns true iff
 every two consecutive elements of <code>reals</code> have primary values in
 the order indicated by the name of the applicative.  If any element of
@@ -165,7 +184,7 @@ the order indicated by the name of the applicative.  If any element of
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>+</b> (<var>+ . numbers</var>)<var><a name="index-g_t_002b-166"></a></var><br>
+&mdash; Applicative: <b>+</b> (<var>+ . numbers</var>)<var><a name="index-g_t_002b-183"></a></var><br>
 <blockquote><p>  Applicative <code>+</code> returns the sum of the elements of numbers.  If
 numbers is empty, the sum of its elements is exact zero.  If a
 positive infinity is added to a negative infinity, the result has no
@@ -179,7 +198,7 @@ the cycle has no primary value.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>*</b> (<var>* . numbers</var>)<var><a name="index-g_t_002a-167"></a></var><br>
+&mdash; Applicative: <b>*</b> (<var>* . numbers</var>)<var><a name="index-g_t_002a-184"></a></var><br>
 <blockquote><p>  Applicative <code>*</code> returns the product of the elements of numbers. 
 If numbers is empty, the product of its elements is exact one.  If an
 infinity is multiplied by zero, the result has no primary value.  If
@@ -196,7 +215,7 @@ positive real, the product of the cycle has no primary value.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>-</b> (<var>- number . numbers</var>)<var><a name="index-g_t_002d-168"></a></var><br>
+&mdash; Applicative: <b>-</b> (<var>- number . numbers</var>)<var><a name="index-g_t_002d-185"></a></var><br>
 <blockquote><p>  <code>numbers</code> should be a nonempty list of numbers.
 
         <p>Applicative <code>-</code> returns the sum of <code>number</code> with the
@@ -204,7 +223,7 @@ negation of the sum of <code>numbers</code>.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>zero?</b> (<var>zero? . numbers</var>)<var><a name="index-zero_003f-169"></a></var><br>
+&mdash; Applicative: <b>zero?</b> (<var>zero? . numbers</var>)<var><a name="index-zero_003f-186"></a></var><br>
 <blockquote><p>  Applicative <code>zero?</code> is a predicate that returns true iff every
 element of <code>numbers</code> is zero.  For this purpose, a real number is
 zero if its primary value is zero.  If any element of numbers has no
@@ -212,9 +231,9 @@ primary value an error is signaled.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>div</b> (<var>div real1 real2</var>)<var><a name="index-div-170"></a></var><br>
-&mdash; Applicative: <b>mod</b> (<var>mod real1 real2</var>)<var><a name="index-mod-171"></a></var><br>
-&mdash; Applicative: <b>div-and-mod</b> (<var>div-and-mod real1 real2</var>)<var><a name="index-div_002dand_002dmod-172"></a></var><br>
+&mdash; Applicative: <b>div</b> (<var>div real1 real2</var>)<var><a name="index-div-187"></a></var><br>
+&mdash; Applicative: <b>mod</b> (<var>mod real1 real2</var>)<var><a name="index-mod-188"></a></var><br>
+&mdash; Applicative: <b>div-and-mod</b> (<var>div-and-mod real1 real2</var>)<var><a name="index-div_002dand_002dmod-189"></a></var><br>
 <blockquote><p>  For all three applicatives, if <code>real1</code> is infinite or
 <code>real2</code> is zero, an error is signaled.
 
@@ -229,9 +248,9 @@ whose first element is <code>n</code> and whose second element is
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>div0</b> (<var>div0 real1 real2</var>)<var><a name="index-div0-173"></a></var><br>
-&mdash; Applicative: <b>mod0</b> (<var>mod0 real1 real2</var>)<var><a name="index-mod0-174"></a></var><br>
-&mdash; Applicative: <b>div0-and-mod0</b> (<var>div0-and-mod0 real1 real2</var>)<var><a name="index-div0_002dand_002dmod0-175"></a></var><br>
+&mdash; Applicative: <b>div0</b> (<var>div0 real1 real2</var>)<var><a name="index-div0-190"></a></var><br>
+&mdash; Applicative: <b>mod0</b> (<var>mod0 real1 real2</var>)<var><a name="index-mod0-191"></a></var><br>
+&mdash; Applicative: <b>div0-and-mod0</b> (<var>div0-and-mod0 real1 real2</var>)<var><a name="index-div0_002dand_002dmod0-192"></a></var><br>
 <blockquote><p>  For all three applicatives, if <code>real1</code> is infinite or
 <code>real2</code> is zero, an error is signaled.
 
@@ -246,8 +265,8 @@ is <code>real1 - (real2 * n)</code>.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>positive?</b> (<var>positive? . reals</var>)<var><a name="index-positive_003f-176"></a></var><br>
-&mdash; Applicative: <b>negative?</b> (<var>negative? . reals</var>)<var><a name="index-negative_003f-177"></a></var><br>
+&mdash; Applicative: <b>positive?</b> (<var>positive? . reals</var>)<var><a name="index-positive_003f-193"></a></var><br>
+&mdash; Applicative: <b>negative?</b> (<var>negative? . reals</var>)<var><a name="index-negative_003f-194"></a></var><br>
 <blockquote><p>  Applicative <code>positive?</code> is a predicate that returns true iff
 every element of <code>reals</code> is greater than zero. Applicative
 <code>negative?</code> is a predicate that returns true iff every element of
@@ -256,8 +275,8 @@ has no primary value an error is signaled.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>odd?</b> (<var>odd? . integers</var>)<var><a name="index-odd_003f-178"></a></var><br>
-&mdash; Applicative: <b>even?</b> (<var>even? . integers</var>)<var><a name="index-even_003f-179"></a></var><br>
+&mdash; Applicative: <b>odd?</b> (<var>odd? . integers</var>)<var><a name="index-odd_003f-195"></a></var><br>
+&mdash; Applicative: <b>even?</b> (<var>even? . integers</var>)<var><a name="index-even_003f-196"></a></var><br>
 <blockquote><p>  Applicative <code>odd?</code> is a predicate that returns true iff every
 element of <code>integers</code> is odd.  Applicative <code>even?</code> is a
 predicate that returns true iff every element of <code>integers</code> is
@@ -266,7 +285,7 @@ error is signaled.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>abs</b> (<var>abs real</var>)<var><a name="index-abs-180"></a></var><br>
+&mdash; Applicative: <b>abs</b> (<var>abs real</var>)<var><a name="index-abs-197"></a></var><br>
 <blockquote><p>  Applicative <code>abs</code> returns the nonnegative real number with the
 same magnitude as <code>real</code>; that is, if <code>real</code> is nonnegative
 it returns <code>real</code>, otherwise it returns the negation of
@@ -274,8 +293,8 @@ it returns <code>real</code>, otherwise it returns the negation of
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>max</b> (<var>max . reals</var>)<var><a name="index-max-181"></a></var><br>
-&mdash; Applicative: <b>min</b> (<var>min . reals</var>)<var><a name="index-min-182"></a></var><br>
+&mdash; Applicative: <b>max</b> (<var>max . reals</var>)<var><a name="index-max-198"></a></var><br>
+&mdash; Applicative: <b>min</b> (<var>min . reals</var>)<var><a name="index-min-199"></a></var><br>
 <blockquote><p>  If <code>reals</code> is nil, applicative <code>max</code> returns exact
 negative infinity, and applicative <code>min</code> returns exact positive
 infinity.  If <code>reals</code> is non-nil, applicative <code>max</code> returns
@@ -284,8 +303,8 @@ the smallest number in <code>reals</code>.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>lcm</b> (<var>lcm . impints</var>)<var><a name="index-lcm-183"></a></var><br>
-&mdash; Applicative: <b>gcd</b> (<var>gcd . impints</var>)<var><a name="index-gcd-184"></a></var><br>
+&mdash; Applicative: <b>lcm</b> (<var>lcm . impints</var>)<var><a name="index-lcm-200"></a></var><br>
+&mdash; Applicative: <b>gcd</b> (<var>gcd . impints</var>)<var><a name="index-gcd-201"></a></var><br>
 <blockquote><p>  <code>impints</code> should be a list of improper integers, that is, real
 numbers each of which is either an integer or an infinity.
 
@@ -312,8 +331,8 @@ deleted.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>get-real-internal-bounds</b> (<var>get-real-internal-bounds real</var>)<var><a name="index-get_002dreal_002dinternal_002dbounds-185"></a></var><br>
-&mdash; Applicative: <b>get-real-exact-bounds</b> (<var>get-real-exact-bounds real</var>)<var><a name="index-get_002dreal_002dexact_002dbounds-186"></a></var><br>
+&mdash; Applicative: <b>get-real-internal-bounds</b> (<var>get-real-internal-bounds real</var>)<var><a name="index-get_002dreal_002dinternal_002dbounds-202"></a></var><br>
+&mdash; Applicative: <b>get-real-exact-bounds</b> (<var>get-real-exact-bounds real</var>)<var><a name="index-get_002dreal_002dexact_002dbounds-203"></a></var><br>
 <blockquote><p>  Applicative <code>get-real-internal-bounds</code> returns a freshly
 allocated list of reals <code>(x1 x2)</code>, where the primary value of
 <code>x1</code> is the lower bound of <code>real</code>, using the same internal
@@ -333,8 +352,8 @@ the upper bound of <code>real</code>.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>get-real-internal-primary</b> (<var>get-real-internal-primary real</var>)<var><a name="index-get_002dreal_002dinternal_002dprimary-187"></a></var><br>
-&mdash; Applicative: <b>get-real-exact-primary</b> (<var>get-real-exact-primary real</var>)<var><a name="index-get_002dreal_002dexact_002dprimary-188"></a></var><br>
+&mdash; Applicative: <b>get-real-internal-primary</b> (<var>get-real-internal-primary real</var>)<var><a name="index-get_002dreal_002dinternal_002dprimary-204"></a></var><br>
+&mdash; Applicative: <b>get-real-exact-primary</b> (<var>get-real-exact-primary real</var>)<var><a name="index-get_002dreal_002dexact_002dprimary-205"></a></var><br>
 <blockquote><p>  If <code>real</code> is exact, both applicatives return <code>real</code>.  If
 <code>real</code> has no primary value, both applicatives signal an error.
 
@@ -356,7 +375,7 @@ support any exact <code>real</code> that reasonably approximates
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>make-inexact</b> (<var>make-inexact real1 real2 real3</var>)<var><a name="index-make_002dinexact-189"></a></var><br>
+&mdash; Applicative: <b>make-inexact</b> (<var>make-inexact real1 real2 real3</var>)<var><a name="index-make_002dinexact-206"></a></var><br>
 <blockquote><p>  Applicative <code>make-inexact</code> returns an inexact real number, as
 follows.  If <code>real2</code> is inexact, the result has the same primary
 value as <code>real2</code>; and if <code>real2</code> has no primary value, the
@@ -374,8 +393,8 @@ no less than the upper bound of <code>real3</code>, the primary value of
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>real-&gt;inexact</b> (<var>real-&gt;inexact real</var>)<var><a name="index-real_002d_003einexact-190"></a></var><br>
-&mdash; Applicative: <b>real-&gt;exact</b> (<var>real-&gt;exact real</var>)<var><a name="index-real_002d_003eexact-191"></a></var><br>
+&mdash; Applicative: <b>real-&gt;inexact</b> (<var>real-&gt;inexact real</var>)<var><a name="index-real_002d_003einexact-207"></a></var><br>
+&mdash; Applicative: <b>real-&gt;exact</b> (<var>real-&gt;exact real</var>)<var><a name="index-real_002d_003eexact-208"></a></var><br>
 <blockquote><!-- TODO add xref to get-real-exact-primary -->
         <p>Applicative <code>real-&gt;exact</code> behaves just as
 <code>get-real-exact-primary</code>.
@@ -391,8 +410,8 @@ and its bounds are only required to contain its primary value and
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>with-strict-arithmetic</b> (<var>with-strict-arithmetic boolean combiner</var>)<var><a name="index-with_002dstrict_002darithmetic-192"></a></var><br>
-&mdash; Applicative: <b>get-string-arithmetic</b> (<var>get-strict-arithmetic?</var>)<var><a name="index-get_002dstring_002darithmetic-193"></a></var><br>
+&mdash; Applicative: <b>with-strict-arithmetic</b> (<var>with-strict-arithmetic boolean combiner</var>)<var><a name="index-with_002dstrict_002darithmetic-209"></a></var><br>
+&mdash; Applicative: <b>get-string-arithmetic</b> (<var>get-strict-arithmetic?</var>)<var><a name="index-get_002dstring_002darithmetic-210"></a></var><br>
 <blockquote><!-- TODO add xref to dynamic keys and under/over flow, no prim value -->
         <p>These applicatives are the binder and accessor of the
 <code>strict-arithmetic</code> keyed dynamic variable.  When this keyed
@@ -402,7 +421,7 @@ and over- and underflows.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>/</b> (<var>/ number . numbers</var>)<var><a name="index-g_t_002f-194"></a></var><br>
+&mdash; Applicative: <b>/</b> (<var>/ number . numbers</var>)<var><a name="index-g_t_002f-211"></a></var><br>
 <blockquote><p>  <code>numbers</code> should be a nonempty list of numbers.
 
         <p>Applicative <code>/</code> returns <code>number</code> divided by the product of
@@ -412,8 +431,8 @@ infinite, an error is signaled.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>numerator</b> (<var>numerator rational</var>)<var><a name="index-numerator-195"></a></var><br>
-&mdash; Applicative: <b>denominator</b> (<var>denominator rational</var>)<var><a name="index-denominator-196"></a></var><br>
+&mdash; Applicative: <b>numerator</b> (<var>numerator rational</var>)<var><a name="index-numerator-212"></a></var><br>
+&mdash; Applicative: <b>denominator</b> (<var>denominator rational</var>)<var><a name="index-denominator-213"></a></var><br>
 <blockquote><p>  These applicatives return the numerator and denominator of
 <code>rational</code>, in least terms (i.e., chosen for the least positive
 denominator).  Note that if <code>rational</code> is inexact, and either of
@@ -424,10 +443,10 @@ both signs).
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>floor</b> (<var>floor real</var>)<var><a name="index-floor-197"></a></var><br>
-&mdash; Applicative: <b>ceiling</b> (<var>ceiling real</var>)<var><a name="index-ceiling-198"></a></var><br>
-&mdash; Applicative: <b>truncate</b> (<var>truncate real</var>)<var><a name="index-truncate-199"></a></var><br>
-&mdash; Applicative: <b>round</b> (<var>round real</var>)<var><a name="index-round-200"></a></var><br>
+&mdash; Applicative: <b>floor</b> (<var>floor real</var>)<var><a name="index-floor-214"></a></var><br>
+&mdash; Applicative: <b>ceiling</b> (<var>ceiling real</var>)<var><a name="index-ceiling-215"></a></var><br>
+&mdash; Applicative: <b>truncate</b> (<var>truncate real</var>)<var><a name="index-truncate-216"></a></var><br>
+&mdash; Applicative: <b>round</b> (<var>round real</var>)<var><a name="index-round-217"></a></var><br>
 <blockquote><p>  Applicative <code>floor</code> returns the largest integer not greater
 than <code>real</code>.
 
@@ -443,8 +462,8 @@ rounding to even when <code>real</code> is halfway between two integers.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>rationalize</b> (<var>rationalize real1 real2</var>)<var><a name="index-rationalize-201"></a></var><br>
-&mdash; Applicative: <b>simplest-rational</b> (<var>simplest-rational real1 real2</var>)<var><a name="index-simplest_002drational-202"></a></var><br>
+&mdash; Applicative: <b>rationalize</b> (<var>rationalize real1 real2</var>)<var><a name="index-rationalize-218"></a></var><br>
+&mdash; Applicative: <b>simplest-rational</b> (<var>simplest-rational real1 real2</var>)<var><a name="index-simplest_002drational-219"></a></var><br>
 <blockquote><p>  A rational number <code>r1</code> is simpler than another rational
 <code>r2</code> if <code>r1 = p1 / q1</code> and <code>r2 = p2 / q2</code>, both in
 lowest terms, and <code>|p1| &lt;= |p2|</code> and <code>|q1| &lt;= |q2|</code>. Thus
@@ -484,29 +503,81 @@ primary values of the arguments; but the result is an approximation of
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>exp</b> (<var>exp number</var>)<var><a name="index-exp-203"></a></var><br>
-&mdash; Applicative: <b>log</b> (<var>log number</var>)<var><a name="index-log-204"></a></var><br>
-<blockquote><p>TODO
+&mdash; Applicative: <b>sqrt</b> (<var>sqrt number</var>)<var><a name="index-sqrt-220"></a></var><br>
+<blockquote><p>If <code>number</code> is negative, the result is undefined.
+
+        <p>Applicative <code>sqrt</code> returns the positive square root of number. 
+The result may be inexact even if <code>number</code> is exact and the
+square root is rational. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>sin</b> (<var>sin number</var>)<var><a name="index-sin-205"></a></var><br>
-&mdash; Applicative: <b>cos</b> (<var>cos number</var>)<var><a name="index-cos-206"></a></var><br>
-&mdash; Applicative: <b>tan</b> (<var>tan number</var>)<var><a name="index-tan-207"></a></var><br>
-<blockquote><p>TODO
+&mdash; Applicative: <b>expt</b> (<var>expt number1 number2</var>)<var><a name="index-expt-221"></a></var><br>
+<blockquote><p>Applicative <code>expt</code> returns <code>number1</code> to the power of
+<code>number2</code>.  If <code>number1</code> is zero, then the result is 1 if
+<code>number2</code> is zero and 0 otherwise. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>asin</b> (<var>asin number</var>)<var><a name="index-asin-208"></a></var><br>
-&mdash; Applicative: <b>acos</b> (<var>acos number</var>)<var><a name="index-acos-209"></a></var><br>
-&mdash; Applicative: <b>atan</b> (<var>atan number1 </var>[<var>number2</var>])<var><a name="index-atan-210"></a></var><br>
-<blockquote><p>TODO
+&mdash; Applicative: <b>exp</b> (<var>exp number</var>)<var><a name="index-exp-222"></a></var><br>
+&mdash; Applicative: <b>log</b> (<var>log number</var>)<var><a name="index-log-223"></a></var><br>
+&mdash; Applicative: <b>sin</b> (<var>sin number</var>)<var><a name="index-sin-224"></a></var><br>
+&mdash; Applicative: <b>cos</b> (<var>cos number</var>)<var><a name="index-cos-225"></a></var><br>
+&mdash; Applicative: <b>tan</b> (<var>tan number</var>)<var><a name="index-tan-226"></a></var><br>
+&mdash; Applicative: <b>asin</b> (<var>asin number</var>)<var><a name="index-asin-227"></a></var><br>
+&mdash; Applicative: <b>acos</b> (<var>acos number</var>)<var><a name="index-acos-228"></a></var><br>
+&mdash; Applicative: <b>atan</b> (<var>atan number1 </var>[<var>number2</var>])<var><a name="index-atan-229"></a></var><br>
+<blockquote><p>These applicatives compute the usual transcendental functions. 
+<code>log</code> computes the natural logarithm (not the base-10 logarithm). 
+The two argument version of <code>atan</code> computes <code>(angle
+(make-recutangular number1 number2))</code> even thou klisp doesn't support
+complex numbers.
+
+        <p>All results may be inexact even if <code>number</code> is exact and the
+result of the transcendental function is rational. 
+TODO add intervals returned for multidefined functions (inverses and log)
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>string-&gt;number</b> (<var>string-&gt;number string </var>[<var>radix</var>])<var><a name="index-string_002d_003enumber-230"></a></var><br>
+<blockquote><p><code>radix</code> should be an exact integer, either 2, 8, 10, or 16. 
+<code>string</code> should be a string describing a number in the specified
+radix, but may contain a radix prefix to override it.  The default
+<code>radix</code>, if not supplied, is 10.
+
+        <p>Applicative <code>string-&gt;number</code> returns the best approximation of
+the number represented by <code>string</code>.  If <code>string</code> is not a
+valid representation of a number in the given <code>radix</code> an error is
+signaled.
+
+        <p>Examples:
+     <pre class="example">          (string-&gt;number "100") &rArr; 100
+          (string-&gt;number "100" 16) &rArr; 256
+          (string-&gt;number "#o100" 2) &rArr; 64
+          (string-&gt;number "1.0") &rArr; 1.0
+</pre>
+        <p>SOURCE NOTE: this is taken from r7rs. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>sqrt</b> (<var>sqrt number</var>)<var><a name="index-sqrt-211"></a></var><br>
-&mdash; Applicative: <b>expt</b> (<var>expt number1 number2</var>)<var><a name="index-expt-212"></a></var><br>
-<blockquote><p>TODO
+&mdash; Applicative: <b>number-&gt;string</b> (<var>number-&gt;string number </var>[<var>radix</var>])<var><a name="index-number_002d_003estring-231"></a></var><br>
+<blockquote><p><code>radix</code> should be an exact integer, either 2, 8, 10, or 16.  The
+default <code>radix</code>, if not supplied, is 10.
+
+        <p>Applicative <code>number-&gt;string</code> returns a string representing
+<code>number</code> in the given <code>radix</code>.  No radix prefix is present
+in the returned string.  If an inexact number is passed together with
+a radix other from 10, an error is signaled.
+
+        <p>The returned string is such that
+     <pre class="example">          (string-&gt;number (number-&gt;string number radix) radix) == number
+</pre>
+        <p>Examples:
+     <pre class="example">          (number-&gt;string 100) &rArr; "100"
+          (number-&gt;string 256 16) &rArr; "100"
+          (number-&gt;string 1.0) &rArr; "1.0"
+</pre>
+        <p>SOURCE NOTE: this is taken from r7rs. 
 </p></blockquote></div>
 
 <!-- *-texinfo-*- -->
diff --git a/doc/html/Pairs-and-lists.html b/doc/html/Pairs-and-lists.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">7 Pairs and lists</h2>
 
-<p><a name="index-pairs-34"></a><a name="index-nil-35"></a><a name="index-empty-list-36"></a><a name="index-lists-37"></a>
+<p><a name="index-pairs-39"></a><a name="index-nil-40"></a><a name="index-empty-list-41"></a><a name="index-lists-42"></a>
 A pair is an object that refers to two other objects, called its car
 and cdr.  The Kernel data type pair is encapsulated.
 
@@ -59,19 +59,30 @@ representation <code>(1 . (2 . (3 . ())))</code> would be output using,
 modulo whitespace, external representation <code>(1 2 3)</code>.
 
 <div class="defun">
-&mdash; Applicative: <b>pair?</b> (<var>pair? . objects</var>)<var><a name="index-pair_003f-38"></a></var><br>
+&mdash; Applicative: <b>pair?</b> (<var>pair? . objects</var>)<var><a name="index-pair_003f-43"></a></var><br>
 <blockquote><p>  The primitive type predicate for type pair.  <code>pair?</code> returns
 true iff all the objects in <code>objects</code> are of type pair. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>null?</b> (<var>null? . objects</var>)<var><a name="index-null_003f-39"></a></var><br>
+&mdash; Applicative: <b>null?</b> (<var>null? . objects</var>)<var><a name="index-null_003f-44"></a></var><br>
 <blockquote><p>  The primitive type predicate for type null.  <code>null?</code> returns
 true iff all the objects in <code>objects</code> are of type null. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>cons</b> (<var>cons object1 object2</var>)<var><a name="index-cons-40"></a></var><br>
+&mdash; Applicative: <b>immutable-pair?</b> (<var>immutable-pair? objects</var>)<var><a name="index-immutable_002dpair_003f-45"></a></var><br>
+&mdash; Applicative: <b>mutable-pair?</b> (<var>mutable-pair? objects</var>)<var><a name="index-mutable_002dpair_003f-46"></a></var><br>
+<blockquote><p>The primitive type predicates for types immutable pair and mutable
+pair.  These return true iff all the objects in <code>objects</code> are of
+type immutable pair or mutable pair respectively.
+
+        <p>SOURCE NOTE: these aren't provided in the Kernel report, but added for
+convenience.  These can be implemented in standard kernel by using guards. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>cons</b> (<var>cons object1 object2</var>)<var><a name="index-cons-47"></a></var><br>
 <blockquote><p>  A new mutable pair object is constructed and returned, whose car and
 cdr referents are respectively <code>object1</code> and <code>object2</code>.  No
 two objects returned by different calls to cons are <code>eq?</code> to each
@@ -79,8 +90,8 @@ other.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>set-car!</b> (<var>set-car! pair object</var>)<var><a name="index-set_002dcar_0021-41"></a></var><br>
-&mdash; Applicative: <b>set-cdr!</b> (<var>set-cdr! pair object</var>)<var><a name="index-set_002dcdr_0021-42"></a></var><br>
+&mdash; Applicative: <b>set-car!</b> (<var>set-car! pair object</var>)<var><a name="index-set_002dcar_0021-48"></a></var><br>
+&mdash; Applicative: <b>set-cdr!</b> (<var>set-cdr! pair object</var>)<var><a name="index-set_002dcdr_0021-49"></a></var><br>
 <blockquote><p>  <code>pair</code> should be a mutable pair.
 
         <p>These applicatives set the referent of, respectively, the car
@@ -89,7 +100,7 @@ result of the expression is inert.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>copy-es-immutable!</b> (<var>copy-es-immutable object</var>)<var><a name="index-copy_002des_002dimmutable_0021-43"></a></var><br>
+&mdash; Applicative: <b>copy-es-immutable!</b> (<var>copy-es-immutable object</var>)<var><a name="index-copy_002des_002dimmutable_0021-50"></a></var><br>
 <blockquote><p>  The short description of this applicative is that it returns an object
 <code>equal?</code> to <code>object</code> with an immutable evaluation structure. The
 &ldquo;-es-&rdquo; in the name is short for &ldquo;evaluation structure&rdquo;.
@@ -115,7 +126,7 @@ that behaviour should not be depended upon.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>list</b> (<var>list . objects</var>)<var><a name="index-list-44"></a></var><br>
+&mdash; Applicative: <b>list</b> (<var>list . objects</var>)<var><a name="index-list-51"></a></var><br>
 <blockquote><p>The <code>list</code> applicative returns <code>objects</code>.
 
         <p>The underlying operative of <code>list</code> returns its undifferentiated
@@ -123,7 +134,7 @@ operand tree, regardless of whether that tree is or is not a list.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>list*</b> (<var>list* . objects</var>)<var><a name="index-list_002a-45"></a></var><br>
+&mdash; Applicative: <b>list*</b> (<var>list* . objects</var>)<var><a name="index-list_002a-52"></a></var><br>
 <blockquote><p><code>objects</code> should be a finite nonempty list of arguments.
 
         <p>The following equivalences hold:
@@ -133,40 +144,40 @@ operand tree, regardless of whether that tree is or is not a list.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>car</b> (<var>car pair</var>)<var><a name="index-car-46"></a></var><br>
-&mdash; Applicative: <b>cdr</b> (<var>cdr pair</var>)<var><a name="index-cdr-47"></a></var><br>
+&mdash; Applicative: <b>car</b> (<var>car pair</var>)<var><a name="index-car-53"></a></var><br>
+&mdash; Applicative: <b>cdr</b> (<var>cdr pair</var>)<var><a name="index-cdr-54"></a></var><br>
 <blockquote><p>These applicatives return, respectively, the car and cdr of <code>pair</code>. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>caar</b> (<var>caar pair</var>)<var><a name="index-caar-48"></a></var><br>
-&mdash; Applicative: <b>cadr</b> (<var>cadr pair</var>)<var><a name="index-cadr-49"></a></var><br>
-&mdash; Applicative: <b>cdar</b> (<var>cdar pair</var>)<var><a name="index-cdar-50"></a></var><br>
-&mdash; Applicative: <b>cddr</b> (<var>cddr pair</var>)<var><a name="index-cddr-51"></a></var><br>
-&mdash; Applicative: <b>caaar</b> (<var>caaar pair</var>)<var><a name="index-caaar-52"></a></var><br>
-&mdash; Applicative: <b>caadr</b> (<var>caadr pair</var>)<var><a name="index-caadr-53"></a></var><br>
-&mdash; Applicative: <b>cadar</b> (<var>cadar pair</var>)<var><a name="index-cadar-54"></a></var><br>
-&mdash; Applicative: <b>caddr</b> (<var>caddr pair</var>)<var><a name="index-caddr-55"></a></var><br>
-&mdash; Applicative: <b>cdaar</b> (<var>cdaar pair</var>)<var><a name="index-cdaar-56"></a></var><br>
-&mdash; Applicative: <b>cdadr</b> (<var>cdadr pair</var>)<var><a name="index-cdadr-57"></a></var><br>
-&mdash; Applicative: <b>cddar</b> (<var>cddar pair</var>)<var><a name="index-cddar-58"></a></var><br>
-&mdash; Applicative: <b>cdddr</b> (<var>cdddr pair</var>)<var><a name="index-cdddr-59"></a></var><br>
-&mdash; Applicative: <b>caaaar</b> (<var>caaaar pair</var>)<var><a name="index-caaaar-60"></a></var><br>
-&mdash; Applicative: <b>caaadr</b> (<var>caaadr pair</var>)<var><a name="index-caaadr-61"></a></var><br>
-&mdash; Applicative: <b>caadar</b> (<var>caadar pair</var>)<var><a name="index-caadar-62"></a></var><br>
-&mdash; Applicative: <b>caaddr</b> (<var>caaddr pair</var>)<var><a name="index-caaddr-63"></a></var><br>
-&mdash; Applicative: <b>cadaar</b> (<var>cadaar pair</var>)<var><a name="index-cadaar-64"></a></var><br>
-&mdash; Applicative: <b>cadadr</b> (<var>cadadr pair</var>)<var><a name="index-cadadr-65"></a></var><br>
-&mdash; Applicative: <b>caddar</b> (<var>caddar pair</var>)<var><a name="index-caddar-66"></a></var><br>
-&mdash; Applicative: <b>cadddr</b> (<var>cadddr pair</var>)<var><a name="index-cadddr-67"></a></var><br>
-&mdash; Applicative: <b>cdaaar</b> (<var>cdaaar pair</var>)<var><a name="index-cdaaar-68"></a></var><br>
-&mdash; Applicative: <b>cdaadr</b> (<var>cdaadr pair</var>)<var><a name="index-cdaadr-69"></a></var><br>
-&mdash; Applicative: <b>cdadar</b> (<var>cdadar pair</var>)<var><a name="index-cdadar-70"></a></var><br>
-&mdash; Applicative: <b>cdaddr</b> (<var>cdaddr pair</var>)<var><a name="index-cdaddr-71"></a></var><br>
-&mdash; Applicative: <b>cddaar</b> (<var>cddaar pair</var>)<var><a name="index-cddaar-72"></a></var><br>
-&mdash; Applicative: <b>cddadr</b> (<var>cddadr pair</var>)<var><a name="index-cddadr-73"></a></var><br>
-&mdash; Applicative: <b>cdddar</b> (<var>cdddar pair</var>)<var><a name="index-cdddar-74"></a></var><br>
-&mdash; Applicative: <b>cddddr</b> (<var>cddddr pair</var>)<var><a name="index-cddddr-75"></a></var><br>
+&mdash; Applicative: <b>caar</b> (<var>caar pair</var>)<var><a name="index-caar-55"></a></var><br>
+&mdash; Applicative: <b>cadr</b> (<var>cadr pair</var>)<var><a name="index-cadr-56"></a></var><br>
+&mdash; Applicative: <b>cdar</b> (<var>cdar pair</var>)<var><a name="index-cdar-57"></a></var><br>
+&mdash; Applicative: <b>cddr</b> (<var>cddr pair</var>)<var><a name="index-cddr-58"></a></var><br>
+&mdash; Applicative: <b>caaar</b> (<var>caaar pair</var>)<var><a name="index-caaar-59"></a></var><br>
+&mdash; Applicative: <b>caadr</b> (<var>caadr pair</var>)<var><a name="index-caadr-60"></a></var><br>
+&mdash; Applicative: <b>cadar</b> (<var>cadar pair</var>)<var><a name="index-cadar-61"></a></var><br>
+&mdash; Applicative: <b>caddr</b> (<var>caddr pair</var>)<var><a name="index-caddr-62"></a></var><br>
+&mdash; Applicative: <b>cdaar</b> (<var>cdaar pair</var>)<var><a name="index-cdaar-63"></a></var><br>
+&mdash; Applicative: <b>cdadr</b> (<var>cdadr pair</var>)<var><a name="index-cdadr-64"></a></var><br>
+&mdash; Applicative: <b>cddar</b> (<var>cddar pair</var>)<var><a name="index-cddar-65"></a></var><br>
+&mdash; Applicative: <b>cdddr</b> (<var>cdddr pair</var>)<var><a name="index-cdddr-66"></a></var><br>
+&mdash; Applicative: <b>caaaar</b> (<var>caaaar pair</var>)<var><a name="index-caaaar-67"></a></var><br>
+&mdash; Applicative: <b>caaadr</b> (<var>caaadr pair</var>)<var><a name="index-caaadr-68"></a></var><br>
+&mdash; Applicative: <b>caadar</b> (<var>caadar pair</var>)<var><a name="index-caadar-69"></a></var><br>
+&mdash; Applicative: <b>caaddr</b> (<var>caaddr pair</var>)<var><a name="index-caaddr-70"></a></var><br>
+&mdash; Applicative: <b>cadaar</b> (<var>cadaar pair</var>)<var><a name="index-cadaar-71"></a></var><br>
+&mdash; Applicative: <b>cadadr</b> (<var>cadadr pair</var>)<var><a name="index-cadadr-72"></a></var><br>
+&mdash; Applicative: <b>caddar</b> (<var>caddar pair</var>)<var><a name="index-caddar-73"></a></var><br>
+&mdash; Applicative: <b>cadddr</b> (<var>cadddr pair</var>)<var><a name="index-cadddr-74"></a></var><br>
+&mdash; Applicative: <b>cdaaar</b> (<var>cdaaar pair</var>)<var><a name="index-cdaaar-75"></a></var><br>
+&mdash; Applicative: <b>cdaadr</b> (<var>cdaadr pair</var>)<var><a name="index-cdaadr-76"></a></var><br>
+&mdash; Applicative: <b>cdadar</b> (<var>cdadar pair</var>)<var><a name="index-cdadar-77"></a></var><br>
+&mdash; Applicative: <b>cdaddr</b> (<var>cdaddr pair</var>)<var><a name="index-cdaddr-78"></a></var><br>
+&mdash; Applicative: <b>cddaar</b> (<var>cddaar pair</var>)<var><a name="index-cddaar-79"></a></var><br>
+&mdash; Applicative: <b>cddadr</b> (<var>cddadr pair</var>)<var><a name="index-cddadr-80"></a></var><br>
+&mdash; Applicative: <b>cdddar</b> (<var>cdddar pair</var>)<var><a name="index-cdddar-81"></a></var><br>
+&mdash; Applicative: <b>cddddr</b> (<var>cddddr pair</var>)<var><a name="index-cddddr-82"></a></var><br>
 <blockquote>
      <!-- TODO add note about pronunciation -->
         <p>These applicatives are compositions of <code>car</code> and <code>cdr</code>, with
@@ -177,7 +188,41 @@ twenty-eight of these applicatives in all.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>get-list-metrics</b> (<var>get-list-metrics object</var>)<var><a name="index-get_002dlist_002dmetrics-76"></a></var><br>
+&mdash; Applicative: <b>make-list</b> (<var>make-list length </var>[<var>fill</var>])<var><a name="index-make_002dlist-83"></a></var><br>
+<blockquote><p>  <code>length</code> shoulde be an exact non-negative integer.
+
+        <p>Applicative <code>make-list</code> creates a new mutable acyclic list of
+length <code>length</code>, with all pairs having <code>fill</code> in their
+cars.  If no value is provided for <code>fill</code>, <code>#inert</code> is used.
+
+        <p>SOURCE NOTE: this is taken from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>list-copy</b> (<var>list-copy list</var>)<var><a name="index-list_002dcopy-84"></a></var><br>
+<blockquote><p>Applicative <code>list-copy</code> creates a new mutable copy of
+<code>list</code>.  That is, the returned list has the same list metrics as
+<code>list</code> and the cars in the returned list are initially <code>eq?</code>
+to the corresponding cars in <code>list</code>.
+
+        <p>SOURCE NOTE: this is taken from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>reverse</b> (<var>reverse list</var>)<var><a name="index-reverse-85"></a></var><br>
+<blockquote><p><code>list</code> should be an acyclic list.
+
+        <p>Applicative <code>reverse</code> makes a mutable copy of list but with the
+reverse order.  That is, the returned list has the same number of
+pairs as <code>list</code> and the cars in the returned list are initially
+<code>eq?</code> to the corresponding cars in <code>list</code> but starting from
+the end and going backwards.
+
+        <p>SOURCE NOTE: this is taken from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>get-list-metrics</b> (<var>get-list-metrics object</var>)<var><a name="index-get_002dlist_002dmetrics-86"></a></var><br>
 <blockquote><!-- TODO move definition of improper list to intro, xref data structure -->
         <p>By definition, an improper list is a data structure whose objects
 are its start together with all objects reachable from the start by
@@ -206,7 +251,7 @@ is acyclic; if <code>n = 1</code>, the improper list is a finite list; if
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>list-tail</b> (<var>list-tail object k</var>)<var><a name="index-list_002dtail-77"></a></var><br>
+&mdash; Applicative: <b>list-tail</b> (<var>list-tail object k</var>)<var><a name="index-list_002dtail-87"></a></var><br>
 <blockquote><p><code>object</code> must be the start of an improper list containing at
 least <code>k</code> pairs.
 
@@ -220,7 +265,7 @@ starting from <code>object</code>.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>encycle!</b> (<var>encycle! object k1 k2</var>)<var><a name="index-encycle_0021-78"></a></var><br>
+&mdash; Applicative: <b>encycle!</b> (<var>encycle! object k1 k2</var>)<var><a name="index-encycle_0021-88"></a></var><br>
 <blockquote><p>  The improper list starting at <code>object</code> must contain at least
 <code>k1 + k2</code> pairs.
 
@@ -233,7 +278,7 @@ the <code>(k1 + 1)</code>th pair in the list.  The result returned by
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>map</b> (<var>map applicative . lists</var>)<var><a name="index-map-79"></a></var><br>
+&mdash; Applicative: <b>map</b> (<var>map applicative . lists</var>)<var><a name="index-map-89"></a></var><br>
 <blockquote><p>  <code>lists</code> must be a nonempty list of lists; if there are two or
 <!-- TODO add xref to length -->
 more, they must all have the same length.
@@ -259,7 +304,7 @@ called exactly <code>a + c</code> times.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>length</b> (<var>length object</var>)<var><a name="index-length-80"></a></var><br>
+&mdash; Applicative: <b>length</b> (<var>length object</var>)<var><a name="index-length-90"></a></var><br>
 <blockquote><!-- TODO xref improper-list -->
         <p>Applicative <code>length</code> returns the (exact) improper-list length
 of <code>object</code>.  That is, it returns the number of consecutive cdr
@@ -269,7 +314,7 @@ cyclic list, it returns positive infinity.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>list-ref</b> (<var>list-ref object k</var>)<var><a name="index-list_002dref-81"></a></var><br>
+&mdash; Applicative: <b>list-ref</b> (<var>list-ref object k</var>)<var><a name="index-list_002dref-91"></a></var><br>
 <blockquote><p>  The <code>list-ref</code> applicative returns the <code>car</code> of the object
 obtained by following <code>k</code> cdr references starting from
 <code>object</code>.
@@ -283,7 +328,7 @@ in line with the applicative <code>list-tail</code>.  That is, we define
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>append</b> (<var>append . lists</var>)<var><a name="index-append-82"></a></var><br>
+&mdash; Applicative: <b>append</b> (<var>append . lists</var>)<var><a name="index-append-92"></a></var><br>
 <blockquote><p>  Here, all the elements of <code>lists</code> except the last element (if
 any) must be acyclic lists.  The <code>append</code> applicative returns a
 freshly allocated list of the elements of all the specified
@@ -307,7 +352,7 @@ lists specified in the cycle of <code>lists</code>.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>list-neighbors</b> (<var>list-neighbors list</var>)<var><a name="index-list_002dneighbors-83"></a></var><br>
+&mdash; Applicative: <b>list-neighbors</b> (<var>list-neighbors list</var>)<var><a name="index-list_002dneighbors-93"></a></var><br>
 <blockquote><p>  The <code>list-neighbors</code> applicative constructs and returns a list
 of all the consecutive sublists of <code>list</code> of length 2, in order. 
 If <code>list</code> is nil, the result is nil.  If <code>list</code> is non-nil,
@@ -323,7 +368,7 @@ length).
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>filter</b> (<var>filter applicative list</var>)<var><a name="index-filter-84"></a></var><br>
+&mdash; Applicative: <b>filter</b> (<var>filter applicative list</var>)<var><a name="index-filter-94"></a></var><br>
 <blockquote><p>  Applicative <code>filter</code> passes each of the elements of <code>list</code>
 as an argument to <code>applicative</code>, one at a time in no particular
 order, using a fresh empty environment for each call.  The result of
@@ -338,37 +383,41 @@ the result is acyclic.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>assoc</b> (<var>assoc object pairs</var>)<var><a name="index-assoc-85"></a></var><br>
+&mdash; Applicative: <b>assoc</b> (<var>assoc object pairs </var>[<var>eq-pred?</var>])<var><a name="index-assoc-95"></a></var><br>
 <blockquote><p>  Applicative <code>assoc</code> returns the first element of <code>pairs</code>
-whose car is <code>equal?</code> to <code>object</code>.  If there is no such
-element in <code>pairs</code>, nil is returned. 
+whose car is <code>eq-pred?</code> to <code>object</code>.  If there is no such
+element in <code>pairs</code>, nil is returned.  If <code>eq-pred?</code> is not
+supplied it defaults to <code>equal?</code>. 
 <!-- TODO add xref/comp to assq -->
 <!-- TODO add xref to equal? -->
+SOURCE NOTE: the optional eq-pred? argument is from r7rs. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>member?</b> (<var>member? object list</var>)<var><a name="index-member_003f-86"></a></var><br>
+&mdash; Applicative: <b>member?</b> (<var>member? object list </var>[<var>eq-pred?</var>])<var><a name="index-member_003f-96"></a></var><br>
 <blockquote><p>  Applicative <code>member?</code> is a predicate that returns true iff some
-element of <code>list</code> is <code>equal?</code> to <code>object</code>. 
+element of <code>list</code> is <code>eq-pred?</code> to <code>object</code>.  If
+<code>eq-pred?</code> is not supplied, it defaults to <code>equal?</code>. 
 <!-- TODO add xref/comp to memq -->
 <!-- TODO add xref to equal? -->
+SOURCE NOTE: the optional eq-pred? argument is from r7rs. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>finite-list?</b> (<var>finite-list? . objects</var>)<var><a name="index-finite_002dlist_003f-87"></a></var><br>
+&mdash; Applicative: <b>finite-list?</b> (<var>finite-list? . objects</var>)<var><a name="index-finite_002dlist_003f-97"></a></var><br>
 <blockquote><p>  This is the type predicate for type finite-list. 
 <code>finite-list?</code>  returns true iff all the objects in
 <code>objects</code> are acyclic lists. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>countable-list?</b> (<var>countable-list? . objects</var>)<var><a name="index-countable_002dlist_003f-88"></a></var><br>
+&mdash; Applicative: <b>countable-list?</b> (<var>countable-list? . objects</var>)<var><a name="index-countable_002dlist_003f-98"></a></var><br>
 <blockquote><p>This is the type predicate for type list.  <code>countable-list?</code>
 returns true iff all the objects in <code>objects</code> are lists. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>reduce</b> (<var>reduce list binary identity </var>[<var>precycle incycle postcycle</var>])<var><a name="index-reduce-89"></a></var><br>
+&mdash; Applicative: <b>reduce</b> (<var>reduce list binary identity </var>[<var>precycle incycle postcycle</var>])<var><a name="index-reduce-99"></a></var><br>
 <blockquote><p>  <code>binary</code> should be an applicative. If the short form is used,
 <code>list</code> should be an acyclic. If the long form is used,
 <code>precycle</code>, <code>incycle</code>, and <code>postcycle</code> should be
@@ -409,7 +458,7 @@ times; <code>incycle</code>, <code>c - 1</code> times; and <code>postcycle</code
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>append!</b> (<var>append! . lists</var>)<var><a name="index-append_0021-90"></a></var><br>
+&mdash; Applicative: <b>append!</b> (<var>append! . lists</var>)<var><a name="index-append_0021-100"></a></var><br>
 <blockquote><p>  <code>lists</code> must be a nonempty list; its first element must be an
 acyclic nonempty list, and all of its elements except the last element
 (if any) must be acyclic lists.
@@ -427,7 +476,7 @@ The result returned by this applicative is inert.
         </blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>copy-es</b> (<var>copy-es object</var>)<var><a name="index-copy_002des-91"></a></var><br>
+&mdash; Applicative: <b>copy-es</b> (<var>copy-es object</var>)<var><a name="index-copy_002des-101"></a></var><br>
 <blockquote><p>  Briefly, applicative <code>copy-es</code> returns an object initially
 <code>equal?</code> to <code>object</code> with a freshly constructed evaluation
 <!-- TODO add xref to evaluation structure -->
@@ -445,7 +494,7 @@ referents being <code>eq?</code>.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>assq</b> (<var>assq object pairs</var>)<var><a name="index-assq-92"></a></var><br>
+&mdash; Applicative: <b>assq</b> (<var>assq object pairs</var>)<var><a name="index-assq-102"></a></var><br>
 <blockquote><p>  Applicative <code>assq</code> returns the first element of <code>pairs</code>
 whose car is <code>eq?</code> to <code>object</code>.  If there is no such element
 in <code>pairs</code>, nil is returned. 
@@ -454,7 +503,7 @@ in <code>pairs</code>, nil is returned.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>memq?</b> (<var>memq? object list</var>)<var><a name="index-memq_003f-93"></a></var><br>
+&mdash; Applicative: <b>memq?</b> (<var>memq? object list</var>)<var><a name="index-memq_003f-103"></a></var><br>
 <blockquote><p>  Applicative <code>memq?</code> is a predicate that returns true iff some
 element of <code>list</code> is <code>eq?</code> to <code>object</code>. 
 <!-- TODO add xref/comp to member? -->
diff --git a/doc/html/Ports.html b/doc/html/Ports.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">17 Ports</h2>
 
-<p><a name="index-ports-258"></a>
+<p><a name="index-ports-287"></a>
   A port is an object that mediates data from an input or to a
 destination.  In the former case, the port is an input port, in the
 latter case, an output port.  The data itself can consist of either
@@ -55,17 +55,17 @@ an output only external representation (so that it can never be the
 normal result of a call to read).  The eof type is encapsulated.
 
    <p>SOURCE NOTE:  the eof type is not in the Kernel report, it is used in
-klisp and was taken from Scheme.
+klisp and was taken from r7rs.
 
 <div class="defun">
-&mdash; Applicative: <b>port?</b> (<var>port? . objects</var>)<var><a name="index-port_003f-259"></a></var><br>
+&mdash; Applicative: <b>port?</b> (<var>port? . objects</var>)<var><a name="index-port_003f-288"></a></var><br>
 <blockquote><p>  The primitive type predicate for type port.  <code>port?</code>
 returns true iff all the objects in <code>objects</code> are of type port. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>input-port?</b> (<var>input-port? . objects</var>)<var><a name="index-input_002dport_003f-260"></a></var><br>
-&mdash; Applicative: <b>output-port?</b> (<var>output-port? . objects</var>)<var><a name="index-output_002dport_003f-261"></a></var><br>
+&mdash; Applicative: <b>input-port?</b> (<var>input-port? . objects</var>)<var><a name="index-input_002dport_003f-289"></a></var><br>
+&mdash; Applicative: <b>output-port?</b> (<var>output-port? . objects</var>)<var><a name="index-output_002dport_003f-290"></a></var><br>
 <blockquote><p>  Applicative <code>input-port?</code> is a predicate that returns true
 unless one or more of its arguments is not an input port.  Applicative
 <code>output-port?</code> is a predicate that returns true unless one or
@@ -75,8 +75,8 @@ more of its arguments is not an output port.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>textual-port?</b> (<var>textual-port? . objects</var>)<var><a name="index-textual_002dport_003f-262"></a></var><br>
-&mdash; Applicative: <b>binary-port?</b> (<var>binary-port? . objects</var>)<var><a name="index-binary_002dport_003f-263"></a></var><br>
+&mdash; Applicative: <b>textual-port?</b> (<var>textual-port? . objects</var>)<var><a name="index-textual_002dport_003f-291"></a></var><br>
+&mdash; Applicative: <b>binary-port?</b> (<var>binary-port? . objects</var>)<var><a name="index-binary_002dport_003f-292"></a></var><br>
 <blockquote><p>  Applicative <code>textual-port?</code> is a predicate that returns true
 unless one or more of its arguments is not a textual port.  Applicative
 <code>binary-port?</code> is a predicate that returns true unless one or more of
@@ -84,13 +84,31 @@ its arguments is not a binary port.
 
         <p>Every port must be admitted by at least one of these two predicates.
 
-        <p>SOURCE NOTE: this is missing from Kernel, it is taken from Scheme. 
+        <p>SOURCE NOTE: this is missing from Kernel, it is taken from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>file-port?</b> (<var>file-port? . objects</var>)<var><a name="index-file_002dport_003f-293"></a></var><br>
+&mdash; Applicative: <b>string-port?</b> (<var>string-port? . objects</var>)<var><a name="index-string_002dport_003f-294"></a></var><br>
+&mdash; Applicative: <b>bytevector-port?</b> (<var>bytevector-port? . objects</var>)<var><a name="index-bytevector_002dport_003f-295"></a></var><br>
+<blockquote><p>These applictives are predicates that returns true unless one or more
+of its arguments is not file, string or bytevector port, repectively.
+
+        <p>Every port in klisp is be admitted by exactly one of these predicates.
+
+        <p>SOURCE NOTE: this is missing from Kernel. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>with-input-from-file</b> (<var>with-input-from-file string combiner</var>)<var><a name="index-with_002dinput_002dfrom_002dfile-264"></a></var><br>
-&mdash; Applicative: <b>with-output-to-file</b> (<var>with-output-to-file string combiner</var>)<var><a name="index-with_002doutput_002dto_002dfile-265"></a></var><br>
-&mdash; Applicative: <b>with-error-to-file</b> (<var>with-error-to-file string combiner</var>)<var><a name="index-with_002derror_002dto_002dfile-266"></a></var><br>
+&mdash; Applicative: <b>port-open?</b> (<var>port-open? port</var>)<var><a name="index-port_002dopen_003f-296"></a></var><br>
+<blockquote><p>Applicative <code>port-open?</code> returns true iff <code>port</code> is still
+open. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>with-input-from-file</b> (<var>with-input-from-file string combiner</var>)<var><a name="index-with_002dinput_002dfrom_002dfile-297"></a></var><br>
+&mdash; Applicative: <b>with-output-to-file</b> (<var>with-output-to-file string combiner</var>)<var><a name="index-with_002doutput_002dto_002dfile-298"></a></var><br>
+&mdash; Applicative: <b>with-error-to-file</b> (<var>with-error-to-file string combiner</var>)<var><a name="index-with_002derror_002dto_002dfile-299"></a></var><br>
 <blockquote><!-- add xref get-current-input-port/get-current-output-port -->
         <p>These three applicatives open the file named in <code>string</code> for
 textual input or output, an invoke the binder of either the
@@ -106,9 +124,9 @@ the text is still missing.  The third applicative is from Scheme.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>get-current-input-port</b> (<var>get-current-input-port</var>)<var><a name="index-get_002dcurrent_002dinput_002dport-267"></a></var><br>
-&mdash; Applicative: <b>get-current-output-port</b> (<var>get-current-output-port</var>)<var><a name="index-get_002dcurrent_002doutput_002dport-268"></a></var><br>
-&mdash; Applicative: <b>get-current-error-port</b> (<var>get-current-error-port</var>)<var><a name="index-get_002dcurrent_002derror_002dport-269"></a></var><br>
+&mdash; Applicative: <b>get-current-input-port</b> (<var>get-current-input-port</var>)<var><a name="index-get_002dcurrent_002dinput_002dport-300"></a></var><br>
+&mdash; Applicative: <b>get-current-output-port</b> (<var>get-current-output-port</var>)<var><a name="index-get_002dcurrent_002doutput_002dport-301"></a></var><br>
+&mdash; Applicative: <b>get-current-error-port</b> (<var>get-current-error-port</var>)<var><a name="index-get_002dcurrent_002derror_002dport-302"></a></var><br>
 <blockquote><p>  These are the accessors for the input-port, output-port, and
 error-port keyed dynamic variables repectively. 
 <!-- add xref to with-input-from-file, etc -->
@@ -119,8 +137,8 @@ the text is still missing.  The third applicative is from Scheme.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>open-input-file</b> (<var>open-input-file string</var>)<var><a name="index-open_002dinput_002dfile-270"></a></var><br>
-&mdash; Applicative: <b>open-binary-input-file</b> (<var>open-binary-input-file string</var>)<var><a name="index-open_002dbinary_002dinput_002dfile-271"></a></var><br>
+&mdash; Applicative: <b>open-input-file</b> (<var>open-input-file string</var>)<var><a name="index-open_002dinput_002dfile-303"></a></var><br>
+&mdash; Applicative: <b>open-binary-input-file</b> (<var>open-binary-input-file string</var>)<var><a name="index-open_002dbinary_002dinput_002dfile-304"></a></var><br>
 <blockquote><p>  <code>string</code> should be the name/path for an existing file.
 
         <p>Applicative <code>open-input-file</code> creates and returns a textual
@@ -131,12 +149,12 @@ In either case, if the file can't be opened (e.g. because it doesn't
 exists, or there's a permissions problem), an error is signaled.
 
         <p>SOURCE NOTE: open-input-file is enumerated in the Kernel report but
-the text is still missing. open-binary-input-file is from Scheme. 
+the text is still missing. open-binary-input-file is from r7rs. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>open-output-file</b> (<var>open-output-file string</var>)<var><a name="index-open_002doutput_002dfile-272"></a></var><br>
-&mdash; Applicative: <b>open-binary-output-file</b> (<var>open-binary-output-file string</var>)<var><a name="index-open_002dbinary_002doutput_002dfile-273"></a></var><br>
+&mdash; Applicative: <b>open-output-file</b> (<var>open-output-file string</var>)<var><a name="index-open_002doutput_002dfile-305"></a></var><br>
+&mdash; Applicative: <b>open-binary-output-file</b> (<var>open-binary-output-file string</var>)<var><a name="index-open_002dbinary_002doutput_002dfile-306"></a></var><br>
 <blockquote><p>  <code>string</code> should be the name/path for an existing file.
 
         <p>Applicative <code>open-output-file</code> creates and returns a textual
@@ -152,12 +170,32 @@ but that could change later (i.e. like in Scheme the behaviour should
 be considered unspecified).
 
         <p>SOURCE NOTE: open-output-file is enumerated in the Kernel report but
-the text is still missing. open-binary-output-file is from Scheme. 
+the text is still missing. open-binary-output-file is from r7rs. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>close-input-file</b> (<var>close-input-file input-port</var>)<var><a name="index-close_002dinput_002dfile-274"></a></var><br>
-&mdash; Applicative: <b>close-output-file</b> (<var>close-output-file output-port</var>)<var><a name="index-close_002doutput_002dfile-275"></a></var><br>
+&mdash; Applicative: <b>open-input-string</b> (<var>open-output-string string</var>)<var><a name="index-open_002dinput_002dstring-307"></a></var><br>
+&mdash; Applicative: <b>open-input-bytevector</b> (<var>open-output-bytevector bytevector</var>)<var><a name="index-open_002dinput_002dbytevector-308"></a></var><br>
+<blockquote><p>These applicative return a fresh input port that reads characters or
+unsigned bytes from the passed sequence.
+
+        <p>SOURCE NOTE: These are taken from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>open-output-string</b> (<var>open-output-string</var>)<var><a name="index-open_002doutput_002dstring-309"></a></var><br>
+&mdash; Applicative: <b>open-output-bytevector</b> (<var>open-output-bytevector</var>)<var><a name="index-open_002doutput_002dbytevector-310"></a></var><br>
+<blockquote><p>These applicative return a fresh output port that accumulates
+characters or unsigned bytes.  The accumulated data can be obtained
+via applicatives <code>get-ouput-string</code> and
+<code>get-output-bytevector</code>, respectively.
+
+        <p>SOURCE NOTE: This are taken from r7rs. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>close-input-file</b> (<var>close-input-file input-port</var>)<var><a name="index-close_002dinput_002dfile-311"></a></var><br>
+&mdash; Applicative: <b>close-output-file</b> (<var>close-output-file output-port</var>)<var><a name="index-close_002doutput_002dfile-312"></a></var><br>
 <blockquote><p>  These applicatives close the port argument, so that no more
 input/output may be performed on them, and the resources can be
 freed.  If the port was already closed these applicatives have no
@@ -172,9 +210,9 @@ probably be called close-input-port &amp; close-output-port.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>close-input-port</b> (<var>close-input-port input-port</var>)<var><a name="index-close_002dinput_002dport-276"></a></var><br>
-&mdash; Applicative: <b>close-output-port</b> (<var>close-output-port output-port</var>)<var><a name="index-close_002doutput_002dport-277"></a></var><br>
-&mdash; Applicative: <b>close-port</b> (<var>close-port port</var>)<var><a name="index-close_002dport-278"></a></var><br>
+&mdash; Applicative: <b>close-input-port</b> (<var>close-input-port input-port</var>)<var><a name="index-close_002dinput_002dport-313"></a></var><br>
+&mdash; Applicative: <b>close-output-port</b> (<var>close-output-port output-port</var>)<var><a name="index-close_002doutput_002dport-314"></a></var><br>
+&mdash; Applicative: <b>close-port</b> (<var>close-port port</var>)<var><a name="index-close_002dport-315"></a></var><br>
 <blockquote><p>  These applicatives close the port argument, so that no more
 input/output may be performed on them, and the resources can be
 freed.  If the port was already closed these applicatives have no
@@ -184,13 +222,13 @@ be used to selectively close only one direction of the port.
         <p>The result returned by applicatives <code>close-input-port</code>,
 <code>close-output-port</code>, and <code>close-port</code> is inert.
 
-        <p>SOURCE NOTE: this is from Scheme. The equivalent
+        <p>SOURCE NOTE: this is from r7rs. The equivalent
 <code>close-input-file</code> and <code>close-output-file</code> are probably name
 errors and only retained here till the draft standard rectifies them
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>read</b> (<var>read </var>[<var>textual-input-port</var>])<var><a name="index-read-279"></a></var><br>
+&mdash; Applicative: <b>read</b> (<var>read </var>[<var>textual-input-port</var>])<var><a name="index-read-316"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>input-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -206,7 +244,7 @@ still missing.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>write</b> (<var>write object </var>[<var>textual-output-port</var>])<var><a name="index-write-280"></a></var><br>
+&mdash; Applicative: <b>write</b> (<var>write object </var>[<var>textual-output-port</var>])<var><a name="index-write-317"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>output-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -224,8 +262,14 @@ still missing.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>call-with-input-file</b> (<var>call-with-input-file string combiner</var>)<var><a name="index-call_002dwith_002dinput_002dfile-281"></a></var><br>
-&mdash; Applicative: <b>call-with-output-file</b> (<var>call-with-output-file string combiner</var>)<var><a name="index-call_002dwith_002doutput_002dfile-282"></a></var><br>
+&mdash; Applicative: <b>write-simple</b> (<var>write-simple object </var>[<var>port</var>])<var><a name="index-write_002dsimple-318"></a></var><br>
+<blockquote><p>Applicative <code>write-simple</code> is like <code>write</code> except that it
+doesn't write sharing info. It will hang if handed a cyclic structure. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>call-with-input-file</b> (<var>call-with-input-file string combiner</var>)<var><a name="index-call_002dwith_002dinput_002dfile-319"></a></var><br>
+&mdash; Applicative: <b>call-with-output-file</b> (<var>call-with-output-file string combiner</var>)<var><a name="index-call_002dwith_002doutput_002dfile-320"></a></var><br>
 <blockquote><p>  These applicatives open file named in <code>string</code> for textual
 input/output respectively and call their <code>combiner</code> argument in a
 fresh empty environment passing it as a sole operand the opened port. 
@@ -237,7 +281,7 @@ still missing.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>load</b> (<var>load string</var>)<var><a name="index-load-283"></a></var><br>
+&mdash; Applicative: <b>load</b> (<var>load string</var>)<var><a name="index-load-321"></a></var><br>
 <blockquote><!-- TODO add xref, open/input, read -->
         <p>Applicative <code>load</code> opens the file named <code>string</code> for
 textual input; reads objects from the file until the end of the file
@@ -253,7 +297,14 @@ return the value of the last evaluation.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>get-module</b> (<var>get-module string </var>[<var>environment</var>])<var><a name="index-get_002dmodule-284"></a></var><br>
+&mdash; Applicative: <b>require</b><var><a name="index-require-322"></a></var><br>
+<blockquote><p>TODO
+</p></blockquote></div>
+
+   <p>TODO
+
+<div class="defun">
+&mdash; Applicative: <b>get-module</b> (<var>get-module string </var>[<var>environment</var>])<var><a name="index-get_002dmodule-323"></a></var><br>
 <blockquote><!-- TODO add xref standard-environment, open/input, read -->
         <p>Applicative <code>get-module</code> creates a fresh standard environment;
 opens the file named <code>string</code> for textual input; reads objects
@@ -266,7 +317,7 @@ prior to evaluating read expressions, by binding symbol
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>eof-object?</b> (<var>eof-object? . objects</var>)<var><a name="index-eof_002dobject_003f-285"></a></var><br>
+&mdash; Applicative: <b>eof-object?</b> (<var>eof-object? . objects</var>)<var><a name="index-eof_002dobject_003f-324"></a></var><br>
 <blockquote><p>  The primitive type predicate for type eof.  <code>eof-object?</code>
 returns true iff all the objects in <code>objects</code> are of type eof.
 
@@ -277,7 +328,7 @@ primitive type predicates.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>read-char</b> (<var>read-char </var>[<var>textual-input-port</var>])<var><a name="index-read_002dchar-286"></a></var><br>
+&mdash; Applicative: <b>read-char</b> (<var>read-char </var>[<var>textual-input-port</var>])<var><a name="index-read_002dchar-325"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>input-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -290,7 +341,7 @@ an <code>eof</code> if the end of file was reached.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>peek-char</b> (<var>peek-char </var>[<var>textual-input-port</var>])<var><a name="index-peek_002dchar-287"></a></var><br>
+&mdash; Applicative: <b>peek-char</b> (<var>peek-char </var>[<var>textual-input-port</var>])<var><a name="index-peek_002dchar-326"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>input-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -305,7 +356,7 @@ remains unchanged so that new call to <code>peek-char</code> or
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>char-ready?</b> (<var>char-ready? </var>[<var>textual-input-port</var>])<var><a name="index-char_002dready_003f-288"></a></var><br>
+&mdash; Applicative: <b>char-ready?</b> (<var>char-ready? </var>[<var>textual-input-port</var>])<var><a name="index-char_002dready_003f-327"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>input-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -320,7 +371,7 @@ the code to do this is non-portable.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>write-char</b> (<var>write-char char </var>[<var>textual-output-port</var>])<var><a name="index-write_002dchar-289"></a></var><br>
+&mdash; Applicative: <b>write-char</b> (<var>write-char char </var>[<var>textual-output-port</var>])<var><a name="index-write_002dchar-328"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>output-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -333,7 +384,7 @@ The result returned by <code>write-char</code> is inert.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>newline</b> (<var>newline </var>[<var>textal-ouput-port</var>])<var><a name="index-newline-290"></a></var><br>
+&mdash; Applicative: <b>newline</b> (<var>newline </var>[<var>textal-ouput-port</var>])<var><a name="index-newline-329"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>output-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -345,7 +396,7 @@ The result returned by <code>newline</code> is inert.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>display</b> (<var>display object </var>[<var>textual-output-port</var>])<var><a name="index-display-291"></a></var><br>
+&mdash; Applicative: <b>display</b> (<var>display object </var>[<var>textual-output-port</var>])<var><a name="index-display-330"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>output-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -360,7 +411,7 @@ within those strings and character objects are output as if by
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>read-u8</b> (<var>read-u8 </var>[<var>textual-input-port</var>])<var><a name="index-read_002du8-292"></a></var><br>
+&mdash; Applicative: <b>read-u8</b> (<var>read-u8 </var>[<var>textual-input-port</var>])<var><a name="index-read_002du8-331"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>input-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -374,7 +425,7 @@ the end of file was reached.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>peek-u8</b> (<var>peek-u8 </var>[<var>textual-input-port</var>])<var><a name="index-peek_002du8-293"></a></var><br>
+&mdash; Applicative: <b>peek-u8</b> (<var>peek-u8 </var>[<var>textual-input-port</var>])<var><a name="index-peek_002du8-332"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>input-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -390,7 +441,7 @@ same port return the same byte.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>u8-ready?</b> (<var>u8-ready? </var>[<var>textual-input-port</var>])<var><a name="index-u8_002dready_003f-294"></a></var><br>
+&mdash; Applicative: <b>u8-ready?</b> (<var>u8-ready? </var>[<var>textual-input-port</var>])<var><a name="index-u8_002dready_003f-333"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>input-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -405,7 +456,7 @@ the code to do this is non-portable.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>write-u8</b> (<var>write-u8 u8 </var>[<var>textual-output-port</var>])<var><a name="index-write_002du8-295"></a></var><br>
+&mdash; Applicative: <b>write-u8</b> (<var>write-u8 u8 </var>[<var>textual-output-port</var>])<var><a name="index-write_002du8-334"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>output-port</code> keyed dynamic variable is used.  If the
 port is closed, an error is signaled.
@@ -419,7 +470,7 @@ result returned by <code>write-u8</code> is inert.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>flush-output-port</b> (<var>flush-output-port </var>[<var>output-port</var>])<var><a name="index-flush_002doutput_002dport-296"></a></var><br>
+&mdash; Applicative: <b>flush-output-port</b> (<var>flush-output-port </var>[<var>output-port</var>])<var><a name="index-flush_002doutput_002dport-335"></a></var><br>
 <blockquote><p>  If the <code>port</code> optional argument is not specified, then the
 value of the <code>output-port</code> keyed dynamic variable is used.  If
 the <code>port</code> is closed or if it is not an output port, an error is
@@ -433,7 +484,7 @@ output port to the underlying file or device. The result returned by
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>file-exists?</b> (<var>file-exists? string</var>)<var><a name="index-file_002dexists_003f-297"></a></var><br>
+&mdash; Applicative: <b>file-exists?</b> (<var>file-exists? string</var>)<var><a name="index-file_002dexists_003f-336"></a></var><br>
 <blockquote><p>  <code>string</code> should be the name/path for a file.
 
         <p>Predicate <code>file-exists?</code> checks to see if a file named
@@ -443,7 +494,7 @@ output port to the underlying file or device. The result returned by
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>delete-file</b> (<var>delete-file string</var>)<var><a name="index-delete_002dfile-298"></a></var><br>
+&mdash; Applicative: <b>delete-file</b> (<var>delete-file string</var>)<var><a name="index-delete_002dfile-337"></a></var><br>
 <blockquote><p>  <code>string</code> should be the name/path for an existing file.
 
         <p>Applicative <code>delete-file</code> deletes the file named <code>string</code>. 
@@ -454,7 +505,7 @@ result returned by <code>delete-file</code> is inert.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>rename-file</b> (<var>rename-file string1 string2</var>)<var><a name="index-rename_002dfile-299"></a></var><br>
+&mdash; Applicative: <b>rename-file</b> (<var>rename-file string1 string2</var>)<var><a name="index-rename_002dfile-338"></a></var><br>
 <blockquote><p>  <code>string1</code> should be the name/path for an existing file,
 <code>string2</code> should be the name/path for a non existing file.
 
diff --git a/doc/html/Promises.html b/doc/html/Promises.html
@@ -34,7 +34,7 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">12 Promises</h2>
 
-<p><a name="index-promises-141"></a>
+<p><a name="index-promises-155"></a>
 <!-- TODO xref to $lazy, memoize, force -->
 A promise is an object that represents the potential to determine a
 value.  The value may be the result of an arbitrary computation that
@@ -64,14 +64,14 @@ the promises may or may not be <code>eq?</code>.  Two promises are
 <code>equal?</code> iff they are <code>eq?</code>.
 
 <div class="defun">
-&mdash; Applicative: <b>promise?</b> (<var>promise? . objects</var>)<var><a name="index-promise_003f-142"></a></var><br>
+&mdash; Applicative: <b>promise?</b> (<var>promise? . objects</var>)<var><a name="index-promise_003f-156"></a></var><br>
 <blockquote><p>  The primitive type predicate for type promise.  <code>promise?</code>
 returns true iff all the objects in <code>objects</code> are of type
 promise. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>force</b> (<var>force object</var>)<var><a name="index-force-143"></a></var><br>
+&mdash; Applicative: <b>force</b> (<var>force object</var>)<var><a name="index-force-157"></a></var><br>
 <blockquote><p>  If <code>object</code> is a promise, applicative <code>force</code> returns the
 value determined by promise; otherwise, it returns <code>object</code>.
 
@@ -81,7 +81,7 @@ how to force promises constructed by that constructor.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Operative: <b>$lazy</b> (<var>$lazy expression</var>)<var><a name="index-g_t_0024lazy-144"></a></var><br>
+&mdash; Operative: <b>$lazy</b> (<var>$lazy expression</var>)<var><a name="index-g_t_0024lazy-158"></a></var><br>
 <blockquote><p>  Operative <code>$lazy</code> constructs and returns a new object of type
 promise, representing potential evaluation of expression in the
 dynamic environment from which <code>$lazy</code> was called.
@@ -114,12 +114,21 @@ evaluation will take place the first time each of them is forced.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>memoize</b> (<var>memoize object</var>)<var><a name="index-memoize-145"></a></var><br>
+&mdash; Applicative: <b>memoize</b> (<var>memoize object</var>)<var><a name="index-memoize-159"></a></var><br>
 <blockquote><p>  Applicative <code>memoize</code> constructs and returns a new object of
 type promise, representing memoization of <code>object</code>.  Whenever the
 promise is forced, it determines <code>object</code>. 
 </p></blockquote></div>
 
+<div class="defun">
+&mdash; Operative: <b>$delay</b> (<var>$delay &lt;expression&gt;</var>)<var><a name="index-g_t_0024delay-160"></a></var><br>
+<blockquote><p>Operative <code>delay</code> behaves as the composition of <code>$lazy</code> and
+<code>memoize</code>, that is:
+     <pre class="example">          ($delay &lt;expr&gt;) == ($lazy (memoize &lt;expr&gt;))
+</pre>
+        <p>SOURCE NOTE: this is taken from r7rs. 
+</p></blockquote></div>
+
 <!-- *-texinfo-*- -->
    </body></html>
 
diff --git a/doc/html/Strings.html b/doc/html/Strings.html
@@ -34,18 +34,28 @@ Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
 <!-- node-name,  next,  previous,  up -->
 <h2 class="chapter">15 Strings</h2>
 
-<p><a name="index-strings-213"></a>
+<p><a name="index-strings-232"></a>
   A string is an object that represent a sequence of characters (for
 now, only ASCII is supported in klisp, in the future, full UNICODE
 will be supported).  The external representation of strings consists
 of a leading &ldquo;"&rdquo;, the characters of the string and a closing &ldquo;"&rdquo;. 
-Some characters should be escaped, by preceding them with a &ldquo;\&rdquo;: in
-klisp these are the double quote (&ldquo;"&rdquo;) and the backslash (&ldquo;\&rdquo;). 
-In the future more advanced escape mechanism may be added (like in
-r7rs-draft scheme, for escping common ASCII control codes and
-arbitrary unicode characters).  A string has a length that is fixed at
-creation time, and as many characters, indexed from <code>0</code> to
-<code>length-1</code>.
+Both double quote and backslash should be escaped to appear withing
+strings.  Some other characters also have an escaped form for
+convenience.  All of these are written with a leading slash (&ldquo;\&rdquo;). 
+In klisp these are: double quote (&ldquo;\"&rdquo;), backslash (&ldquo;\\&rdquo;), null
+(&ldquo;\0&rdquo;), alarm (&ldquo;\a&rdquo;), backspace (&ldquo;\b&rdquo;), tab (&ldquo;\t&rdquo;), newline
+(&ldquo;\n&rdquo;), return (&ldquo;\r&rdquo;), vertical tab (&ldquo;\v&rdquo;), and formfeed
+(&ldquo;\f&rdquo;).  You can also use inline hex escapes to include arbitary
+unicode codepoints (only ASCII range supported for now).  The syntax
+is &ldquo;\x&lt;hex codepoint&gt;;&rdquo;.  New lines can be escaped to simplify the
+accomodation of literal strings in source code, to do this: use &ldquo;\&rdquo;
+followed by any ammount of intraline whitespace, a new line and
+another ammount of intraline whitespace.  All of that intraline
+whitespace and the newline, together with the leading slash is
+discarded by the reader and doesn't end up in the string being read.
+
+   <p>A string has a length that is fixed at creation time, and as many
+characters, indexed from <code>0</code> to <code>length-1</code>.
 
    <p>Strings may be mutable or immutable.  If an attempt is made to
 mutate an immutable string, an error is signaled.  Two immutable
@@ -61,41 +71,52 @@ attempt is made to return a new empty string (like calling
 The string type is encapsulated.
 
    <p>SOURCE NOTE: This section is still missing from the report.  The
-features defined here were taken mostly from r5rs scheme.  It is
+features defined here were taken mostly from r7rs scheme.  It is
 possible that in the future, klisp only admits immutable strings (like
 lua and java), and that operations for contructing strings are moved
 to a new type (like Java's StringBuilder/StringBuffer).  But for now,
-compatibility with r5rs was preferred/simpler.
+compatibility with r7rs was preferred/simpler.
 
 <div class="defun">
-&mdash; Applicative: <b>string?</b> (<var>string? . objects</var>)<var><a name="index-string_003f-214"></a></var><br>
+&mdash; Applicative: <b>string?</b> (<var>string? . objects</var>)<var><a name="index-string_003f-233"></a></var><br>
 <blockquote><p>  The primitive type predicate for type string.  <code>string?</code>
 returns true iff all the objects in <code>objects</code> are of type
 string. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string=?</b> (<var>string=? . strings</var>)<var><a name="index-string_003d_003f-215"></a></var><br>
-&mdash; Applicative: <b>string&lt;?</b> (<var>string&lt;? . strings</var>)<var><a name="index-string_003c_003f-216"></a></var><br>
-&mdash; Applicative: <b>string&lt;=?</b> (<var>string&lt;=? . strings</var>)<var><a name="index-string_003c_003d_003f-217"></a></var><br>
-&mdash; Applicative: <b>string&gt;?</b> (<var>string&gt;? . strings</var>)<var><a name="index-string_003e_003f-218"></a></var><br>
-&mdash; Applicative: <b>string&gt;=?</b> (<var>string&gt;=? . strings</var>)<var><a name="index-string_003e_003d_003f-219"></a></var><br>
+&mdash; Applicative: <b>immutable-string?</b> (<var>immutable-string? objects</var>)<var><a name="index-immutable_002dstring_003f-234"></a></var><br>
+&mdash; Applicative: <b>mutable-string?</b> (<var>mutable-string? objects</var>)<var><a name="index-mutable_002dstring_003f-235"></a></var><br>
+<blockquote><p>The primitive type predicates for types immutable string and mutable
+string.  These return true iff all the objects in <code>objects</code> are of
+type immutable string or mutable string respectively.
+
+        <p>SOURCE NOTE: these aren't provided in the Kernel report, but added for
+convenience.  These can be implemented in standard kernel by using guards. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>string=?</b> (<var>string=? . strings</var>)<var><a name="index-string_003d_003f-236"></a></var><br>
+&mdash; Applicative: <b>string&lt;?</b> (<var>string&lt;? . strings</var>)<var><a name="index-string_003c_003f-237"></a></var><br>
+&mdash; Applicative: <b>string&lt;=?</b> (<var>string&lt;=? . strings</var>)<var><a name="index-string_003c_003d_003f-238"></a></var><br>
+&mdash; Applicative: <b>string&gt;?</b> (<var>string&gt;? . strings</var>)<var><a name="index-string_003e_003f-239"></a></var><br>
+&mdash; Applicative: <b>string&gt;=?</b> (<var>string&gt;=? . strings</var>)<var><a name="index-string_003e_003d_003f-240"></a></var><br>
 <blockquote><p>  These predicates compare any number of strings by their
 lexicographic order. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-ci=?</b> (<var>string-ci=? . strings</var>)<var><a name="index-string_002dci_003d_003f-220"></a></var><br>
-&mdash; Applicative: <b>string-ci&lt;?</b> (<var>string-ci&lt;? . strings</var>)<var><a name="index-string_002dci_003c_003f-221"></a></var><br>
-&mdash; Applicative: <b>string-ci&lt;=?</b> (<var>string-ci&lt;=? . strings</var>)<var><a name="index-string_002dci_003c_003d_003f-222"></a></var><br>
-&mdash; Applicative: <b>string-ci&gt;?</b> (<var>string-ci&gt;? . strings</var>)<var><a name="index-string_002dci_003e_003f-223"></a></var><br>
-&mdash; Applicative: <b>string-ci&gt;=?</b> (<var>string-ci&gt;=? . strings</var>)<var><a name="index-string_002dci_003e_003d_003f-224"></a></var><br>
+&mdash; Applicative: <b>string-ci=?</b> (<var>string-ci=? . strings</var>)<var><a name="index-string_002dci_003d_003f-241"></a></var><br>
+&mdash; Applicative: <b>string-ci&lt;?</b> (<var>string-ci&lt;? . strings</var>)<var><a name="index-string_002dci_003c_003f-242"></a></var><br>
+&mdash; Applicative: <b>string-ci&lt;=?</b> (<var>string-ci&lt;=? . strings</var>)<var><a name="index-string_002dci_003c_003d_003f-243"></a></var><br>
+&mdash; Applicative: <b>string-ci&gt;?</b> (<var>string-ci&gt;? . strings</var>)<var><a name="index-string_002dci_003e_003f-244"></a></var><br>
+&mdash; Applicative: <b>string-ci&gt;=?</b> (<var>string-ci&gt;=? . strings</var>)<var><a name="index-string_002dci_003e_003d_003f-245"></a></var><br>
 <blockquote><p>  These predicates convert the strings to lowercase and then compare
 them using their lexicographic order. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>make-string</b> (<var>make-string k </var>[<var>char</var>])<var><a name="index-make_002dstring-225"></a></var><br>
+&mdash; Applicative: <b>make-string</b> (<var>make-string k </var>[<var>char</var>])<var><a name="index-make_002dstring-246"></a></var><br>
 <blockquote><p>  Applicative <code>make-string</code> constructs and returns a new mutable
 string of length <code>k</code>.  If <code>char</code> is specified, then all
 characters in the returned string are <code>char</code>, otherwise the
@@ -103,19 +124,19 @@ content of the string is unspecified.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string</b> (<var>string . chars</var>)<var><a name="index-string-226"></a></var><br>
+&mdash; Applicative: <b>string</b> (<var>string . chars</var>)<var><a name="index-string-247"></a></var><br>
 <blockquote><p>  Applicative <code>string</code> contructs and return a new mutable string
 composed of the character arguments. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-length</b> (<var>string-length string</var>)<var><a name="index-string_002dlength-227"></a></var><br>
+&mdash; Applicative: <b>string-length</b> (<var>string-length string</var>)<var><a name="index-string_002dlength-248"></a></var><br>
 <blockquote><p>  Applicative <code>string-length</code> returns the length of
 <code>string</code>. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-ref</b> (<var>string-ref string k</var>)<var><a name="index-string_002dref-228"></a></var><br>
+&mdash; Applicative: <b>string-ref</b> (<var>string-ref string k</var>)<var><a name="index-string_002dref-249"></a></var><br>
 <blockquote><p>  Applicative <code>string-ref</code> returns the character of <code>string</code>
 at position <code>k</code>.  If <code>k</code> is out of bounds (i.e. less than
 <code>0</code> or greater or equal than <code>(length string)</code>) an error is
@@ -123,21 +144,21 @@ signaled.
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-set!</b> (<var>string-set! string k char</var>)<var><a name="index-string_002dset_0021-229"></a></var><br>
+&mdash; Applicative: <b>string-set!</b> (<var>string-set! string k char</var>)<var><a name="index-string_002dset_0021-250"></a></var><br>
 <blockquote><p>  Applicative <code>string-set!</code> replaces the character with index
 <code>k</code> in <code>string</code> with character <code>char</code>.  If <code>k</code> is
 out of bounds, or <code>string</code> is immutable, an error is signaled. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-fill!</b> (<var>string-fill! string char</var>)<var><a name="index-string_002dfill_0021-230"></a></var><br>
+&mdash; Applicative: <b>string-fill!</b> (<var>string-fill! string char</var>)<var><a name="index-string_002dfill_0021-251"></a></var><br>
 <blockquote><p>  Applicative <code>string-fill!</code> replaces all the characters in
 <code>string</code> with character <code>char</code>.  If <code>string</code> is an
 immutable string, an error is signaled. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>substring</b> (<var>substring string k1 k2</var>)<var><a name="index-substring-231"></a></var><br>
+&mdash; Applicative: <b>substring</b> (<var>substring string k1 k2</var>)<var><a name="index-substring-252"></a></var><br>
 <blockquote><p>  Both <code>k1</code> &amp; <code>k2</code> should be valid indexes in
 <code>string</code>.  Also it should be the case that <code>k1 &lt;= k2</code>.
 
@@ -148,33 +169,48 @@ index <code>k2</code> (exclusive).
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-append</b> (<var>string-append . strings</var>)<var><a name="index-string_002dappend-232"></a></var><br>
+&mdash; Applicative: <b>string-append</b> (<var>string-append . strings</var>)<var><a name="index-string_002dappend-253"></a></var><br>
 <blockquote><p>  Applicative <code>string-append</code> constructs and returns a new
 mutable string consisting of the concatenation of all its arguments. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-copy</b> (<var>string-copy string</var>)<var><a name="index-string_002dcopy-233"></a></var><br>
+&mdash; Applicative: <b>string-copy</b> (<var>string-copy string</var>)<var><a name="index-string_002dcopy-254"></a></var><br>
 <blockquote><p>  Applicative <code>string-copy</code> constructs and returns a new mutable
 string with the same length and characters as <code>string</code>. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-&gt;immutable-string</b> (<var>string-&gt;immutable-string string</var>)<var><a name="index-string_002d_003eimmutable_002dstring-234"></a></var><br>
+&mdash; Applicative: <b>string-&gt;immutable-string</b> (<var>string-&gt;immutable-string string</var>)<var><a name="index-string_002d_003eimmutable_002dstring-255"></a></var><br>
 <blockquote><p>  Applicative <code>string-&gt;immutable-string</code> constructs and returns a
 new immutable string with the same length and characters as
 <code>string</code>. 
 </p></blockquote></div>
 
 <div class="defun">
-&mdash; Applicative: <b>string-&gt;list</b> (<var>string-&gt;list string</var>)<var><a name="index-string_002d_003elist-235"></a></var><br>
-&mdash; Applicative: <b>list-&gt;string</b> (<var>list-&gt;string chars</var>)<var><a name="index-list_002d_003estring-236"></a></var><br>
-<blockquote><p>  Applicatives <code>string-&gt;list</code> and <code>list-&gt;string</code> convert
-between strings and list of characters.  The strings returned by
-<code>list-&gt;string</code> are mutable. 
+&mdash; Applicative: <b>string-&gt;list</b> (<var>string-&gt;list string</var>)<var><a name="index-string_002d_003elist-256"></a></var><br>
+&mdash; Applicative: <b>list-&gt;string</b> (<var>list-&gt;string chars</var>)<var><a name="index-list_002d_003estring-257"></a></var><br>
+&mdash; Applicative: <b>string-&gt;vector</b> (<var>string-&gt;vector string</var>)<var><a name="index-string_002d_003evector-258"></a></var><br>
+&mdash; Applicative: <b>vector-&gt;string</b> (<var>vector-&gt;string vchars</var>)<var><a name="index-vector_002d_003estring-259"></a></var><br>
+&mdash; Applicative: <b>string-&gt;bytevector</b> (<var>string-&gt;bytevector string</var>)<var><a name="index-string_002d_003ebytevector-260"></a></var><br>
+&mdash; Applicative: <b>bytevector-&gt;string</b> (<var>bytevector-&gt;string bvchars</var>)<var><a name="index-bytevector_002d_003estring-261"></a></var><br>
+<blockquote><p>These applicatives convert between strings and list of characters,
+vectors of characters, and bytevectors of characters.  The objects
+returned by these applicatives are always mutable. 
+</p></blockquote></div>
+
+<div class="defun">
+&mdash; Applicative: <b>string-upcase</b> (<var>string-upcase string</var>)<var><a name="index-string_002dupcase-262"></a></var><br>
+&mdash; Applicative: <b>string-downcase</b> (<var>string-downcase string</var>)<var><a name="index-string_002ddowncase-263"></a></var><br>
+&mdash; Applicative: <b>string-titlecase</b> (<var>string-titlecase string</var>)<var><a name="index-string_002dtitlecase-264"></a></var><br>
+&mdash; Applicative: <b>string-foldcase</b> (<var>string-foldcase string</var>)<var><a name="index-string_002dfoldcase-265"></a></var><br>
+<blockquote><p>These applicatives perform the respective case folding on the passed
+<code>string</code> and return a new mutable strings as a result.  The
+original <code>string</code> is not modified.  For now in klisp only ASCII
+is implemented, and so <code>string-foldcase</code> is the same as
+<code>string-downcase</code>. 
 </p></blockquote></div>
 
-<!-- TODO add upcase/downcase when added to klisp -->
 <!-- *-texinfo-*- -->
    </body></html>
 
diff --git a/doc/html/Symbols.html b/doc/html/Symbols.html
@@ -40,7 +40,13 @@ representation. Symbols are immutable, and the symbol type is
 encapsulated.  The external representations of symbols are usually
 identifiers.  However, symbols with other external representations may
 <!-- TODO add xref to string->symbol -->
-be created.
+be created.  Symbols whose external representation is enclosed within
+&ldquo;|&rdquo; (that is &ldquo;| ... |&rdquo;) can contain any character supported by
+klisp, &ldquo;|&rdquo; and &ldquo;\&rdquo; can be included by escaping them with a leading
+&ldquo;\&rdquo; (that is &ldquo;\|&rdquo; and &ldquo;\\&rdquo;).  Characters in symbols can also be
+specified with a unicode hex escape by using the syntax &ldquo;\x&lt;hex
+codepoint&gt;;&rdquo;.  This works whether using the &ldquo;| ... |&rdquo; syntax or
+not.
 
 <div class="defun">
 &mdash; Applicative: <b>symbol?</b> (<var>symbol? . objects</var>)<var><a name="index-symbol_003f-24"></a></var><br>
@@ -64,10 +70,9 @@ always the case that:
 </pre>
         <!-- TODO add xrefs for external representation -->
         <p><code>string-&gt;symbol</code> can create symbols whose external
-representation aren't identifiers.  Right now klisp uses an output-only
-representation, but in the near future it will probably include some
-kind of escaping mechanism to allow arbitrary symbols to have readable
-external representations as in R7RS Scheme. 
+representation aren't identifiers.  klisp uses the r7rs external
+representation for such symbols and so all symbols can be written and
+read back. 
 </p></blockquote></div>
 
 <!-- *-texinfo-*- -->
diff --git a/doc/klisp.info b/doc/klisp.info
@@ -534,7 +534,8 @@ boolean type is encapsulated.
      `nil'), the operative returns true.  If an operand evaluates to
      false, no further operand evaluations are performed, and the
      operative returns false.  If `<list>' is acyclic, and the last
-     operand is evaluated, it is evaluated as a tail context.  If
+     operand is evaluated, it is evaluated in a special type of tail
+     context that checks that the passed value is a boolean.  If
      `<list>' is cyclic, an unbounded number of operand evaluations may
      be performed.  If any of the operands evaluates to a non-boolean
      value, an error is signaled (even if it's the last one).
@@ -547,7 +548,8 @@ boolean type is encapsulated.
      `nil'), the operative returns false.  If an operand evaluates to
      true, no further operand evaluations are performed, and the
      operative returns true.  If `<list>' is acyclic, and the last
-     operand is evaluated, it is evaluated as a tail context.  If
+     operand is evaluated, it is evaluated in a special type of tail
+     context that checks that the passed value is a boolean.  If
      `<list>' is cyclic, an unbounded number of operand evaluations may
      be performed.  If any of the operands evaluates to a non-boolean
      value, an error is signaled (even if it's the last one).
@@ -582,7 +584,13 @@ File: klisp.info,  Node: Symbols,  Next: Control,  Prev: Equivalence,  Up: Top
 Two symbols are eq? iff they have the same external representation.
 Symbols are immutable, and the symbol type is encapsulated.  The
 external representations of symbols are usually identifiers.  However,
-symbols with other external representations may be created.
+symbols with other external representations may be created.  Symbols
+whose external representation is enclosed within "|" (that is "| ...
+|") can contain any character supported by klisp, "|" and "\" can be
+included by escaping them with a leading "\" (that is "\|" and "\\").
+Characters in symbols can also be specified with a unicode hex escape
+by using the syntax "\x<hex codepoint>;".  This works whether using the
+"| ... |" syntax or not.
 
  -- Applicative: symbol? (symbol? . objects)
      The primitive type predicate for type symbol.  `symbol?' returns
@@ -599,11 +607,9 @@ symbols with other external representations may be created.
           (eq? <symbol> (string->symbol (symbol->string <symbol>)))
                => #t
        `string->symbol' can create symbols whose external
-     representation aren't identifiers.  Right now klisp uses an
-     output-only representation, but in the near future it will
-     probably include some kind of escaping mechanism to allow
-     arbitrary symbols to have readable external representations as in
-     R7RS Scheme.
+     representation aren't identifiers.  klisp uses the r7rs external
+     representation for such symbols and so all symbols can be written
+     and read back.
 
 
 File: klisp.info,  Node: Control,  Next: Pairs and lists,  Prev: Symbols,  Up: Top
@@ -646,7 +652,7 @@ consists of a single immutable value, having external representation
           ($cond (<test> . <body>) . <clauses>) ==
             ($if <test> ($sequence . <body>) ($cond . <clauses>))
 
- -- Applicative: for-each (for-each . lists)
+ -- Applicative: for-each (for-each applicative . lists)
      `lists' must be a nonempty list of lists; if there are two or
      more, they should all be the same length. If lists is empty, or if
      all of its elements are not lists of the same length, an error is
@@ -657,6 +663,41 @@ consists of a single immutable value, having external representation
      element-wise applications, the results of the applications are
      discarded and the result returned by `for-each' is inert.
 
+ -- Applicative: string-for-each (string-for-each applicative . strings)
+ -- Applicative: vector-for-each (vector-for-each applicative. vectors)
+ -- Applicative: bytevector-for-each (bytevector-for-each applicative .
+          bytevectors)
+     `strings', `vectors', or `bytevectors' should be non-empty lists
+     of the corresponding type and all elements should be of the same
+     length.
+
+     These applicatives behave as `for-each' except that the list of
+     elements passed to `applicative' are the n-th chars, objects, or
+     uint8s of the strings, vectors or bytevectors passed as arguments.
+
+     SOURCE NOTE: These are taken from r7rs.
+
+ -- Operative: $when ($when <test> . <body>)
+ -- Operative: $unless ($unless <test> . <body>)
+     `body' should be a list of expressions.
+
+     These operatives behave as one-armed `$if's with an implicit
+     `$sequence', except that they always discard the last value and
+     the result returned is inert.
+
+     So both `$when', and `$unless' evaluate `<test>' in the dynamic
+     environment.  If the result is non boolean an error is signaled.
+     In `$when' if the result is false and in `$unless' if the result
+     is true, the expressions in `<body>' are not evaluated and an
+     inert value is returned.  Otherwise, the expressions in `<body>'
+     are evaluated sequentially in the dynamic environment.  If
+     `<body>' is a non cyclic list, the last expression in `<body>' is
+     evaluated in a special type of tail context, that, upon receiving
+     a value discards it and returns an inert value instead.  If
+     `<body>' is a cyclic list, element evaluation continues
+     indefinitely, with elements in the cycle being evaluated
+     repeatedly.  SOURCE NOTE: These are taken from r7rs.
+
 
 File: klisp.info,  Node: Pairs and lists,  Next: Environments,  Prev: Control,  Up: Top
 
@@ -691,6 +732,16 @@ output using, modulo whitespace, external representation `(1 2 3)'.
      The primitive type predicate for type null.  `null?' returns true
      iff all the objects in `objects' are of type null.
 
+ -- Applicative: immutable-pair? (immutable-pair? objects)
+ -- Applicative: mutable-pair? (mutable-pair? objects)
+     The primitive type predicates for types immutable pair and mutable
+     pair.  These return true iff all the objects in `objects' are of
+     type immutable pair or mutable pair respectively.
+
+     SOURCE NOTE: these aren't provided in the Kernel report, but added
+     for convenience.  These can be implemented in standard kernel by
+     using guards.
+
  -- Applicative: cons (cons object1 object2)
      A new mutable pair object is constructed and returned, whose car
      and cdr referents are respectively `object1' and `object2'.  No
@@ -779,6 +830,34 @@ output using, modulo whitespace, external representation `(1 2 3)'.
      Arbitrary compositions up to four deep are provided. There are
      twenty-eight of these applicatives in all.
 
+ -- Applicative: make-list (make-list length [fill])
+     `length' shoulde be an exact non-negative integer.
+
+     Applicative `make-list' creates a new mutable acyclic list of
+     length `length', with all pairs having `fill' in their cars.  If
+     no value is provided for `fill', `#inert' is used.
+
+     SOURCE NOTE: this is taken from r7rs.
+
+ -- Applicative: list-copy (list-copy list)
+     Applicative `list-copy' creates a new mutable copy of `list'.
+     That is, the returned list has the same list metrics as `list' and
+     the cars in the returned list are initially `eq?' to the
+     corresponding cars in `list'.
+
+     SOURCE NOTE: this is taken from r7rs.
+
+ -- Applicative: reverse (reverse list)
+     `list' should be an acyclic list.
+
+     Applicative `reverse' makes a mutable copy of list but with the
+     reverse order.  That is, the returned list has the same number of
+     pairs as `list' and the cars in the returned list are initially
+     `eq?' to the corresponding cars in `list' but starting from the
+     end and going backwards.
+
+     SOURCE NOTE: this is taken from r7rs.
+
  -- Applicative: get-list-metrics (get-list-metrics object)
      By definition, an improper list is a data structure whose objects
      are its start together with all objects reachable from the start by
@@ -908,14 +987,18 @@ output using, modulo whitespace, external representation `(1 2 3)'.
      were in the cycle of `list'; if there were no such elements, the
      result is acyclic.
 
- -- Applicative: assoc (assoc object pairs)
+ -- Applicative: assoc (assoc object pairs [eq-pred?])
      Applicative `assoc' returns the first element of `pairs' whose car
-     is `equal?' to `object'.  If there is no such element in `pairs',
-     nil is returned.
+     is `eq-pred?' to `object'.  If there is no such element in
+     `pairs', nil is returned.  If `eq-pred?' is not supplied it
+     defaults to `equal?'.  SOURCE NOTE: the optional eq-pred? argument
+     is from r7rs.
 
- -- Applicative: member? (member? object list)
+ -- Applicative: member? (member? object list [eq-pred?])
      Applicative `member?' is a predicate that returns true iff some
-     element of `list' is `equal?' to `object'.
+     element of `list' is `eq-pred?' to `object'.  If `eq-pred?' is not
+     supplied, it defaults to `equal?'.  SOURCE NOTE: the optional
+     eq-pred? argument is from r7rs.
 
  -- Applicative: finite-list? (finite-list? . objects)
      This is the type predicate for type finite-list.  `finite-list?'
@@ -1030,8 +1113,8 @@ external representation `#ignore'.  The ignore type is encapsulated.
      true iff all the objects in `objects' are of type ignore.
 
  -- Applicative: eval (eval expression environment)
-     The `eval' applicative evaluates `expression' as a tail context in
-     `environment', and returns the resulting value.
+     The `eval' applicative evaluates `expression' in `environment', as
+     a tail context, returning the resulting value.
 
  -- Applicative: make-environment (make-environment . environments)
      The applicative constructs and returns a new environment, with
@@ -1180,6 +1263,15 @@ external representation `#ignore'.  The ignore type is encapsulated.
           ($bindings->environment . bindings) ==
             ($let-redirect (make-environment) bindings (get-current-environment))
 
+ -- Applicative: eval-string (eval-string string environment)
+     `string' should be the external representation of a single object.
+     If none or more than one external representation is found in
+     `string' then an error is signaled.
+
+     Applicative `eval-string' reads an external representation from
+     string, and evaluates the resulting object in `environment', as a
+     tail context, returning the resulting value.
+
  -- Operative: $set! ($set! <exp1> <formals> <exp2>)
      `<formals>' should be as described for the `$define!' operative.
      The `$set!' operative evaluates `<exp1>' and `<exp2>' in the
@@ -1338,6 +1430,20 @@ combiners are `equal?' iff they are `eq?'.
      common multiple of the `ck'.  In the construction of the result,
      applicative is called exactly `a + c' times.
 
+ -- Applicative: string-map (string-map applicative . strings)
+ -- Applicative: vector-map (vector-map applicative . vectors)
+ -- Applicative: bytevector-map (bytevector-map applicative .
+          bytevectors)
+     `strings', `vectors', or `bytevectors' should be non-empty lists
+     of the corresponding type and all elements should be of the same
+     length.
+
+     These applicatives behave as `map' except that the list of
+     elements passed to `applicative' are the n-th chars, objects, or
+     uint8s of the strings, vectors or bytevectors passed as arguments.
+
+     SOURCE NOTE: These are taken from r7rs.
+
  -- Applicative: combiner? (combiner? . objects)
      The primitive type predicate for type combiner. `combiner?'
      returns true iff all the objects in `objects' are of type combiner
@@ -1629,6 +1735,12 @@ may not be `eq?'.  Two promises are `equal?' iff they are `eq?'.
      promise, representing memoization of `object'.  Whenever the
      promise is forced, it determines `object'.
 
+ -- Operative: $delay ($delay <expression>)
+     Operative `delay' behaves as the composition of `$lazy' and
+     `memoize', that is:
+          ($delay <expr>) == ($lazy (memoize <expr>))
+     SOURCE NOTE: this is taken from r7rs.
+
 
 File: klisp.info,  Node: Keyed Variables,  Next: Numbers,  Prev: Promises,  Up: Top
 
@@ -1755,6 +1867,21 @@ floating point.  No bounding or robustness info is kept.
      `integer?'  returns true iff all the objects in `objects' are of
      type integer.
 
+ -- Applicative: exact-integer? (exact-integer? . objects)
+     The primitive type predicate for number subtype exact integer.
+     `exact-integer?'  returns true iff all the objects in `objects'
+     are of type integer and exact.
+
+     SOURCE NOTE: this is from r7rs.
+
+ -- Applicative: u8? (u8? . objects)
+     The primitive type predicate for number subtype exact integer
+     between 0 and 255.  This is the subtype used in bytevectors.  `u8?'
+     returns true iff all the objects in `objects' are of type integer,
+     are exact, and lie between 0 and 255 inclusive.
+
+     SOURCE NOTE: this is handy for use with bytevectors.
+
  -- Applicative: rational? (rational? . objects)
      The primitive type predicate for number subtype rational.
      `rational?'  returns true iff all the objects in `objects' are of
@@ -2064,23 +2191,73 @@ floating point.  No bounding or robustness info is kept.
      but the result is an approximation of `x0', which is so bounded,
      and the bounds of the result include `x0'.
 
+ -- Applicative: sqrt (sqrt number)
+     If `number' is negative, the result is undefined.
+
+     Applicative `sqrt' returns the positive square root of number.
+     The result may be inexact even if `number' is exact and the square
+     root is rational.
+
+ -- Applicative: expt (expt number1 number2)
+     Applicative `expt' returns `number1' to the power of `number2'.
+     If `number1' is zero, then the result is 1 if `number2' is zero
+     and 0 otherwise.
+
  -- Applicative: exp (exp number)
  -- Applicative: log (log number)
-     TODO
-
  -- Applicative: sin (sin number)
  -- Applicative: cos (cos number)
  -- Applicative: tan (tan number)
-     TODO
-
  -- Applicative: asin (asin number)
  -- Applicative: acos (acos number)
  -- Applicative: atan (atan number1 [number2])
-     TODO
+     These applicatives compute the usual transcendental functions.
+     `log' computes the natural logarithm (not the base-10 logarithm).
+     The two argument version of `atan' computes `(angle
+     (make-recutangular number1 number2))' even thou klisp doesn't
+     support complex numbers.
+
+     All results may be inexact even if `number' is exact and the
+     result of the transcendental function is rational.  TODO add
+     intervals returned for multidefined functions (inverses and log)
+
+ -- Applicative: string->number (string->number string [radix])
+     `radix' should be an exact integer, either 2, 8, 10, or 16.
+     `string' should be a string describing a number in the specified
+     radix, but may contain a radix prefix to override it.  The default
+     `radix', if not supplied, is 10.
+
+     Applicative `string->number' returns the best approximation of the
+     number represented by `string'.  If `string' is not a valid
+     representation of a number in the given `radix' an error is
+     signaled.
 
- -- Applicative: sqrt (sqrt number)
- -- Applicative: expt (expt number1 number2)
-     TODO
+     Examples:
+          (string->number "100") => 100
+          (string->number "100" 16) => 256
+          (string->number "#o100" 2) => 64
+          (string->number "1.0") => 1.0
+
+     SOURCE NOTE: this is taken from r7rs.
+
+ -- Applicative: number->string (number->string number [radix])
+     `radix' should be an exact integer, either 2, 8, 10, or 16.  The
+     default `radix', if not supplied, is 10.
+
+     Applicative `number->string' returns a string representing
+     `number' in the given `radix'.  No radix prefix is present in the
+     returned string.  If an inexact number is passed together with a
+     radix other from 10, an error is signaled.
+
+     The returned string is such that
+          (string->number (number->string number radix) radix) == number
+
+     Examples:
+          (number->string 100) => "100"
+          (number->string 256 16) => "100"
+          (number->string 1.0) => "1.0"
+
+     SOURCE NOTE: this is taken from r7rs.
 
 
 File: klisp.info,  Node: Strings,  Next: Characters,  Prev: Numbers,  Up: Top
@@ -2091,13 +2268,23 @@ File: klisp.info,  Node: Strings,  Next: Characters,  Prev: Numbers,  Up: Top
 A string is an object that represent a sequence of characters (for now,
 only ASCII is supported in klisp, in the future, full UNICODE will be
 supported).  The external representation of strings consists of a
-leading """, the characters of the string and a closing """.  Some
-characters should be escaped, by preceding them with a "\": in klisp
-these are the double quote (""") and the backslash ("\").  In the
-future more advanced escape mechanism may be added (like in r7rs-draft
-scheme, for escping common ASCII control codes and arbitrary unicode
-characters).  A string has a length that is fixed at creation time, and
-as many characters, indexed from `0' to `length-1'.
+leading """, the characters of the string and a closing """.  Both
+double quote and backslash should be escaped to appear withing strings.
+Some other characters also have an escaped form for convenience.  All
+of these are written with a leading slash ("\").  In klisp these are:
+double quote ("\""), backslash ("\\"), null ("\0"), alarm ("\a"),
+backspace ("\b"), tab ("\t"), newline ("\n"), return ("\r"), vertical
+tab ("\v"), and formfeed ("\f").  You can also use inline hex escapes
+to include arbitary unicode codepoints (only ASCII range supported for
+now).  The syntax is "\x<hex codepoint>;".  New lines can be escaped to
+simplify the accomodation of literal strings in source code, to do
+this: use "\" followed by any ammount of intraline whitespace, a new
+line and another ammount of intraline whitespace.  All of that intraline
+whitespace and the newline, together with the leading slash is
+discarded by the reader and doesn't end up in the string being read.
+
+   A string has a length that is fixed at creation time, and as many
+characters, indexed from `0' to `length-1'.
 
    Strings may be mutable or immutable.  If an attempt is made to
 mutate an immutable string, an error is signaled.  Two immutable
@@ -2112,16 +2299,27 @@ string (like calling `(string)', the canonical immutable empty string
 is returned.  The string type is encapsulated.
 
    SOURCE NOTE: This section is still missing from the report.  The
-features defined here were taken mostly from r5rs scheme.  It is
+features defined here were taken mostly from r7rs scheme.  It is
 possible that in the future, klisp only admits immutable strings (like
 lua and java), and that operations for contructing strings are moved to
 a new type (like Java's StringBuilder/StringBuffer).  But for now,
-compatibility with r5rs was preferred/simpler.
+compatibility with r7rs was preferred/simpler.
 
  -- Applicative: string? (string? . objects)
      The primitive type predicate for type string.  `string?' returns
      true iff all the objects in `objects' are of type string.
 
+ -- Applicative: immutable-string? (immutable-string? objects)
+ -- Applicative: mutable-string? (mutable-string? objects)
+     The primitive type predicates for types immutable string and
+     mutable string.  These return true iff all the objects in
+     `objects' are of type immutable string or mutable string
+     respectively.
+
+     SOURCE NOTE: these aren't provided in the Kernel report, but added
+     for convenience.  These can be implemented in standard kernel by
+     using guards.
+
  -- Applicative: string=? (string=? . strings)
  -- Applicative: string<? (string<? . strings)
  -- Applicative: string<=? (string<=? . strings)
@@ -2191,9 +2389,23 @@ compatibility with r5rs was preferred/simpler.
 
  -- Applicative: string->list (string->list string)
  -- Applicative: list->string (list->string chars)
-     Applicatives `string->list' and `list->string' convert between
-     strings and list of characters.  The strings returned by
-     `list->string' are mutable.
+ -- Applicative: string->vector (string->vector string)
+ -- Applicative: vector->string (vector->string vchars)
+ -- Applicative: string->bytevector (string->bytevector string)
+ -- Applicative: bytevector->string (bytevector->string bvchars)
+     These applicatives convert between strings and list of characters,
+     vectors of characters, and bytevectors of characters.  The objects
+     returned by these applicatives are always mutable.
+
+ -- Applicative: string-upcase (string-upcase string)
+ -- Applicative: string-downcase (string-downcase string)
+ -- Applicative: string-titlecase (string-titlecase string)
+ -- Applicative: string-foldcase (string-foldcase string)
+     These applicatives perform the respective case folding on the
+     passed `string' and return a new mutable strings as a result.  The
+     original `string' is not modified.  For now in klisp only ASCII is
+     implemented, and so `string-foldcase' is the same as
+     `string-downcase'.
 
 
 File: klisp.info,  Node: Characters,  Next: Ports,  Prev: Strings,  Up: Top
@@ -2203,13 +2415,19 @@ File: klisp.info,  Node: Characters,  Next: Ports,  Prev: Strings,  Up: Top
 
 A character is an object that represents an ASCII character (for now,
 only ASCII is supported in klisp, in the future, full UNICODE will be
-supported).  The external representation of characters consists of a
-leading "#\" and the character or character name.  The only supported
-names for now are "newline" and "space" (both from r5rs scheme).
-Characters are immutable.  The character type is encapsulated.
+supported).
+
+   The external representation of characters consists of a leading "#\"
+and the character or character name or "#\x" followed by the hex
+unicode code point (only ASCII supported for now).  The supported names
+for now are "null", "alarm", "backspace", "tab", "newline", "return",
+"escape", "space", "delete", "vtab", and "formfeed" (this is a
+combination of the ones accepted in r6rs and r7rs).
+
+   Characters are immutable.  The character type is encapsulated.
 
    SOURCE NOTE: This section is still missing from the report.  The
-features defined here were taken mostly from r5rs scheme.
+features defined here were taken mostly from r7rs.
 
  -- Applicative: char? (char? . objects)
      The primitive type predicate for type character.  `char?' returns
@@ -2284,7 +2502,7 @@ output only external representation (so that it can never be the normal
 result of a call to read).  The eof type is encapsulated.
 
    SOURCE NOTE:  the eof type is not in the Kernel report, it is used in
-klisp and was taken from Scheme.
+klisp and was taken from r7rs.
 
  -- Applicative: port? (port? . objects)
      The primitive type predicate for type port.  `port?' returns true
@@ -2310,7 +2528,22 @@ klisp and was taken from Scheme.
      Every port must be admitted by at least one of these two
      predicates.
 
-     SOURCE NOTE: this is missing from Kernel, it is taken from Scheme.
+     SOURCE NOTE: this is missing from Kernel, it is taken from r7rs.
+
+ -- Applicative: file-port? (file-port? . objects)
+ -- Applicative: string-port? (string-port? . objects)
+ -- Applicative: bytevector-port? (bytevector-port? . objects)
+     These applictives are predicates that returns true unless one or
+     more of its arguments is not file, string or bytevector port,
+     repectively.
+
+     Every port in klisp is be admitted by exactly one of these
+     predicates.
+
+     SOURCE NOTE: this is missing from Kernel.
+
+ -- Applicative: port-open? (port-open? port)
+     Applicative `port-open?' returns true iff `port' is still open.
 
  -- Applicative: with-input-from-file (with-input-from-file string
           combiner)
@@ -2350,7 +2583,7 @@ klisp and was taken from Scheme.
      exists, or there's a permissions problem), an error is signaled.
 
      SOURCE NOTE: open-input-file is enumerated in the Kernel report but
-     the text is still missing. open-binary-input-file is from Scheme.
+     the text is still missing. open-binary-input-file is from r7rs.
 
  -- Applicative: open-output-file (open-output-file string)
  -- Applicative: open-binary-output-file (open-binary-output-file
@@ -2371,7 +2604,24 @@ klisp and was taken from Scheme.
 
      SOURCE NOTE: open-output-file is enumerated in the Kernel report
      but the text is still missing. open-binary-output-file is from
-     Scheme.
+     r7rs.
+
+ -- Applicative: open-input-string (open-output-string string)
+ -- Applicative: open-input-bytevector (open-output-bytevector
+          bytevector)
+     These applicative return a fresh input port that reads characters
+     or unsigned bytes from the passed sequence.
+
+     SOURCE NOTE: These are taken from r7rs.
+
+ -- Applicative: open-output-string (open-output-string)
+ -- Applicative: open-output-bytevector (open-output-bytevector)
+     These applicative return a fresh output port that accumulates
+     characters or unsigned bytes.  The accumulated data can be obtained
+     via applicatives `get-ouput-string' and `get-output-bytevector',
+     respectively.
+
+     SOURCE NOTE: This are taken from r7rs.
 
  -- Applicative: close-input-file (close-input-file input-port)
  -- Applicative: close-output-file (close-output-file output-port)
@@ -2399,10 +2649,9 @@ klisp and was taken from Scheme.
      The result returned by applicatives `close-input-port',
      `close-output-port', and `close-port' is inert.
 
-     SOURCE NOTE: this is from Scheme. The equivalent
-     `close-input-file' and `close-output-file' are probably name
-     errors and only retained here till the draft standard rectifies
-     them
+     SOURCE NOTE: this is from r7rs. The equivalent `close-input-file'
+     and `close-output-file' are probably name errors and only retained
+     here till the draft standard rectifies them
 
  -- Applicative: read (read [textual-input-port])
      If the `port' optional argument is not specified, then the value
@@ -2432,6 +2681,10 @@ klisp and was taken from Scheme.
      SOURCE NOTE: this is enumerated in the Kernel report but the text
      is still missing.
 
+ -- Applicative: write-simple (write-simple object [port])
+     Applicative `write-simple' is like `write' except that it doesn't
+     write sharing info. It will hang if handed a cyclic structure.
+
  -- Applicative: call-with-input-file (call-with-input-file string
           combiner)
  -- Applicative: call-with-output-file (call-with-output-file string
@@ -2458,6 +2711,11 @@ klisp and was taken from Scheme.
      return `#inert' (as is the case with klisp currently) or rather
      return the value of the last evaluation.
 
+ -- Applicative: require
+     TODO
+
+   TODO
+
  -- Applicative: get-module (get-module string [environment])
      Applicative `get-module' creates a fresh standard environment;
      opens the file named `string' for textual input; reads objects
@@ -2657,8 +2915,9 @@ Index
 * $binds?:                               Environments.        (line 108)
 * $cond:                                 Control.             (line  32)
 * $define!:                              Environments.        (line  49)
+* $delay:                                Promises.            (line  79)
 * $if:                                   Control.             (line  15)
-* $import!:                              Environments.        (line 208)
+* $import!:                              Environments.        (line 217)
 * $lambda:                               Combiners.           (line  76)
 * $lazy:                                 Promises.            (line  43)
 * $let:                                  Environments.        (line  89)
@@ -2668,219 +2927,239 @@ Index
 * $let/cc:                               Continuations.       (line 143)
 * $letrec:                               Environments.        (line 137)
 * $letrec*:                              Environments.        (line 144)
-* $or?:                                  Booleans.            (line  41)
-* $provide!:                             Environments.        (line 192)
+* $or?:                                  Booleans.            (line  42)
+* $provide!:                             Environments.        (line 201)
 * $remote-eval:                          Environments.        (line 169)
 * $sequence:                             Control.             (line  23)
-* $set!:                                 Environments.        (line 183)
+* $set!:                                 Environments.        (line 192)
+* $unless:                               Control.             (line  68)
 * $vau:                                  Combiners.           (line  26)
-* *:                                     Numbers.             (line 121)
-* +:                                     Numbers.             (line 109)
-* -:                                     Numbers.             (line 137)
-* /:                                     Numbers.             (line 306)
-* <=?:                                   Numbers.             (line 101)
-* <?:                                    Numbers.             (line 100)
-* =?:                                    Numbers.             (line  95)
-* >=?:                                   Numbers.             (line 103)
-* >?:                                    Numbers.             (line 102)
-* abs:                                   Numbers.             (line 193)
-* acos:                                  Numbers.             (line 385)
+* $when:                                 Control.             (line  67)
+* *:                                     Numbers.             (line 136)
+* +:                                     Numbers.             (line 124)
+* -:                                     Numbers.             (line 152)
+* /:                                     Numbers.             (line 321)
+* <=?:                                   Numbers.             (line 116)
+* <?:                                    Numbers.             (line 115)
+* =?:                                    Numbers.             (line 110)
+* >=?:                                   Numbers.             (line 118)
+* >?:                                    Numbers.             (line 117)
+* abs:                                   Numbers.             (line 208)
+* acos:                                  Numbers.             (line 408)
 * and?:                                  Booleans.            (line  20)
-* append:                                Pairs and lists.     (line 208)
-* append!:                               Pairs and lists.     (line 306)
+* append:                                Pairs and lists.     (line 246)
+* append!:                               Pairs and lists.     (line 348)
 * applicative descriptions:              A Sample Applicative Description.
                                                               (line   6)
 * applicative?:                          Combiners.           (line  21)
 * applicatives:                          Combiners.           (line   6)
 * apply:                                 Combiners.           (line  83)
 * apply-continuation:                    Continuations.       (line 134)
-* asin:                                  Numbers.             (line 384)
-* assoc:                                 Pairs and lists.     (line 252)
-* assq:                                  Pairs and lists.     (line 333)
-* atan:                                  Numbers.             (line 386)
+* asin:                                  Numbers.             (line 407)
+* assoc:                                 Pairs and lists.     (line 290)
+* assq:                                  Pairs and lists.     (line 375)
+* atan:                                  Numbers.             (line 409)
 * binary-port?:                          Ports.               (line  43)
 * boolean?:                              Booleans.            (line  12)
 * booleans:                              Booleans.            (line   6)
-* caaaar:                                Pairs and lists.     (line 101)
-* caaadr:                                Pairs and lists.     (line 102)
-* caaar:                                 Pairs and lists.     (line  93)
-* caadar:                                Pairs and lists.     (line 103)
-* caaddr:                                Pairs and lists.     (line 104)
-* caadr:                                 Pairs and lists.     (line  94)
-* caar:                                  Pairs and lists.     (line  89)
-* cadaar:                                Pairs and lists.     (line 105)
-* cadadr:                                Pairs and lists.     (line 106)
-* cadar:                                 Pairs and lists.     (line  95)
-* caddar:                                Pairs and lists.     (line 107)
-* cadddr:                                Pairs and lists.     (line 108)
-* caddr:                                 Pairs and lists.     (line  96)
-* cadr:                                  Pairs and lists.     (line  90)
-* call-with-input-file:                  Ports.               (line 175)
-* call-with-output-file:                 Ports.               (line 177)
+* bytevector->string:                    Strings.             (line 134)
+* bytevector-for-each:                   Control.             (line  56)
+* bytevector-map:                        Combiners.           (line 123)
+* bytevector-port?:                      Ports.               (line  56)
+* caaaar:                                Pairs and lists.     (line 111)
+* caaadr:                                Pairs and lists.     (line 112)
+* caaar:                                 Pairs and lists.     (line 103)
+* caadar:                                Pairs and lists.     (line 113)
+* caaddr:                                Pairs and lists.     (line 114)
+* caadr:                                 Pairs and lists.     (line 104)
+* caar:                                  Pairs and lists.     (line  99)
+* cadaar:                                Pairs and lists.     (line 115)
+* cadadr:                                Pairs and lists.     (line 116)
+* cadar:                                 Pairs and lists.     (line 105)
+* caddar:                                Pairs and lists.     (line 117)
+* cadddr:                                Pairs and lists.     (line 118)
+* caddr:                                 Pairs and lists.     (line 106)
+* cadr:                                  Pairs and lists.     (line 100)
+* call-with-input-file:                  Ports.               (line 210)
+* call-with-output-file:                 Ports.               (line 212)
 * call/cc:                               Continuations.       (line  43)
-* car:                                   Pairs and lists.     (line  85)
-* cdaaar:                                Pairs and lists.     (line 109)
-* cdaadr:                                Pairs and lists.     (line 110)
-* cdaar:                                 Pairs and lists.     (line  97)
-* cdadar:                                Pairs and lists.     (line 111)
-* cdaddr:                                Pairs and lists.     (line 112)
-* cdadr:                                 Pairs and lists.     (line  98)
-* cdar:                                  Pairs and lists.     (line  91)
-* cddaar:                                Pairs and lists.     (line 113)
-* cddadr:                                Pairs and lists.     (line 114)
-* cddar:                                 Pairs and lists.     (line  99)
-* cdddar:                                Pairs and lists.     (line 115)
-* cddddr:                                Pairs and lists.     (line 116)
-* cdddr:                                 Pairs and lists.     (line 100)
-* cddr:                                  Pairs and lists.     (line  92)
-* cdr:                                   Pairs and lists.     (line  86)
-* ceiling:                               Numbers.             (line 325)
-* char->integer:                         Characters.          (line  58)
-* char-alphabetic?:                      Characters.          (line  37)
-* char-ci<=?:                            Characters.          (line  31)
-* char-ci<?:                             Characters.          (line  30)
-* char-ci=?:                             Characters.          (line  29)
-* char-ci>=?:                            Characters.          (line  33)
-* char-ci>?:                             Characters.          (line  32)
-* char-downcase:                         Characters.          (line  49)
-* char-lower-case?:                      Characters.          (line  44)
-* char-numeric?:                         Characters.          (line  38)
-* char-ready?:                           Ports.               (line 243)
-* char-upcase:                           Characters.          (line  48)
-* char-upper-case?:                      Characters.          (line  43)
-* char-whitespace?:                      Characters.          (line  39)
-* char<=?:                               Characters.          (line  23)
-* char<?:                                Characters.          (line  22)
-* char=?:                                Characters.          (line  21)
-* char>=?:                               Characters.          (line  25)
-* char>?:                                Characters.          (line  24)
-* char?:                                 Characters.          (line  17)
+* car:                                   Pairs and lists.     (line  95)
+* cdaaar:                                Pairs and lists.     (line 119)
+* cdaadr:                                Pairs and lists.     (line 120)
+* cdaar:                                 Pairs and lists.     (line 107)
+* cdadar:                                Pairs and lists.     (line 121)
+* cdaddr:                                Pairs and lists.     (line 122)
+* cdadr:                                 Pairs and lists.     (line 108)
+* cdar:                                  Pairs and lists.     (line 101)
+* cddaar:                                Pairs and lists.     (line 123)
+* cddadr:                                Pairs and lists.     (line 124)
+* cddar:                                 Pairs and lists.     (line 109)
+* cdddar:                                Pairs and lists.     (line 125)
+* cddddr:                                Pairs and lists.     (line 126)
+* cdddr:                                 Pairs and lists.     (line 110)
+* cddr:                                  Pairs and lists.     (line 102)
+* cdr:                                   Pairs and lists.     (line  96)
+* ceiling:                               Numbers.             (line 340)
+* char->integer:                         Characters.          (line  64)
+* char-alphabetic?:                      Characters.          (line  43)
+* char-ci<=?:                            Characters.          (line  37)
+* char-ci<?:                             Characters.          (line  36)
+* char-ci=?:                             Characters.          (line  35)
+* char-ci>=?:                            Characters.          (line  39)
+* char-ci>?:                             Characters.          (line  38)
+* char-downcase:                         Characters.          (line  55)
+* char-lower-case?:                      Characters.          (line  50)
+* char-numeric?:                         Characters.          (line  44)
+* char-ready?:                           Ports.               (line 283)
+* char-upcase:                           Characters.          (line  54)
+* char-upper-case?:                      Characters.          (line  49)
+* char-whitespace?:                      Characters.          (line  45)
+* char<=?:                               Characters.          (line  29)
+* char<?:                                Characters.          (line  28)
+* char=?:                                Characters.          (line  27)
+* char>=?:                               Characters.          (line  31)
+* char>?:                                Characters.          (line  30)
+* char?:                                 Characters.          (line  23)
 * characters:                            Characters.          (line   6)
-* close-input-file:                      Ports.               (line 115)
-* close-input-port:                      Ports.               (line 129)
-* close-output-file:                     Ports.               (line 116)
-* close-output-port:                     Ports.               (line 130)
-* close-port:                            Ports.               (line 131)
-* combiner?:                             Combiners.           (line 120)
+* close-input-file:                      Ports.               (line 147)
+* close-input-port:                      Ports.               (line 161)
+* close-output-file:                     Ports.               (line 148)
+* close-output-port:                     Ports.               (line 162)
+* close-port:                            Ports.               (line 163)
+* combiner?:                             Combiners.           (line 134)
 * combiners:                             Combiners.           (line   6)
-* cons:                                  Pairs and lists.     (line  35)
+* cons:                                  Pairs and lists.     (line  45)
 * continuation->applicative:             Continuations.       (line  95)
 * continuation?:                         Continuations.       (line  38)
 * continuations:                         Continuations.       (line   6)
 * control:                               Control.             (line   6)
-* copy-es:                               Pairs and lists.     (line 321)
-* copy-es-immutable!:                    Pairs and lists.     (line  49)
-* cos:                                   Numbers.             (line 380)
-* countable-list?:                       Pairs and lists.     (line 265)
-* delete-file:                           Ports.               (line 363)
-* denominator:                           Numbers.             (line 315)
+* copy-es:                               Pairs and lists.     (line 363)
+* copy-es-immutable!:                    Pairs and lists.     (line  59)
+* cos:                                   Numbers.             (line 405)
+* countable-list?:                       Pairs and lists.     (line 307)
+* delete-file:                           Ports.               (line 403)
+* denominator:                           Numbers.             (line 330)
 * description format:                    Format of Descriptions.
                                                               (line   6)
-* display:                               Ports.               (line 277)
-* div:                                   Numbers.             (line 149)
-* div-and-mod:                           Numbers.             (line 151)
-* div0:                                  Numbers.             (line 163)
-* div0-and-mod0:                         Numbers.             (line 165)
+* display:                               Ports.               (line 317)
+* div:                                   Numbers.             (line 164)
+* div-and-mod:                           Numbers.             (line 166)
+* div0:                                  Numbers.             (line 178)
+* div0-and-mod0:                         Numbers.             (line 180)
 * documentation notation:                Evaluation Notation. (line   6)
 * empty list:                            Pairs and lists.     (line   6)
 * encapsulations:                        Encapsulations.      (line   6)
-* encycle!:                              Pairs and lists.     (line 158)
+* encycle!:                              Pairs and lists.     (line 196)
 * environment?:                          Environments.        (line  23)
 * environments:                          Environments.        (line   6)
-* eof-object?:                           Ports.               (line 210)
+* eof-object?:                           Ports.               (line 250)
 * eq?:                                   Equivalence.         (line  12)
 * equal?:                                Equivalence.         (line  16)
 * equivalence:                           Equivalence.         (line   6)
 * error message notation:                Error Messages.      (line   6)
 * error-continuation:                    Continuations.       (line 110)
 * eval:                                  Environments.        (line  32)
+* eval-string:                           Environments.        (line 183)
 * evaluation notation:                   Evaluation Notation. (line   6)
-* even?:                                 Numbers.             (line 186)
-* exact?:                                Numbers.             (line  79)
+* even?:                                 Numbers.             (line 201)
+* exact-integer?:                        Numbers.             (line  66)
+* exact?:                                Numbers.             (line  94)
 * exit:                                  Continuations.       (line 162)
-* exp:                                   Numbers.             (line 375)
-* expt:                                  Numbers.             (line 390)
+* exp:                                   Numbers.             (line 402)
+* expt:                                  Numbers.             (line 397)
 * extend-continuation:                   Continuations.       (line  50)
-* file-exists?:                          Ports.               (line 354)
-* filter:                                Pairs and lists.     (line 239)
-* finite-list?:                          Pairs and lists.     (line 261)
-* finite?:                               Numbers.             (line  75)
-* floor:                                 Numbers.             (line 324)
-* flush-output-port:                     Ports.               (line 341)
+* file-exists?:                          Ports.               (line 394)
+* file-port?:                            Ports.               (line  54)
+* filter:                                Pairs and lists.     (line 277)
+* finite-list?:                          Pairs and lists.     (line 303)
+* finite?:                               Numbers.             (line  90)
+* floor:                                 Numbers.             (line 339)
+* flush-output-port:                     Ports.               (line 381)
 * fonts:                                 Some Terms.          (line  13)
 * foo:                                   A Sample Applicative Description.
                                                               (line  15)
 * for-each:                              Control.             (line  42)
 * force:                                 Promises.            (line  35)
-* gcd:                                   Numbers.             (line 207)
+* gcd:                                   Numbers.             (line 222)
 * get-current-environment:               Environments.        (line 114)
-* get-current-error-port:                Ports.               (line  73)
-* get-current-input-port:                Ports.               (line  71)
-* get-current-output-port:               Ports.               (line  72)
-* get-list-metrics:                      Pairs and lists.     (line 123)
-* get-module:                            Ports.               (line 200)
-* get-real-exact-bounds:                 Numbers.             (line 233)
-* get-real-exact-primary:                Numbers.             (line 252)
-* get-real-internal-bounds:              Numbers.             (line 232)
-* get-real-internal-primary:             Numbers.             (line 251)
-* get-string-arithmetic:                 Numbers.             (line 299)
+* get-current-error-port:                Ports.               (line  88)
+* get-current-input-port:                Ports.               (line  86)
+* get-current-output-port:               Ports.               (line  87)
+* get-list-metrics:                      Pairs and lists.     (line 161)
+* get-module:                            Ports.               (line 240)
+* get-real-exact-bounds:                 Numbers.             (line 248)
+* get-real-exact-primary:                Numbers.             (line 267)
+* get-real-internal-bounds:              Numbers.             (line 247)
+* get-real-internal-primary:             Numbers.             (line 266)
+* get-string-arithmetic:                 Numbers.             (line 314)
 * guard-continuation:                    Continuations.       (line  63)
 * guard-dynamic-extent:                  Continuations.       (line 156)
 * ignore:                                Environments.        (line   6)
 * ignore?:                               Environments.        (line  28)
+* immutable-pair?:                       Pairs and lists.     (line  35)
+* immutable-string?:                     Strings.             (line  51)
 * inert:                                 Control.             (line   6)
 * inert?:                                Control.             (line  11)
-* inexact?:                              Numbers.             (line  83)
+* inexact?:                              Numbers.             (line  98)
 * input-port?:                           Ports.               (line  32)
-* integer->char:                         Characters.          (line  59)
+* integer->char:                         Characters.          (line  65)
 * integer?:                              Numbers.             (line  61)
 * interpreter:                           Interpreter.         (line   6)
 * Kernel history:                        Kernel History.      (line   6)
 * keyed dynamic variables:               Keyed Variables.     (line  15)
 * keyed static variables:                Keyed Variables.     (line  40)
 * keyed variables:                       Keyed Variables.     (line   6)
-* lcm:                                   Numbers.             (line 206)
-* length:                                Pairs and lists.     (line 191)
-* list:                                  Pairs and lists.     (line  72)
-* list*:                                 Pairs and lists.     (line  78)
-* list->string:                          Strings.             (line 109)
-* list-neighbors:                        Pairs and lists.     (line 228)
-* list-ref:                              Pairs and lists.     (line 198)
-* list-tail:                             Pairs and lists.     (line 147)
+* lcm:                                   Numbers.             (line 221)
+* length:                                Pairs and lists.     (line 229)
+* list:                                  Pairs and lists.     (line  82)
+* list*:                                 Pairs and lists.     (line  88)
+* list->string:                          Strings.             (line 130)
+* list-copy:                             Pairs and lists.     (line 142)
+* list-neighbors:                        Pairs and lists.     (line 266)
+* list-ref:                              Pairs and lists.     (line 236)
+* list-tail:                             Pairs and lists.     (line 185)
 * lists:                                 Pairs and lists.     (line   6)
-* load:                                  Ports.               (line 187)
-* log:                                   Numbers.             (line 376)
+* load:                                  Ports.               (line 222)
+* log:                                   Numbers.             (line 403)
 * make-encapsulation-type:               Encapsulations.      (line  12)
 * make-environment:                      Environments.        (line  36)
-* make-inexact:                          Numbers.             (line 270)
+* make-inexact:                          Numbers.             (line 285)
 * make-kernel-standard-environment:      Environments.        (line 119)
 * make-keyed-dynamic-variable:           Keyed Variables.     (line  21)
 * make-keyed-static-variable:            Keyed Variables.     (line  44)
-* make-string:                           Strings.             (line  57)
+* make-list:                             Pairs and lists.     (line 133)
+* make-string:                           Strings.             (line  78)
 * map <1>:                               Combiners.           (line  96)
-* map:                                   Pairs and lists.     (line 169)
-* max:                                   Numbers.             (line 198)
-* member?:                               Pairs and lists.     (line 257)
+* map:                                   Pairs and lists.     (line 207)
+* max:                                   Numbers.             (line 213)
+* member?:                               Pairs and lists.     (line 297)
 * memoize:                               Promises.            (line  74)
-* memq?:                                 Pairs and lists.     (line 338)
-* min:                                   Numbers.             (line 199)
-* mod:                                   Numbers.             (line 150)
-* mod0:                                  Numbers.             (line 164)
-* negative?:                             Numbers.             (line 178)
-* newline:                               Ports.               (line 267)
+* memq?:                                 Pairs and lists.     (line 380)
+* min:                                   Numbers.             (line 214)
+* mod:                                   Numbers.             (line 165)
+* mod0:                                  Numbers.             (line 179)
+* mutable-pair?:                         Pairs and lists.     (line  36)
+* mutable-string?:                       Strings.             (line  52)
+* negative?:                             Numbers.             (line 193)
+* newline:                               Ports.               (line 307)
 * nil:                                   Pairs and lists.     (line   6)
 * not?:                                  Booleans.            (line  16)
 * null?:                                 Pairs and lists.     (line  31)
+* number->string:                        Numbers.             (line 439)
 * number?:                               Numbers.             (line  57)
 * numbers:                               Numbers.             (line   6)
-* numerator:                             Numbers.             (line 314)
+* numerator:                             Numbers.             (line 329)
 * object descriptions:                   A Sample Applicative Description.
                                                               (line   6)
-* odd?:                                  Numbers.             (line 185)
-* open-binary-input-file:                Ports.               (line  81)
-* open-binary-output-file:               Ports.               (line  96)
-* open-input-file:                       Ports.               (line  80)
-* open-output-file:                      Ports.               (line  94)
+* odd?:                                  Numbers.             (line 200)
+* open-binary-input-file:                Ports.               (line  96)
+* open-binary-output-file:               Ports.               (line 111)
+* open-input-bytevector:                 Ports.               (line 132)
+* open-input-file:                       Ports.               (line  95)
+* open-input-string:                     Ports.               (line 130)
+* open-output-bytevector:                Ports.               (line 139)
+* open-output-file:                      Ports.               (line 109)
+* open-output-string:                    Ports.               (line 138)
 * operative descriptions:                A Sample Applicative Description.
                                                               (line   6)
 * operative?:                            Combiners.           (line  16)
@@ -2889,73 +3168,91 @@ Index
 * output-port?:                          Ports.               (line  33)
 * pair?:                                 Pairs and lists.     (line  27)
 * pairs:                                 Pairs and lists.     (line   6)
-* peek-char:                             Ports.               (line 230)
-* peek-u8:                               Ports.               (line 302)
+* peek-char:                             Ports.               (line 270)
+* peek-u8:                               Ports.               (line 342)
+* port-open?:                            Ports.               (line  66)
 * port?:                                 Ports.               (line  28)
 * ports:                                 Ports.               (line   6)
-* positive?:                             Numbers.             (line 177)
+* positive?:                             Numbers.             (line 192)
 * printing notation:                     Printing Notation.   (line   6)
 * promise?:                              Promises.            (line  31)
 * promises:                              Promises.            (line   6)
-* rational?:                             Numbers.             (line  66)
-* rationalize:                           Numbers.             (line 340)
-* read:                                  Ports.               (line 146)
-* read-char:                             Ports.               (line 219)
-* read-u8:                               Ports.               (line 290)
-* real->exact:                           Numbers.             (line 286)
-* real->inexact:                         Numbers.             (line 285)
-* real?:                                 Numbers.             (line  71)
-* reduce:                                Pairs and lists.     (line 270)
-* rename-file:                           Ports.               (line 373)
-* robust?:                               Numbers.             (line  87)
+* rational?:                             Numbers.             (line  81)
+* rationalize:                           Numbers.             (line 355)
+* read:                                  Ports.               (line 177)
+* read-char:                             Ports.               (line 259)
+* read-u8:                               Ports.               (line 330)
+* real->exact:                           Numbers.             (line 301)
+* real->inexact:                         Numbers.             (line 300)
+* real?:                                 Numbers.             (line  86)
+* reduce:                                Pairs and lists.     (line 312)
+* rename-file:                           Ports.               (line 413)
+* require:                               Ports.               (line 235)
+* reverse:                               Pairs and lists.     (line 150)
+* robust?:                               Numbers.             (line 102)
 * root-continuation:                     Continuations.       (line 104)
-* round:                                 Numbers.             (line 327)
-* set-car!:                              Pairs and lists.     (line  41)
-* set-cdr!:                              Pairs and lists.     (line  42)
-* simplest-rational:                     Numbers.             (line 341)
-* sin:                                   Numbers.             (line 379)
-* sqrt:                                  Numbers.             (line 389)
-* string:                                Strings.             (line  63)
-* string->immutable-string:              Strings.             (line 103)
-* string->list:                          Strings.             (line 108)
-* string->symbol:                        Symbols.             (line  20)
-* string-append:                         Strings.             (line  94)
-* string-ci<=?:                          Strings.             (line  51)
-* string-ci<?:                           Strings.             (line  50)
-* string-ci=?:                           Strings.             (line  49)
-* string-ci>=?:                          Strings.             (line  53)
-* string-ci>?:                           Strings.             (line  52)
-* string-copy:                           Strings.             (line  98)
-* string-fill!:                          Strings.             (line  80)
-* string-length:                         Strings.             (line  67)
-* string-ref:                            Strings.             (line  70)
-* string-set!:                           Strings.             (line  75)
-* string<=?:                             Strings.             (line  43)
-* string<?:                              Strings.             (line  42)
-* string=?:                              Strings.             (line  41)
-* string>=?:                             Strings.             (line  45)
-* string>?:                              Strings.             (line  44)
-* string?:                               Strings.             (line  37)
+* round:                                 Numbers.             (line 342)
+* set-car!:                              Pairs and lists.     (line  51)
+* set-cdr!:                              Pairs and lists.     (line  52)
+* simplest-rational:                     Numbers.             (line 356)
+* sin:                                   Numbers.             (line 404)
+* sqrt:                                  Numbers.             (line 390)
+* string:                                Strings.             (line  84)
+* string->bytevector:                    Strings.             (line 133)
+* string->immutable-string:              Strings.             (line 124)
+* string->list:                          Strings.             (line 129)
+* string->number:                        Numbers.             (line 420)
+* string->symbol:                        Symbols.             (line  26)
+* string->vector:                        Strings.             (line 131)
+* string-append:                         Strings.             (line 115)
+* string-ci<=?:                          Strings.             (line  72)
+* string-ci<?:                           Strings.             (line  71)
+* string-ci=?:                           Strings.             (line  70)
+* string-ci>=?:                          Strings.             (line  74)
+* string-ci>?:                           Strings.             (line  73)
+* string-copy:                           Strings.             (line 119)
+* string-downcase:                       Strings.             (line 140)
+* string-fill!:                          Strings.             (line 101)
+* string-foldcase:                       Strings.             (line 142)
+* string-for-each:                       Control.             (line  53)
+* string-length:                         Strings.             (line  88)
+* string-map:                            Combiners.           (line 120)
+* string-port?:                          Ports.               (line  55)
+* string-ref:                            Strings.             (line  91)
+* string-set!:                           Strings.             (line  96)
+* string-titlecase:                      Strings.             (line 141)
+* string-upcase:                         Strings.             (line 139)
+* string<=?:                             Strings.             (line  64)
+* string<?:                              Strings.             (line  63)
+* string=?:                              Strings.             (line  62)
+* string>=?:                             Strings.             (line  66)
+* string>?:                              Strings.             (line  65)
+* string?:                               Strings.             (line  47)
 * strings:                               Strings.             (line   6)
-* substring:                             Strings.             (line  85)
-* symbol->string:                        Symbols.             (line  16)
-* symbol?:                               Symbols.             (line  12)
+* substring:                             Strings.             (line 106)
+* symbol->string:                        Symbols.             (line  22)
+* symbol?:                               Symbols.             (line  18)
 * symbols:                               Symbols.             (line   6)
-* tan:                                   Numbers.             (line 381)
+* tan:                                   Numbers.             (line 406)
 * textual-port?:                         Ports.               (line  42)
-* truncate:                              Numbers.             (line 326)
-* u8-ready?:                             Ports.               (line 316)
-* undefined?:                            Numbers.             (line  91)
+* truncate:                              Numbers.             (line 341)
+* u8-ready?:                             Ports.               (line 356)
+* u8?:                                   Numbers.             (line  73)
+* undefined?:                            Numbers.             (line 106)
 * unwrap:                                Combiners.           (line  72)
-* with-error-to-file:                    Ports.               (line  58)
-* with-input-from-file:                  Ports.               (line  55)
-* with-output-to-file:                   Ports.               (line  57)
-* with-strict-arithmetic:                Numbers.             (line 298)
+* vector->string:                        Strings.             (line 132)
+* vector-for-each:                       Control.             (line  54)
+* vector-map:                            Combiners.           (line 121)
+* with-error-to-file:                    Ports.               (line  73)
+* with-input-from-file:                  Ports.               (line  70)
+* with-output-to-file:                   Ports.               (line  72)
+* with-strict-arithmetic:                Numbers.             (line 313)
 * wrap:                                  Combiners.           (line  68)
-* write:                                 Ports.               (line 159)
-* write-char:                            Ports.               (line 256)
-* write-u8:                              Ports.               (line 329)
-* zero?:                                 Numbers.             (line 143)
+* write:                                 Ports.               (line 190)
+* write-char:                            Ports.               (line 296)
+* write-simple:                          Ports.               (line 205)
+* write-u8:                              Ports.               (line 369)
+* zero?:                                 Numbers.             (line 158)
 
 
 
@@ -2977,20 +3274,20 @@ Node: Interpreter15709
 Ref: Command Line Options18009
 Ref: Interpreter Exit Status18943
 Node: Booleans20171
-Node: Equivalence22712
-Node: Symbols23505
-Node: Control24871
-Node: Pairs and lists27188
-Node: Environments44211
-Node: Combiners54452
-Node: Continuations60488
-Node: Encapsulations69031
-Node: Promises70484
-Node: Keyed Variables74407
-Node: Numbers77178
-Node: Strings96681
-Node: Characters102028
-Node: Ports104738
-Node: Alphabetical Index122674
+Node: Equivalence22848
+Node: Symbols23641
+Node: Control25271
+Node: Pairs and lists29362
+Node: Environments48242
+Node: Combiners58915
+Node: Continuations65569
+Node: Encapsulations74112
+Node: Promises75565
+Node: Keyed Variables79720
+Node: Numbers82491
+Node: Strings104945
+Node: Characters112206
+Node: Ports115116
+Node: Alphabetical Index134564
 
 End Tag Table
diff --git a/doc/src/booleans.texi b/doc/src/booleans.texi
@@ -41,11 +41,12 @@ end of the list is reached (which is immediate if @code{<list>} is
 @code{nil}), the operative returns true.  If an operand evaluates to
 false, no further operand evaluations are performed, and the operative
 returns false.  If @code{<list>} is acyclic, and the last operand is
-@c TODO cross ref tail-contect
-evaluated, it is evaluated as a tail context.  If @code{<list>} is
-cyclic, an unbounded number of operand evaluations may be
-performed.  If any of the operands evaluates to a non-boolean value, an
-error is signaled (even if it's the last one).
+@c TODO cross ref tail-context
+evaluated, it is evaluated in a special type of tail context that
+checks that the passed value is a boolean.  If @code{<list>} is
+cyclic, an unbounded number of operand evaluations may be performed.
+If any of the operands evaluates to a non-boolean value, an error is
+signaled (even if it's the last one).
 @end deffn
 
 @deffn Operative $or? ($or? . <list>)
@@ -57,9 +58,10 @@ end of the list is reached (which is immediate if @code{<list>} is
 true, no further operand evaluations are performed, and the operative
 returns true.  If @code{<list>} is acyclic, and the last operand is
 @c TODO cross ref tail-context
-evaluated, it is evaluated as a tail context.  If @code{<list>} is
-cyclic, an unbounded number of operand evaluations may be
-performed.  If any of the operands evaluates to a non-boolean value, an
-error is signaled (even if it's the last one).
+evaluated, it is evaluated in a special type of tail context that
+checks that the passed value is a boolean.  If @code{<list>} is
+cyclic, an unbounded number of operand evaluations may be performed.
+If any of the operands evaluates to a non-boolean value, an error is
+signaled (even if it's the last one).
 @end deffn
 
diff --git a/doc/src/characters.texi b/doc/src/characters.texi
@@ -9,14 +9,20 @@
 
   A character is an object that represents an ASCII character (for
 now, only ASCII is supported in klisp, in the future, full UNICODE
-will be supported).  The external representation of characters
-consists of a leading ``#\'' and the character or character name.  The
-only supported names for now are ``newline'' and ``space'' (both from
-r5rs scheme).  Characters are immutable.  The character type is
-encapsulated.
+will be supported).  
+
+The external representation of characters consists of a leading ``#\''
+and the character or character name or ``#\x'' followed by the hex
+unicode code point (only ASCII supported for now).  The supported
+names for now are ``null'', ``alarm'', ``backspace'', ``tab'',
+``newline'', ``return'', ``escape'', ``space'', ``delete'', ``vtab'',
+and ``formfeed'' (this is a combination of the ones accepted in r6rs
+and r7rs).
+
+Characters are immutable.  The character type is encapsulated.
 
   SOURCE NOTE: This section is still missing from the report.  The
-features defined here were taken mostly from r5rs scheme.
+features defined here were taken mostly from r7rs.
 
 @deffn Applicative char? (char? . objects)
   The primitive type predicate for type character.  @code{char?}
diff --git a/doc/src/combiners.texi b/doc/src/combiners.texi
@@ -148,6 +148,20 @@ times.
 @c TODO comp/xref for-each
 @end deffn
 
+@deffn Applicative string-map (string-map applicative . strings)
+@deffnx Applicative vector-map (vector-map applicative . vectors)
+@deffnx Applicative bytevector-map (bytevector-map applicative . bytevectors)
+@code{strings}, @code{vectors}, or @code{bytevectors} should be
+non-empty lists of the corresponding type and all elements should be
+of the same length.
+
+These applicatives behave as @code{map} except that the list of
+elements passed to @code{applicative} are the n-th chars, objects, or
+uint8s of the strings, vectors or bytevectors passed as arguments.
+
+SOURCE NOTE: These are taken from r7rs.
+@end deffn
+
 @deffn Applicative combiner? (combiner? . objects)
   The primitive type predicate for type combiner. @code{combiner?}
 returns true iff all the objects in @code{objects} are of type
diff --git a/doc/src/control.texi b/doc/src/control.texi
@@ -50,7 +50,7 @@ the behaviour of the @code{$cond} operative:
 @end example
 @end deffn
 
-@deffn Applicative for-each (for-each . lists)
+@deffn Applicative for-each (for-each applicative . lists)
 @code{lists} must be a nonempty list of lists; if there are two or
 more, they should all be the same length. If lists is empty, or if all
 of its elements are not lists of the same length, an error is
@@ -62,3 +62,41 @@ of accumulating and returning a list of the results of the
 element-wise applications, the results of the applications are
 discarded and the result returned by @code{for-each} is inert.
 @end deffn
+
+@deffn Applicative string-for-each (string-for-each applicative . strings)
+@deffnx Applicative vector-for-each (vector-for-each applicative. vectors)
+@deffnx Applicative bytevector-for-each (bytevector-for-each applicative . bytevectors)
+@code{strings}, @code{vectors}, or @code{bytevectors} should be
+non-empty lists of the corresponding type and all elements should be
+of the same length.
+
+These applicatives behave as @code{for-each} except that the list of
+elements passed to @code{applicative} are the n-th chars, objects, or
+uint8s of the strings, vectors or bytevectors passed as arguments.
+
+SOURCE NOTE: These are taken from r7rs.
+@end deffn
+
+@deffn Operative $when ($when <test> . <body>)
+@deffnx Operative $unless ($unless <test> . <body>)
+@code{body} should be a list of expressions.
+
+These operatives behave as one-armed @code{$if}s with an implicit
+@code{$sequence}, except that they always discard the last value and
+the result returned is inert.
+
+So both @code{$when}, and @code{$unless} evaluate @code{<test>} in the
+dynamic environment.  If the result is non boolean an error is
+signaled.  In @code{$when} if the result is false and in
+@code{$unless} if the result is true, the expressions in @code{<body>}
+are not evaluated and an inert value is returned.  Otherwise, the
+expressions in @code{<body>} are evaluated sequentially in the dynamic
+environment.  If @code{<body>} is a non cyclic list, the last
+expression in @code{<body>} is evaluated in a special type of tail
+context, that, upon receiving a value discards it and returns an inert
+value instead.  If @code{<body>} is a cyclic list, element evaluation
+continues indefinitely, with elements in the cycle being evaluated
+repeatedly.
+@c TODO xref tail-context
+SOURCE NOTE: These are taken from r7rs.
+@end deffn
diff --git a/doc/src/environments.texi b/doc/src/environments.texi
@@ -41,8 +41,8 @@ returns true iff all the objects in @code{objects} are of type ignore.
 @deffn Applicative eval (eval expression environment)
 @c TODO add xref to tail context
 @c TODO add xref to evaluation description
-  The @code{eval} applicative evaluates @code{expression} as a tail
-context in @code{environment}, and returns the resulting value.
+The @code{eval} applicative evaluates @code{expression} in
+@code{environment}, as a tail context, returning the resulting value.
 @end deffn
 
 @deffn Applicative make-environment (make-environment . environments)
@@ -245,6 +245,17 @@ environment that must result from the first evaluation.
 @end example
 @end deffn
 
+@deffn Applicative eval-string (eval-string string environment)
+@code{string} should be the external representation of a single
+object.  If none or more than one external representation is found in
+@code{string} then an error is signaled.
+
+Applicative @code{eval-string} reads an external representation from
+string, and evaluates the resulting object in @code{environment}, as a
+tail context, returning the resulting value. 
+@c TODO add xref to tail context.
+@end deffn
+
 @deffn Operative $set! ($set! <exp1> <formals> <exp2>)
 @c TODO add xref to $define!
 @c TODO add xref to matching algo
diff --git a/doc/src/equivalence.texi b/doc/src/equivalence.texi
@@ -15,7 +15,7 @@ equivalence in the presence of mutation (@code{eq?}).
 @deffn Applicative eq? (eq? . objects)
   Predicate @code{eq?} returns true iff all of @code{objects} are
 effectively the same object, even in the presence of mutation. 
-@c todo maybe add more content here, specifical to klisp
+@c todo maybe add more content here, specific to klisp
 @end deffn
 
 @deffn Applicative equal? (equal? . objects)
@@ -23,5 +23,5 @@ effectively the same object, even in the presence of mutation.
 ``look'' the same as long as nothing is mutated.  This is a weaker
 predicate than @code{eq?}; that is, @code{equal?} must return true
 whenever @code{eq?} would return true.
-@c todo maybe add more content here, specifical to klisp
+@c todo maybe add more content here, specific to klisp
 @end deffn
diff --git a/doc/src/numbers.texi b/doc/src/numbers.texi
@@ -73,6 +73,23 @@ returns true iff all the objects in @code{objects} are of type number.
 are of type integer.
 @end deffn
 
+@deffn Applicative exact-integer? (exact-integer? . objects)
+  The primitive type predicate for number subtype exact integer.
+@code{exact-integer?}  returns true iff all the objects in
+@code{objects} are of type integer and exact.
+
+SOURCE NOTE: this is from r7rs.
+@end deffn
+
+@deffn Applicative u8? (u8? . objects)
+The primitive type predicate for number subtype exact integer between
+0 and 255.  This is the subtype used in bytevectors.  @code{u8?}
+returns true iff all the objects in @code{objects} are of type
+integer, are exact, and lie between 0 and 255 inclusive.
+
+SOURCE NOTE: this is handy for use with bytevectors.
+@end deffn
+
 @deffn Applicative rational? (rational? . objects)
   The primitive type predicate for number subtype rational.
 @code{rational?}  returns true iff all the objects in @code{objects}
@@ -427,40 +444,81 @@ primary values of the arguments; but the result is an approximation of
 @code{x0}.
 @end deffn
 
-@deffn Applicative exp (exp number)
-@deffnx Applicative log (log number)
-TODO
+@deffn Applicative sqrt (sqrt number)
+If @code{number} is negative, the result is undefined.
+
+Applicative @code{sqrt} returns the positive square root of number.
+The result may be inexact even if @code{number} is exact and the
+square root is rational.
 @end deffn
 
+@deffn Applicative expt (expt number1 number2)
+Applicative @code{expt} returns @code{number1} to the power of
+@code{number2}.  If @code{number1} is zero, then the result is 1 if
+@code{number2} is zero and 0 otherwise.
+@end deffn
 
-@deffn Applicative sin (sin number)
+@deffn Applicative exp (exp number)
+@deffnx Applicative log (log number)
+@deffnx Applicative sin (sin number)
 @deffnx Applicative cos (cos number)
 @deffnx Applicative tan (tan number)
-TODO
-@end deffn
-
-@deffn Applicative asin (asin number)
+@deffnx Applicative asin (asin number)
 @deffnx Applicative acos (acos number)
 @deffnx Applicative atan (atan number1 [number2])
-TODO
+These applicatives compute the usual transcendental functions.
+@code{log} computes the natural logarithm (not the base-10 logarithm).
+The two argument version of @code{atan} computes @code{(angle
+(make-recutangular number1 number2))} even thou klisp doesn't support
+complex numbers.
+
+All results may be inexact even if @code{number} is exact and the
+result of the transcendental function is rational.
+TODO add intervals returned for multidefined functions (inverses and log)
+@end deffn
+
+@deffn Applicative string->number (string->number string [radix])
+@code{radix} should be an exact integer, either 2, 8, 10, or 16.
+@code{string} should be a string describing a number in the specified
+radix, but may contain a radix prefix to override it.  The default
+@code{radix}, if not supplied, is 10.
+
+Applicative @code{string->number} returns the best approximation of
+the number represented by @code{string}.  If @code{string} is not a
+valid representation of a number in the given @code{radix} an error is
+signaled.
+
+Examples:
+@example
+(string->number "100") @result{} 100
+(string->number "100" 16) @result{} 256
+(string->number "#o100" 2) @result{} 64
+(string->number "1.0") @result{} 1.0
+@end example
+
+SOURCE NOTE: this is taken from r7rs.
+@end deffn
+
+@deffn Applicative number->string (number->string number [radix])
+@code{radix} should be an exact integer, either 2, 8, 10, or 16.  The
+default @code{radix}, if not supplied, is 10.
+
+Applicative @code{number->string} returns a string representing
+@code{number} in the given @code{radix}.  No radix prefix is present
+in the returned string.  If an inexact number is passed together with
+a radix other from 10, an error is signaled.
+
+The returned string is such that 
+@example
+(string->number (number->string number radix) radix) @equiv{} number
+@end example
+
+Examples:
+@example
+(number->string 100) @result{} "100"
+(number->string 256 16) @result{} "100"
+(number->string 1.0) @result{} "1.0"
+@end example
+
+SOURCE NOTE: this is taken from r7rs.
 @end deffn
-
-@deffn Applicative sqrt (sqrt number)
-@deffnx Applicative expt (expt number1 number2)
-TODO
-@end deffn
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/doc/src/pairs_lists.texi b/doc/src/pairs_lists.texi
@@ -43,6 +43,16 @@ true iff all the objects in @code{objects} are of type pair.
 true iff all the objects in @code{objects} are of type null.
 @end deffn
 
+@deffn Applicative immutable-pair? (immutable-pair? objects)
+@deffnx Applicative mutable-pair? (mutable-pair? objects)
+The primitive type predicates for types immutable pair and mutable
+pair.  These return true iff all the objects in @code{objects} are of
+type immutable pair or mutable pair respectively.
+
+SOURCE NOTE: these aren't provided in the Kernel report, but added for
+convenience.  These can be implemented in standard kernel by using guards.
+@end deffn
+
 @deffn Applicative cons (cons object1 object2)
   A new mutable pair object is constructed and returned, whose car and
 cdr referents are respectively @code{object1} and @code{object2}.  No
@@ -142,6 +152,37 @@ order.  Arbitrary compositions up to four deep are provided. There are
 twenty-eight of these applicatives in all.
 @end deffn
 
+@deffn Applicative make-list (make-list length [fill])
+  @code{length} shoulde be an exact non-negative integer.
+
+  Applicative @code{make-list} creates a new mutable acyclic list of
+length @code{length}, with all pairs having @code{fill} in their
+cars.  If no value is provided for @code{fill}, @code{#inert} is used.
+
+SOURCE NOTE: this is taken from r7rs.
+@end deffn
+
+@deffn Applicative list-copy (list-copy list)
+Applicative @code{list-copy} creates a new mutable copy of
+@code{list}.  That is, the returned list has the same list metrics as
+@code{list} and the cars in the returned list are initially @code{eq?}
+to the corresponding cars in @code{list}.
+
+SOURCE NOTE: this is taken from r7rs.
+@end deffn
+
+@deffn Applicative reverse (reverse list)
+@code{list} should be an acyclic list.
+
+Applicative @code{reverse} makes a mutable copy of list but with the
+reverse order.  That is, the returned list has the same number of
+pairs as @code{list} and the cars in the returned list are initially
+@code{eq?} to the corresponding cars in @code{list} but starting from
+the end and going backwards.
+
+SOURCE NOTE: this is taken from r7rs.
+@end deffn
+
 @deffn Applicative get-list-metrics (get-list-metrics object)
 @c TODO move definition of improper list to intro, xref data structure
   By definition, an improper list is a data structure whose objects
@@ -298,19 +339,23 @@ that were in the cycle of @code{list}; if there were no such elements,
 the result is acyclic.
 @end deffn
 
-@deffn Applicative assoc (assoc object pairs)
+@deffn Applicative assoc (assoc object pairs [eq-pred?])
   Applicative @code{assoc} returns the first element of @code{pairs}
-whose car is @code{equal?} to @code{object}.  If there is no such
-element in @code{pairs}, nil is returned.
+whose car is @code{eq-pred?} to @code{object}.  If there is no such
+element in @code{pairs}, nil is returned.  If @code{eq-pred?} is not
+supplied it defaults to @code{equal?}.
 @c TODO add xref/comp to assq
 @c TODO add xref to equal?
+SOURCE NOTE: the optional eq-pred? argument is from r7rs.
 @end deffn
 
-@deffn Applicative member? (member? object list)
+@deffn Applicative member? (member? object list [eq-pred?])
   Applicative @code{member?} is a predicate that returns true iff some
-element of @code{list} is @code{equal?} to @code{object}.
+element of @code{list} is @code{eq-pred?} to @code{object}.  If
+@code{eq-pred?} is not supplied, it defaults to @code{equal?}.
 @c TODO add xref/comp to memq
 @c TODO add xref to equal?
+SOURCE NOTE: the optional eq-pred? argument is from r7rs.
 @end deffn
 
 @deffn Applicative finite-list? (finite-list? . objects)
diff --git a/doc/src/ports.texi b/doc/src/ports.texi
@@ -27,7 +27,7 @@ an output only external representation (so that it can never be the
 normal result of a call to read).  The eof type is encapsulated.
 
 SOURCE NOTE:  the eof type is not in the Kernel report, it is used in
-klisp and was taken from Scheme.
+klisp and was taken from r7rs.
 
 @deffn Applicative port? (port? . objects)
   The primitive type predicate for type port.  @code{port?}
@@ -53,7 +53,23 @@ its arguments is not a binary port.
 
   Every port must be admitted by at least one of these two predicates.
 
-  SOURCE NOTE: this is missing from Kernel, it is taken from Scheme.
+  SOURCE NOTE: this is missing from Kernel, it is taken from r7rs.
+@end deffn
+
+@deffn Applicative file-port? (file-port? . objects)
+@deffnx Applicative string-port? (string-port? . objects)
+@deffnx Applicative bytevector-port? (bytevector-port? . objects)
+These applictives are predicates that returns true unless one or more
+of its arguments is not file, string or bytevector port, repectively.
+
+  Every port in klisp is be admitted by exactly one of these predicates.
+
+  SOURCE NOTE: this is missing from Kernel.
+@end deffn
+
+@deffn Applicative port-open? (port-open? port)
+Applicative @code{port-open?} returns true iff @code{port} is still
+open.
 @end deffn
 
 @deffn Applicative with-input-from-file (with-input-from-file string combiner)
@@ -97,7 +113,7 @@ In either case, if the file can't be opened (e.g. because it doesn't
 exists, or there's a permissions problem), an error is signaled.
 
   SOURCE NOTE: open-input-file is enumerated in the Kernel report but
-the text is still missing. open-binary-input-file is from Scheme.
+the text is still missing. open-binary-input-file is from r7rs.
 @end deffn
 
 @deffn Applicative open-output-file (open-output-file string)
@@ -117,7 +133,25 @@ but that could change later (i.e. like in Scheme the behaviour should
 be considered unspecified).
 
   SOURCE NOTE: open-output-file is enumerated in the Kernel report but
-the text is still missing. open-binary-output-file is from Scheme.
+the text is still missing. open-binary-output-file is from r7rs.
+@end deffn
+
+@deffn Applicative open-input-string (open-output-string string)
+@deffnx Applicative open-input-bytevector (open-output-bytevector bytevector)
+These applicative return a fresh input port that reads characters or
+unsigned bytes from the passed sequence.
+
+  SOURCE NOTE: These are taken from r7rs.
+@end deffn
+
+@deffn Applicative open-output-string (open-output-string)
+@deffnx Applicative open-output-bytevector (open-output-bytevector)
+These applicative return a fresh output port that accumulates
+characters or unsigned bytes.  The accumulated data can be obtained
+via applicatives @code{get-ouput-string} and
+@code{get-output-bytevector}, respectively.
+
+  SOURCE NOTE: This are taken from r7rs.
 @end deffn
 
 @deffn Applicative close-input-file (close-input-file input-port)
@@ -147,7 +181,7 @@ be used to selectively close only one direction of the port.
   The result returned by applicatives @code{close-input-port},
 @code{close-output-port}, and @code{close-port} is inert.
 
-  SOURCE NOTE: this is from Scheme. The equivalent
+  SOURCE NOTE: this is from r7rs. The equivalent
 @code{close-input-file} and @code{close-output-file} are probably name
 errors and only retained here till the draft standard rectifies them
 @end deffn
@@ -185,6 +219,11 @@ by @code{write} is inert.
 still missing.
 @end deffn
 
+@deffn Applicative write-simple (write-simple object [port])
+Applicative @code{write-simple} is like @code{write} except that it
+doesn't write sharing info. It will hang if handed a cyclic structure.
+@end deffn
+
 @deffn Applicative call-with-input-file (call-with-input-file string combiner)
 @deffnx Applicative call-with-output-file (call-with-output-file string combiner)
   These applicatives open file named in @code{string} for textual
@@ -212,6 +251,12 @@ return @code{#inert} (as is the case with klisp currently) or rather
 return the value of the last evaluation.
 @end deffn
 
+@deffn Applicative require
+TODO
+@end deffn
+
+TODO
+
 @deffn Applicative get-module (get-module string [environment])
 @c TODO add xref standard-environment, open/input, read
   Applicative @code{get-module} creates a fresh standard environment;
diff --git a/doc/src/promises.texi b/doc/src/promises.texi
@@ -87,3 +87,12 @@ evaluation will take place the first time each of them is forced.
 type promise, representing memoization of @code{object}.  Whenever the
 promise is forced, it determines @code{object}.
 @end deffn
+
+@deffn Operative $delay ($delay <expression>)
+Operative @code{delay} behaves as the composition of @code{$lazy} and
+@code{memoize}, that is:
+@example
+($delay <expr>) @equiv{} ($lazy (memoize <expr>))
+@end example
+SOURCE NOTE: this is taken from r7rs.
+@end deffn
diff --git a/doc/src/strings.texi b/doc/src/strings.texi
@@ -11,15 +11,25 @@
 now, only ASCII is supported in klisp, in the future, full UNICODE
 will be supported).  The external representation of strings consists
 of a leading ``"'', the characters of the string and a closing ``"''.
-Some characters should be escaped, by preceding them with a ``\'': in
-klisp these are the double quote (``"'') and the backslash (``\'').
-In the future more advanced escape mechanism may be added (like in
-r7rs-draft scheme, for escping common ASCII control codes and
-arbitrary unicode characters).  A string has a length that is fixed at
-creation time, and as many characters, indexed from @code{0} to
-@code{length-1}.
-
-  Strings may be mutable or immutable.  If an attempt is made to
+Both double quote and backslash should be escaped to appear withing
+strings.  Some other characters also have an escaped form for
+convenience.  All of these are written with a leading slash (``\'').
+In klisp these are: double quote (``\"''), backslash (``\\''), null
+(``\0''), alarm (``\a''), backspace (``\b''), tab (``\t''), newline
+(``\n''), return (``\r''), vertical tab (``\v''), and formfeed
+(``\f'').  You can also use inline hex escapes to include arbitary
+unicode codepoints (only ASCII range supported for now).  The syntax
+is ``\x<hex codepoint>;''.  New lines can be escaped to simplify the
+accomodation of literal strings in source code, to do this: use ``\''
+followed by any ammount of intraline whitespace, a new line and
+another ammount of intraline whitespace.  All of that intraline
+whitespace and the newline, together with the leading slash is
+discarded by the reader and doesn't end up in the string being read.
+
+A string has a length that is fixed at creation time, and as many
+characters, indexed from @code{0} to @code{length-1}.
+
+Strings may be mutable or immutable.  If an attempt is made to
 mutate an immutable string, an error is signaled.  Two immutable
 strings are ``eq?'' iff they are ``equal?''.  Two mutable strings are
 ``eq?'' if they were created by the same constructor call.  Two
@@ -33,11 +43,11 @@ attempt is made to return a new empty string (like calling
 The string type is encapsulated.
 
 SOURCE NOTE: This section is still missing from the report.  The
-features defined here were taken mostly from r5rs scheme.  It is
+features defined here were taken mostly from r7rs scheme.  It is
 possible that in the future, klisp only admits immutable strings (like
 lua and java), and that operations for contructing strings are moved
 to a new type (like Java's StringBuilder/StringBuffer).  But for now,
-compatibility with r5rs was preferred/simpler.
+compatibility with r7rs was preferred/simpler.
 
 @deffn Applicative string? (string? . objects)
   The primitive type predicate for type string.  @code{string?}
@@ -45,6 +55,16 @@ returns true iff all the objects in @code{objects} are of type
 string.
 @end deffn
 
+@deffn Applicative immutable-string? (immutable-string? objects)
+@deffnx Applicative mutable-string? (mutable-string? objects)
+The primitive type predicates for types immutable string and mutable
+string.  These return true iff all the objects in @code{objects} are of
+type immutable string or mutable string respectively.
+
+SOURCE NOTE: these aren't provided in the Kernel report, but added for
+convenience.  These can be implemented in standard kernel by using guards.
+@end deffn
+
 @deffn Applicative string=? (string=? . strings)
 @deffnx Applicative string<? (string<? . strings)
 @deffnx Applicative string<=? (string<=? . strings)
@@ -127,10 +147,23 @@ new immutable string with the same length and characters as
 
 @deffn Applicative string->list (string->list string)
 @deffnx Applicative list->string (list->string chars)
-  Applicatives @code{string->list} and @code{list->string} convert
-between strings and list of characters.  The strings returned by
-@code{list->string} are mutable.
+@deffnx Applicative string->vector (string->vector string)
+@deffnx Applicative vector->string (vector->string vchars)
+@deffnx Applicative string->bytevector (string->bytevector string)
+@deffnx Applicative bytevector->string (bytevector->string bvchars)
+These applicatives convert between strings and list of characters,
+vectors of characters, and bytevectors of characters.  The objects
+returned by these applicatives are always mutable.
 @end deffn
 
-@c TODO add upcase/downcase when added to klisp
+@deffn Applicative string-upcase (string-upcase string)
+@deffnx Applicative string-downcase (string-downcase string)
+@deffnx Applicative string-titlecase (string-titlecase string)
+@deffnx Applicative string-foldcase (string-foldcase string)
+These applicatives perform the respective case folding on the passed
+@code{string} and return a new mutable strings as a result.  The
+original @code{string} is not modified.  For now in klisp only ASCII
+is implemented, and so @code{string-foldcase} is the same as
+@code{string-downcase}.
+@end deffn
 
diff --git a/doc/src/symbols.texi b/doc/src/symbols.texi
@@ -12,7 +12,13 @@ representation. Symbols are immutable, and the symbol type is
 encapsulated.  The external representations of symbols are usually
 identifiers.  However, symbols with other external representations may
 @c TODO add xref to string->symbol
-be created.
+be created.  Symbols whose external representation is enclosed within
+``|'' (that is ``| ... |'') can contain any character supported by
+klisp, ``|'' and ``\'' can be included by escaping them with a leading
+``\'' (that is ``\|'' and ``\\'').  Characters in symbols can also be
+specified with a unicode hex escape by using the syntax ``\x<hex
+codepoint>;''.  This works whether using the ``| ... |'' syntax or
+not.
 
 @deffn Applicative symbol? (symbol? . objects)
   The primitive type predicate for type symbol.  @code{symbol?}
@@ -34,8 +40,7 @@ always the case that:
 @end example
 @c TODO add xrefs for external representation
   @code{string->symbol} can create symbols whose external
-representation aren't identifiers.  Right now klisp uses an output-only
-representation, but in the near future it will probably include some
-kind of escaping mechanism to allow arbitrary symbols to have readable
-external representations as in R7RS Scheme.
+representation aren't identifiers.  klisp uses the r7rs external
+representation for such symbols and so all symbols can be written and
+read back.
 @end deffn
diff --git a/src/kgnumbers.c b/src/kgnumbers.c
@@ -2514,6 +2514,9 @@ void kinit_numbers_ground_env(klisp_State *K)
     /* 12.5.? exact-integer? */
     add_applicative(K, ground_env, "exact-integer?", ftypep, 2, symbol, 
                     p2tv(keintegerp));
+    /* 12.5.? u8? */
+    add_applicative(K, ground_env, "u8?", ftypep, 2, symbol, 
+                    p2tv(ku8p));
     /* 12.5.2 =? */
     add_applicative(K, ground_env, "=?", ftyped_kbpredp, 3,
                     symbol, p2tv(knumber_wpvp), p2tv(knum_eqp));
diff --git a/src/kgpairs_lists.c b/src/kgpairs_lists.c
@@ -1345,8 +1345,6 @@ void kinit_pairs_lists_ground_env(klisp_State *K)
     add_applicative(K, ground_env, "countable-list?", countable_listp, 0);
     /* 6.3.10 reduce */
     add_applicative(K, ground_env, "reduce", reduce, 0);
-
-    /* TODO add make-list, list-copy and reverse (from r7rs) */
 }
 
 /* init continuation names */