This is kawa.info, produced by makeinfo version 4.5 from
/home/bothner/Kawa/kawa/doc/kawa.texi.

START-INFO-DIR-ENTRY
* kawa: (kawa).         Kawa, the Java-based Scheme system
END-INFO-DIR-ENTRY


File: kawa.info,  Node: KRL,  Next: Mailing lists,  Prev: XML tools,  Up: Top

KRL - The Kawa Report Language for generating XML/HTML
******************************************************

   KRL (the "Kawa Report Language") is powerful Kawa dialect for
embedding Scheme code in text files such as HTML or XML templates.  You
select the KRL language by specifying `--krl' on the Kawa command line.

   KRL is based on on BRL (http://brl.sourceforge.net/), Bruce Lewis's
"Beautiful Report Language", and uses some of BRL's code, but there are
some experimental differences, and the implementation core is
different.  You can run KRL in BRL-compatility-mode by specifying
`--brl' instead of `--krl'.

Differences between KRL and BRL
===============================

   This section summarizes the known differences between KRL and BRL.
Unless otherwise specified, KRL in BRL-compatibility mode will act as
BRL.

   * In BRL a normal Scheme string `"mystring"' is the same as the
     inverted quote string `]mystring[', and both are instances of the
     type `<string>'.  In KRL `"mystring"' is a normal Scheme string of
     type `<string>', but `]mystring[' is special type that suppresses
     output escaping.  (It is equivalent to `(unescaped-data
     "mystring")'.)

   * When BRL writes out a string, it does not do any processing to
     escape special characters like `<'.  However, KRL in its default
     mode does normally escape characters and strings.  Thus `"<a>"' is
     written as `&lt;a&gr;'.  You can stop it from doing this by
     overriding the output format, for example by specifying
     `--output-format scheme' on the Kawa command line, or by using the
     `unescaped-data' function.

   * Various Scheme syntax forms, including `lambda', take a `<body>',
     which is a list of one or more declarations and expressions.  In
     normal Scheme and in BRL the value of a `<body>' is the value of
     the last expression.  In KRL the value of a `<body>' is the
     concatenation of all the values of the expressions, as if using
     `values-append'.

   * In BRL a word starting with a colon is a keyword.  In KRL a word
     starting with a colon is an identifier, which by default is bound
     to the `make-element' function specialized to take the rest of the
     word as the tag name (first argument).

   * BRL has an extensive utility library.  Most of this has not yet
     been ported to KRL, even in BRL-compatibility mode.


File: kawa.info,  Node: Mailing lists,  Next: Support,  Prev: KRL,  Up: Top

Where to report bugs, discuss changes, etc
******************************************

Reporting bugs
==============

   To report a bug or feature request for Kawa (including Qexo or
JEmacs), it is best to use the bug-submission page
(http://savannah.gnu.org/bugs/?func=addbug&group=kawa).  You can browse
and comment on existing bug reports using the Kawa Bugzilla page
(http://savannah.gnu.org/bugs/?group=kawa).

   When a bug report is created or modified, mail is automatically sent
to the <bug-kawa@gnu.org> list.  You can subscribe, unsubscribe, or
browse the archives through the `bug-kawa' web interface
(http://mail.gnu.org/mailman/listinfo/bug-kawa).

General Kawa email and discussion
=================================

   The general Kawa email list is <kawa@sources.redhat.com>.  This
mailing list is used for announcements, questions, patches, and general
discussion relating to Kawa.  If you wish to subscribe, send a blank
message request to <kawa-subscribe@sources.redhat.com>.  To
unsubscribe, send a blank message to
<kawa-unsubscribe@sources.redhat.com>.  (If your mail is forwarded and
you're not sure which email address you're subscribed as send mail to
the address following `mailto:' in the `List-Unsubscribe' line in the
headers of the messages you get from the list.)

   You can browse the archive of past messages
(http://sources.redhat.com/ml/kawa/).

   There are separate mailing lists for Qexo
(http://mail.gnu.org/mailman/listinfo/qexo-general) and JEmacs
(http://lists.sourceforge.net/mailman/listinfo/jemacs-info).


File: kawa.info,  Node: Support,  Next: Projects,  Prev: Mailing lists,  Up: Top

Technical Support for Kawa
**************************

   If you have a project that depends on Kawa or one of its component
packages, you might do well get get paid priority support from Kawa's
author.

   The base price is $2400 for one year.  This entitles you to basic
support by email or phone.  Per <per@bothner.com> will answer techical
questions about Kawa or its implementation, investigate bug reports, and
suggest work-arounds.  I may (at my discretion) provide fixes and
enhancements (patches) for simple problems.  Reponse for support
requests received using the day (California time) will normally be
within a few hours.

   All support requests must come through a single designated contact
person.  If Kawa is important to your business, you probably want at
least two contact people, doubling the price.

   If the support contract is cancelled (by either party), remaining
time will be prorated and refunded.

   Per is also available for development projects.


File: kawa.info,  Node: Projects,  Next: License,  Prev: Support,  Up: Top

Projects using Kawa
*******************

   JEmacs is included in the Kawa distribution.  It is a project to
re-implement Emacs, allowing a mix of Java. Scheme, and Emacs Lisp.  It
has its own home-page (http://www.jemacs.net/).

   BRL ("the Beautiful Report Language") is a database-oriented language
to embed in HTML and other markup.  BRL (http://brl.sourceforge.net/)
allows you to embed Scheme in a an HTML file on a web server.

   The Health Media Research Laboratory, part of the Comprehensive
Cancer Center at the University of Michigan, is using Kawa as an
integral part of its core tailoring technologies. Java programs using
Kawa libraries are used to administer customized web-based surveys,
generate tailored feedback, validate data, and "characterize," or
transform, data. Kawa code is embedded directly in XML-formatted
surveys and data dictionaries. Performance and ease of implementation
has far exceeded expectations. For more information contact Paul R.
Potts, Technical Director, Health Media Research Lab,
`<potts@umich.edu>'.

   Mike Dillon (`mdillon@gjt.org') did the preliminary work of creating
a Kawa plugin for jEdit. It is called SchemeShell and provides a REPL
inside of the jEdit console for executing expressions in Kawa (much as
the BeanShell plugin does with the BeanShell scripting language).  It
is currently available only via CVS from:
     CVSROOT=:pserver:anonymous@cvs.jedit.sourceforge.net:/cvsroot/jedit
     MODULE=plugins/SchemeShell

   STMicroelectronics (`marco.vezzoli@st.com') uses Kawa in a prototypal
intranet 3tier information retrival system as a communication protocol
between server and clients and to do server agents programming.

   The Nice Programming Language is an open source research language
that has a Java-like syntax.  It features multiple dispatch methods,
parametric types, higher-order functions, tuples, ..., and the new
concept of "abstract interfaces".  The Nice compiler (`nicec') uses
Kawa's `gnu.expr' and `gnu.bytecode' packages to generate Java bytecode.
You can find more about Nice at `http://nice.sourceforge.net'.  For
more information feel free to contact Daniel Bonniot
(`d.bonniot@mail.dotcom.fr').


File: kawa.info,  Node: License,  Next: Overall Index,  Prev: Projects,  Up: Top

License
*******

License for the Kawa software
=============================

   The license for Kawa and the packages it depends on is a "modified
Gnu Public License".  You can find it in the file `COPYING' in the Kawa
sources, and also quoted here:.

     The Java classes (with related files and documentation) in these packages
     are copyright (C) 1996, 1997, 1998, 1999  Per Bothner.
     
     These classes are distributed in the hope that they will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     
     These classes are free software.  You can use and re-distribute a class
     without restriction (in source or binary form) as long as you use a
     version that has not been modified in any way from a version released
     by Per Bothner, Red Hat inc, or the Free Software Foundation.
     You may make and distribute a modified version, provided you follow
     the terms of the GNU General Public License; either version 2,
     or (at your option) any later version.

   The file `COPYING' also contains a copy of the GNU General Public
License version 2.

   People have asked what the Kawa license means in practice.
Informally, you get to pick between these choices:
  1. Use Kawa as distributed by Per Bothner, Red Hat Inc, or the Free
     Software Foundation (or their approved agents), with no
     modifications.  In that case, you can use Kawa for any purpose you
     like, and distribute your application with any license you like.
     (This basically gives you the same rights as a typical commercial
     royalty-free re-distribution license.)

  2. Obey the terms of the standard Gnu Public License.  (See
     `http://www.gnu.org/copyleft/gpl.html').  Informally, this means
     that if you distribute any application that is based on Kawa, you
     must also make available to all your recipients (customers) the
     source code for your entire application, giving them the
     modification and re-distribution rights they have under the GPL.
     In a Java context, I take "entire application" to mean all classes
     (and native code) that run in the same Java virtual machine,
     except for the Java runtime system itself (the virtual machine,
     low-level run-time system, and any classes in a `java' or `javax'
     package).

  3. If you need to make a change to Kawa, you can submit them to Per
     Bothner, and convince him to include them in future Kawa releases.

  4. You can negotiate some other (commercial) license with Per Bothner.

   In general, if the license of Kawa or associated packages causes
difficulties, let me know.

   Kawa uses some math routines from fdlib's libf77, which bear the
following copyright:

     Copyright 1990, 1991, 1992, 1993 by AT&T Bell Laboratories and
     Bellcore.

     Permission to use, copy, modify, and distribute this software and
     its documentation for any purpose and without fee is hereby
     granted, provided that the above copyright notice appear in all
     copies and that both that the copyright notice and this permission
     notice and warranty disclaimer appear in supporting documentation,
     and that the names of AT&T Bell Laboratories or Bellcore or any of
     their entities not be used in advertising or publicity pertaining
     to distribution of the software without specific, written prior
     permission.

     AT&T and Bellcore disclaim all warranties with regard to this
     software, including all implied warranties of merchantability and
     fitness.  In no event shall AT&T or Bellcore be liable for any
     special, indirect or consequential damages or any damages
     whatsoever resulting from loss of use, data or profits, whether in
     an action of contract, negligence or other tortious action,
     arising out of or in connection with the use or performance of
     this software.

Copyright for this manual
=========================

   Here is the license for this manual:

   Copyright (C) 1996, 1997, 1998, 1999 Per Bothner
Parts of this manual were derived from the SLIB manual, copyright (C)
1993-1998 Todd R. Eigenschink and Aubrey Jaffer.
Parts of this manual were derived from ISO/EIC 10179:1996(E) (Document
Style and Specifical Language) - unknown copyright.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the author.

   This manual has quoted from SRFI-6 (Basic String Ports), which is
Copyright (C) William D Clinger (1999). All Rights Reserved.

   This manual has quoted from SRFI-8 (receive: Binding to multiple
values), which is Copyright (C) John David Stone (1999). All Rights
Reserved.

   This manual has quoted from SRFI-9 (Defining Record Types) which is
Copyright (C) Richard Kelsey (1999).  All Rights Reserved.

   This manual has quoted from SRFI-11 (Syntax for receiving multiple
values), which is Copyright (C) Lars T. Hansen (1999). All Rights
Reserved.

   This manual has quoted from SRFI-25 (Multi-dimensional Array
Primitives), which is Copyright (C) Jussi Piitulainen (2001). All
Rights Reserved.

   This manual has quoted from SRFI-26 (Notation for Specializing
Parameters without Currying), which is Copyright (C) Sebastian Egner
(2002). All Rights Reserved.

   The following notice applies to SRFI-6, SRFI-8, SRFI-9, SRFI-11,
SRFI-25, and SRFI-26, which are quoted in this manual, but it does not
apply to the manual as a whole:

     This document and translations of it may be copied and furnished to
     others, and derivative works that comment on or otherwise explain
     it or assist in its implementation may be prepared, copied,
     published and distributed, in whole or in part, without
     restriction of any kind, provided that the above copyright notice
     and this paragraph are included on all such copies and derivative
     works. However, this document itself may not be modified in any
     way, such as by removing the copyright notice or references to the
     Scheme Request For Implementation process or editors, except as
     needed for the purpose of developing SRFIs in which case the
     procedures for copyrights defined in the SRFI process must be
     followed, or as required to translate it into languages other than
     English.


File: kawa.info,  Node: Overall Index,  Prev: License,  Up: Top

Index
*****

* Menu:

* #!eof:                                 Special named constants.
* #!key:                                 Special named constants.
* #!null:                                Special named constants.
* #!optional:                            Special named constants.
* #!rest:                                Special named constants.
* #!void:                                Special named constants.
* <character>:                           Standard Types.
* <complex>:                             Standard Types.
* <f32vector>:                           Uniform vectors.
* <f64vector>:                           Uniform vectors.
* <input-port>:                          Standard Types.
* <integer>:                             Standard Types.
* <keyword>:                             Standard Types.
* <list>:                                Standard Types.
* <number>:                              Standard Types.
* <object>:                              Standard Types.
* <output-port>:                         Standard Types.
* <pair>:                                Standard Types.
* <procedure>:                           Standard Types.
* <quantity>:                            Standard Types.
* <rational>:                            Standard Types.
* <real>:                                Standard Types.
* <s16vector>:                           Uniform vectors.
* <s32vector>:                           Uniform vectors.
* <s64vector>:                           Uniform vectors.
* <s8vector>:                            Uniform vectors.
* <String>:                              Standard Types.
* <string>:                              Standard Types.
* <symbol>:                              Standard Types.
* <u16vector>:                           Uniform vectors.
* <u32vector>:                           Uniform vectors.
* <u64vector>:                           Uniform vectors.
* <u8vector>:                            Uniform vectors.
* <vector>:                              Standard Types.
* apply:                                 Procedures.
* arithmetic-shift:                      Logical Number Operations.
* array:                                 Arrays.
* array-end:                             Arrays.
* array-rank:                            Arrays.
* array-ref:                             Arrays.
* array-set!:                            Arrays.
* array-start:                           Arrays.
* array?:                                Arrays.
* as:                                    Miscellaneous.
* as-xml:                                XML tools.
* ash:                                   Logical Number Operations.
* base-uri:                              Eval and Environments.
* bit-extract:                           Logical Number Operations.
* call-with-input-string:                Ports.
* call-with-output-string:               Ports.
* call-with-values:                      Multiple values.
* catch:                                 Exceptions.
* class-methods:                         Method operations.
* command-line-arguments:                Miscellaneous.
* command-parse:                         Processes.
* compile-file:                          Archive compilation.
* cond-expand:                           Syntax and conditional compilation.
* constant-fold:                         Procedures.
* copy-file:                             Files.
* create-directory:                      Files.
* current-error-port:                    Ports.
* current-servlet:                       Servlets.
* current-servlet-config:                Servlets.
* current-servlet-context:               Servlets.
* cut:                                   Procedures.
* cute:                                  Procedures.
* default-prompter:                      Ports.
* define:                                Declaring Types of Variables.
* define-alias:                          Locations.
* define-base-unit:                      Quantities.
* define-class:                          Defining new classes.
* define-constant:                       Module classes.
* define-namespace:                      Module classes.
* define-private:                        Module classes.
* define-procedure:                      Procedures.
* define-record-type:                    Record types.
* define-simple-class:                   Defining new classes.
* define-syntax:                         Syntax and conditional compilation.
* define-unit:                           Quantities.
* define-variable:                       Module classes.
* defmacro:                              Syntax and conditional compilation.
* delete-file:                           Files.
* dynamic-wind:                          Exceptions.
* environment-bound?:                    Eval and Environments.
* error:                                 Exceptions.
* error-response:                        HTTP response.
* eval:                                  Eval and Environments.
* exit:                                  Miscellaneous.
* f32vector:                             Uniform vectors.
* f32vector->list:                       Uniform vectors.
* f32vector-length:                      Uniform vectors.
* f32vector-ref:                         Uniform vectors.
* f32vector-set!:                        Uniform vectors.
* f32vector?:                            Uniform vectors.
* f64vector:                             Uniform vectors.
* f64vector->list:                       Uniform vectors.
* f64vector-length:                      Uniform vectors.
* f64vector-ref:                         Uniform vectors.
* f64vector-set!:                        Uniform vectors.
* f64vector?:                            Uniform vectors.
* field:                                 Field operations.
* file-directory?:                       Files.
* file-exists?:                          Files.
* file-readable?:                        Files.
* file-writable?:                        Files.
* fluid-let:                             Eval and Environments.
* force:                                 Threads.
* force-output:                          Ports.
* format:                                Format.
* future:                                Threads.
* gentemp:                               Syntax and conditional compilation.
* get-output-string:                     Ports.
* home-directory:                        Miscellaneous.
* input-port-column-number:              Ports.
* input-port-line-number:                Ports.
* input-port-prompter:                   Ports.
* input-port-read-state:                 Ports.
* instance?:                             Miscellaneous.
* integer-length:                        Logical Number Operations.
* interaction-environment:               Eval and Environments.
* invoke:                                Method operations.
* invoke-special:                        Method operations.
* invoke-static:                         Method operations.
* keyword->string:                       Keywords.
* keyword?:                              Keywords.
* let:                                   Declaring Types of Variables.
* let*:                                  Declaring Types of Variables.
* let*-values:                           Multiple values.
* let-values:                            Multiple values.
* letrec:                                Declaring Types of Variables.
* list->f32vector:                       Uniform vectors.
* list->f64vector:                       Uniform vectors.
* list->s16vector:                       Uniform vectors.
* list->s32vector:                       Uniform vectors.
* list->s64vector:                       Uniform vectors.
* list->s8vector:                        Uniform vectors.
* list->u16vector:                       Uniform vectors.
* list->u32vector:                       Uniform vectors.
* list->u64vector:                       Uniform vectors.
* list->u8vector:                        Uniform vectors.
* load:                                  Eval and Environments.
* load-relative:                         Eval and Environments.
* location:                              Locations.
* logand:                                Logical Number Operations.
* logbit?:                               Logical Number Operations.
* logcount:                              Logical Number Operations.
* logior:                                Logical Number Operations.
* lognot:                                Logical Number Operations.
* logop:                                 Logical Number Operations.
* logtest:                               Logical Number Operations.
* logxor:                                Logical Number Operations.
* make:                                  Allocating objects.
* make-array:                            Arrays.
* make-attribute:                        XML tools.
* make-element:                          XML tools.
* make-f32vector:                        Uniform vectors.
* make-f64vector:                        Uniform vectors.
* make-procedure:                        Procedures.
* make-process:                          Processes.
* make-quantity:                         Quantities.
* make-record-type:                      Dynamic records.
* make-s16vector:                        Uniform vectors.
* make-s32vector:                        Uniform vectors.
* make-s64vector:                        Uniform vectors.
* make-s8vector:                         Uniform vectors.
* make-temporary-file:                   Files.
* make-u16vector:                        Uniform vectors.
* make-u32vector:                        Uniform vectors.
* make-u64vector:                        Uniform vectors.
* make-u8vector:                         Uniform vectors.
* module-compile-options:                Compilation options.
* module-export:                         Module classes.
* module-extends:                        Module classes.
* module-implements:                     Module classes.
* module-name:                           Module classes.
* module-static:                         Module classes.
* modulo:                                Quantities.
* null-environment:                      Eval and Environments.
* object:                                Anonymous classes.
* open-input-string:                     Ports.
* open-output-string:                    Ports.
* options:                               Options.
* parse-format:                          Format.
* port-char-encoding:                    Ports.
* port-column:                           Ports.
* port-line:                             Ports.
* primitive-array-get:                   Array operations.
* primitive-array-length:                Array operations.
* primitive-array-new:                   Array operations.
* primitive-array-set:                   Array operations.
* primitive-constructor:                 Low-level Method invocation.
* primitive-get-field:                   Low-level Field operations.
* primitive-get-static:                  Low-level Field operations.
* primitive-interface-method:            Low-level Method invocation.
* primitive-set-field:                   Low-level Field operations.
* primitive-set-static:                  Low-level Field operations.
* primitive-static-method:               Low-level Method invocation.
* primitive-throw:                       Exceptions.
* primitive-virtual-method:              Low-level Method invocation.
* procedure-property:                    Procedures.
* quantity->number:                      Quantities.
* quantity->unit:                        Quantities.
* quantity?:                             Quantities.
* quotient:                              Quantities.
* read-line:                             Ports.
* receive:                               Multiple values.
* record-accessor:                       Dynamic records.
* record-constructor:                    Dynamic records.
* record-modifier:                       Dynamic records.
* record-predicate:                      Dynamic records.
* record-type-descriptor:                Dynamic records.
* record-type-field-names:               Dynamic records.
* record-type-name:                      Dynamic records.
* record?:                               Dynamic records.
* remainder:                             Quantities.
* rename-file:                           Files.
* request-method:                        HTTP requests.
* request-path-info:                     HTTP requests.
* request-path-translated:               HTTP requests.
* request-query-string:                  HTTP requests.
* request-uri:                           HTTP requests.
* request-url:                           HTTP requests.
* require:                               Module classes.
* response-content-type:                 HTTP response.
* response-header:                       HTTP response.
* response-status:                       HTTP response.
* reverse!:                              Lists.
* s16vector:                             Uniform vectors.
* s16vector->list:                       Uniform vectors.
* s16vector-length:                      Uniform vectors.
* s16vector-ref:                         Uniform vectors.
* s16vector-set!:                        Uniform vectors.
* s16vector?:                            Uniform vectors.
* s32vector:                             Uniform vectors.
* s32vector->list:                       Uniform vectors.
* s32vector-length:                      Uniform vectors.
* s32vector-ref:                         Uniform vectors.
* s32vector-set!:                        Uniform vectors.
* s32vector?:                            Uniform vectors.
* s64vector:                             Uniform vectors.
* s64vector->list:                       Uniform vectors.
* s64vector-length:                      Uniform vectors.
* s64vector-ref:                         Uniform vectors.
* s64vector-set!:                        Uniform vectors.
* s64vector?:                            Uniform vectors.
* s8vector:                              Uniform vectors.
* s8vector->list:                        Uniform vectors.
* s8vector-length:                       Uniform vectors.
* s8vector-ref:                          Uniform vectors.
* s8vector-set!:                         Uniform vectors.
* s8vector?:                             Uniform vectors.
* scheme-implementation-version:         Miscellaneous.
* scheme-report-environment:             Eval and Environments.
* scheme-window:                         Miscellaneous.
* Scheme.eval:                           Evaluating Scheme expressions from Java.
* Scheme.registerEnvironment:            Evaluating Scheme expressions from Java.
* servlet-context-realpath:              Servlets.
* set-input-port-line-number!:           Ports.
* set-input-port-prompter!:              Ports.
* set-port-line!:                        Ports.
* set-procedure-property!:               Procedures.
* setter:                                Locations.
* shape:                                 Arrays.
* share-array:                           Arrays.
* sleep:                                 Threads.
* slot-ref:                              Field operations.
* slot-set!:                             Field operations.
* static-field:                          Field operations.
* string->keyword:                       Keywords.
* string-capitalize:                     Strings.
* string-capitalize!:                    Strings.
* string-downcase:                       Strings.
* string-downcase!:                      Strings.
* string-upcase:                         Strings.
* string-upcase!:                        Strings.
* symbol-read-case:                      Ports.
* synchronized:                          Miscellaneous.
* system:                                Processes.
* system-tmpdir:                         Files.
* this:                                  Objects Classes and Modules.
* throw:                                 Exceptions.
* tokenize-string-to-string-array:       Processes.
* trace:                                 Debugging.
* try-catch:                             Exceptions.
* try-finally:                           Exceptions.
* u16vector:                             Uniform vectors.
* u16vector->list:                       Uniform vectors.
* u16vector-length:                      Uniform vectors.
* u16vector-ref:                         Uniform vectors.
* u16vector-set!:                        Uniform vectors.
* u16vector?:                            Uniform vectors.
* u32vector:                             Uniform vectors.
* u32vector->list:                       Uniform vectors.
* u32vector-length:                      Uniform vectors.
* u32vector-ref:                         Uniform vectors.
* u32vector-set!:                        Uniform vectors.
* u32vector?:                            Uniform vectors.
* u64vector:                             Uniform vectors.
* u64vector->list:                       Uniform vectors.
* u64vector-length:                      Uniform vectors.
* u64vector-ref:                         Uniform vectors.
* u64vector-set!:                        Uniform vectors.
* u64vector?:                            Uniform vectors.
* u8vector:                              Uniform vectors.
* u8vector->list:                        Uniform vectors.
* u8vector-length:                       Uniform vectors.
* u8vector-ref:                          Uniform vectors.
* u8vector-set!:                         Uniform vectors.
* u8vector?:                             Uniform vectors.
* unescaped-data:                        HTTP response.
* unless:                                Miscellaneous.
* untrace:                               Debugging.
* values:                                Multiple values.
* values-append:                         Multiple values.
* vector-append:                         Miscellaneous.
* when:                                  Miscellaneous.
* with-compile-options:                  Compilation options.


