Index

Symbols

#!eof: Special named constants
#!fold-case: Identifiers
#!key: Special named constants
#!no-fold-case: Identifiers
#!null: Special named constants
#!optional: Special named constants
#!rest: Special named constants
#!void: Special named constants
*: Arithmetic operations
*print-base*: Miscellaeous
*print-miser-width*: Miscellaeous
*print-radix*: Miscellaeous
*print-right-margin*: Miscellaeous
*print-xml-indent*: Miscellaeous
+: Arithmetic operations
-: Arithmetic operations
/: Arithmetic operations
~$: Formatting real numbers
~%: Miscellaneous formatting operators
~&: Miscellaneous formatting operators
~(: Miscellaneous formatting operators
~*: Miscellaneous formatting operators
~;: Miscellaneous formatting operators
~?: Miscellaneous formatting operators
~a: Implemented CL Format Control Directives
~b: Formatting Integers
~c: Implemented CL Format Control Directives
~d: Formatting Integers
~e: Formatting real numbers
~f: Formatting real numbers
~g: Formatting real numbers
~newline: Miscellaneous formatting operators
~o: Formatting Integers
~p: Formatting Integers
~r: Formatting Integers
~s: Implemented CL Format Control Directives
~t: Miscellaneous formatting operators
~x: Formatting Integers
~[: Miscellaneous formatting operators
~^: Miscellaneous formatting operators
~{: Miscellaneous formatting operators
~|: Miscellaneous formatting operators
~~: Miscellaneous formatting operators
–no-warn-whatever: Options for warnings and errors
–warn-whatever: Options for warnings and errors

A

abbrev-prefix: Abbreviations
abbreviation: Abbreviations
abs: Arithmetic operations
acos: Arithmetic operations
alist->hash-table: Type constructors and predicate
alternate: Conditionals
and: Conditionals
annotation: Annotations of declarations
annotation-element-pair: Annotations of declarations
annotation-element-value: Annotations of declarations
annotation-typename: Annotations of declarations
annotations-element-values: Annotations of declarations
apos-attribute-datum: Attributes
apply: Procedures
arg-with-default: Extended Formal Arguments List
arithmetic-shift: Deprecated Logical Number Operations
array: Multi-dimensional Arrays
array-end: Multi-dimensional Arrays
array-rank: Multi-dimensional Arrays
array-ref: Multi-dimensional Arrays
array-set!: Multi-dimensional Arrays
array-start: Multi-dimensional Arrays
array?: Multi-dimensional Arrays
as: Type tests and conversions
as-xml: Formatting XML
ash: Deprecated Logical Number Operations
asin: Arithmetic operations
atan: Arithmetic operations
atmosphere: Whitespace and comments
attribute-name: Creating XML nodes

B

base-uri: Eval and Environments
binary-port?: Ports
bit-extract: Deprecated Logical Number Operations
bitwise-and: Logical Number Operations
bitwise-arithmetic-shift: Logical Number Operations
bitwise-arithmetic-shift-left: Logical Number Operations
bitwise-arithmetic-shift-right: Logical Number Operations
bitwise-bit-count: Logical Number Operations
bitwise-bit-field: Logical Number Operations
bitwise-bit-set?: Logical Number Operations
bitwise-copy-bit: Logical Number Operations
bitwise-copy-bit-field: Logical Number Operations
bitwise-first-bit-set: Logical Number Operations
bitwise-if: Logical Number Operations
bitwise-ior: Logical Number Operations
bitwise-length: Logical Number Operations
bitwise-not: Logical Number Operations
bitwise-reverse-bit-field: Logical Number Operations
bitwise-rotate-bit-field: Logical Number Operations
bitwise-xor: Logical Number Operations
body: Bodies
bound-identifier=?: Identifier predicates
bytevector: Bytevectors
bytevector-append: Bytevectors
bytevector-copy: Bytevectors
bytevector-copy!: Bytevectors
bytevector-length: Bytevectors
bytevector-u8-ref: Bytevectors
bytevector-u8-set!: Bytevectors
bytevector?: Bytevectors

C

call-with-input-file: Ports
call-with-input-string: String and bytevector ports
call-with-output-file: Ports
call-with-output-string: String and bytevector ports
call-with-port: Ports
call-with-values: Multiple values
case: Conditionals
case-clause: Conditionals
catch: Exception handling
ceiling: Arithmetic operations
char->integer: Characters
char-alphabetic?: Characters
char-ci<=?: Characters
char-ci<?: Characters
char-ci=?: Characters
char-ci>=?: Characters
char-ci>?: Characters
char-downcase: Characters
char-foldcase: Characters
char-general-category: Characters
char-lower-case?: Characters
char-numeric?: Characters
char-ready?: Input
char-set: Character sets
char-title-case?: Characters
char-titlecase: Characters
char-upcase: Characters
char-upper-case?: Characters
char-whitespace?: Characters
char<=?: Characters
char<?: Characters
char=?: Characters
char>=?: Characters
char>?: Characters
char?: Characters
character: Standard Types
character-except-vbar: Identifiers
character-except-x: Identifiers
child-value: Allocating objects
class-methods: Invoking a method with the invoke function
class-name: Defining new classes
close-input-port: Ports
close-output-port: Ports
close-port: Ports
command-line: Processes
command-line-arguments: Processes
command-parse: Processes
comment: Whitespace and commentscomment: Creating XML nodes
comment-cont: Whitespace and comments
comment-text: Whitespace and comments
compile-file: Compiling to an archive file
complex: Standard Types
compound-datum: Datum syntax
cond: Conditionals
cond-clause: Conditionals
cond-expand: Syntax and conditional compilation
cond-expand-clause: Syntax and conditional compilation
consequent: Conditionals
constant: Literal expressions
constant-fold: Procedures
constituent: Identifiers
constructor-value: Allocating objects
copy-file: File System Interface
cos: Arithmetic operations
create-directory: File System Interface
current-error-port: Ports
current-input-port: Ports
current-output-port: Ports
current-servlet: Servlet-specific script functions
current-servlet-config: Servlet-specific script functions
current-servlet-context: Servlet-specific script functions
cut: Extended Formal Arguments List
cute: Extended Formal Arguments List

D

datum: Datum syntax
datum->syntax: Syntax-object and datum conversions
datum->syntax-object: Syntax-object and datum conversions
decimal: Numbers
default-prompter: Line numbers and other input port properties
define: Definitions
define-alias: Locations
define-base-unit: Quantities and Units
define-class: Defining new classes
define-constant: Definitions
define-enum: Enumeration types
define-macro: Macros
define-namespace: Namespace aliases
define-private: Definitions
define-private-namespace: Namespace aliases
define-procedure: Procedure properties
define-record-type: Record types
define-simple-class: Defining new classes
define-syntax: Macros
define-syntax-case: Macros
define-unit: Quantities and Units
define-variable: Definitions
define-xml-namespace: Namespace aliases
defined-datum: Datum syntax
defining-datum: Datum syntax
defmacro: Macros
delay: Delayed evaluation
delete-file: File System Interface
delimiter: Formal account
denominator: Arithmetic operations
deprecated-return-specifier: Declaring methods
digit: Identifiers
digit-10: Numbers
digit-16: Numbers
digit-2: Numbers
digit-8: Numbers
disassemble: Debugging
display: Output
div: Arithmetic operations
div-and-mod: Arithmetic operations
div0: Arithmetic operations
div0-and-mod0: Arithmetic operations
dynamic-wind: Exception handling

E

eager: Delayed evaluation
element-name: Creating XML nodes
environment-bound?: Eval and Environments
eof-object: Input
eof-object?: Input
equal-hash: Hash functions
error: Exception handling
error-response: Generating HTTP responses
escape-sequence: Identifiers
eval: Eval and Environments
exact-integer-sqrt: Arithmetic operations
exit: Processes
exp: Arithmetic operations
expand: Macros
exponent-marker: Numbers
expression: Primitive expression syntax

F

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
feature-identifier: Syntax and conditional compilation
feature-requirement: Syntax and conditional compilation
fff-rec: Syntax and conditional compilation
field: Using field and static-field methods
field-decl: Declaring fields
field-name: Declaring fields
field-option: Declaring fields
field-or-method-decl: Defining new classes
file-directory?: File System Interface
file-exists?: File System Interface
file-readable?: File System Interface
file-writable?: File System Interface
filepath: Paths - file name, URLs, and URIs
filepath?: Paths - file name, URLs, and URIs
finite?: Arithmetic operations
floor: Arithmetic operations
fluid-let: Eval and Environments
flush-output-port: Output
force: Delayed evaluationforce: Threads
force*: Delayed evaluation
force-output: Output
formal-arguments: Extended Formal Arguments List
formals: Extended Formal Arguments List
format: Formatted Output (Common-Lisp-style)
free-identifier=?: Identifier predicates
future: Threads

G

gcd: Arithmetic operations
gentemp: Macros
get-output-bytevector: String and bytevector ports
get-output-string: String and bytevector ports
get-request: Servlet-specific script functions
get-response: Servlet-specific script functions
Glassfish: Installing a servlet under Glassfish

H

hash: Hash functions
hash-by-identity: Hash functions
hash-table->alist: Dealing with the whole contents
hash-table-copy: Dealing with the whole contents
hash-table-delete!: Dealing with single elements
hash-table-equivalence-function: Reflective queries
hash-table-exists?: Dealing with single elements
hash-table-fold: Dealing with the whole contents
hash-table-hash-function: Reflective queries
hash-table-keys: Dealing with the whole contents
hash-table-merge!: Dealing with the whole contents
hash-table-ref: Dealing with single elements
hash-table-ref/default: Dealing with single elements
hash-table-set!: Dealing with single elements
hash-table-size: Dealing with the whole contents
hash-table-update!: Dealing with single elements
hash-table-update!/default: Dealing with single elements
hash-table-values: Dealing with the whole contents
hash-table-walk: Dealing with the whole contents
hash-table?: Type constructors and predicate
hashtable-clear!: Procedures
hashtable-contains?: Procedures
hashtable-copy: Procedures
hashtable-delete!: Procedures
hashtable-entries: Procedures
hashtable-equivalence-function: Inspection
hashtable-hash-function: Inspection
hashtable-keys: Procedures
hashtable-mutable?: Inspection
hashtable-ref: Procedures
hashtable-set!: Procedures
hashtable-size: Procedures
hashtable-update!: Procedures
hashtable?: Procedures
hex-digit: Identifiers
hex-scalar-value: Identifiers
home-directory: Processes
html:: Creating HTML nodes

I

identifier: Identifiers
identifier?: Identifier predicates
if: Conditionals
import: Requiring (importing) a module
import-set: Requiring (importing) a module
include: Syntax and conditional compilation
include-relative: Syntax and conditional compilation
indexnum: Datum syntax
infinite?: Arithmetic operations
initial: Identifiers
inline-hex-escape: Identifiers
input-port: Standard Types
input-port-column-number: Line numbers and other input port properties
input-port-line-number: Line numbers and other input port properties
input-port-open?: Ports
input-port-prompter: Line numbers and other input port properties
input-port-read-state: Line numbers and other input port properties
input-port?: Ports
instance?: Type tests and conversions
integer: Standard Types
integer->char: Characters
integer-length: Deprecated Logical Number Operations
integer-valued?: Arithmetic operations
interaction-environment: Eval and Environments
interlexeme-space: Whitespace and comments
invoke: Invoking a method with the invoke function
invoke-special: Invoking a method with the invoke function
invoke-static: Invoking a method with the invoke function

K

kawa-abbreviation: Abbreviations
kawac: Compiling using Ant
key-arg: Extended Formal Arguments List
keyword: Keywordskeyword: Standard Types
keyword->string: Keywords
keyword?: Keywords

L

lambda-expression: Extended Formal Arguments List
lazy: Delayed evaluation
lcm: Arithmetic operations
let: Declaring Types of Variables
let*: Declaring Types of Variables
let*-values: Multiple values
let-values: Multiple values
letrec: Declaring Types of Variables
letter: Identifiers
lexeme: Formal account
lexeme-datum: Datum syntax
library-reference: Requiring (importing) a module
line ending: Whitespace and comments
list: Datum syntaxlist: Standard Types
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->string: Strings
list->u16vector: Uniform vectors
list->u32vector: Uniform vectors
list->u64vector: Uniform vectors
list->u8vector: Uniform vectors
list->vector: Vectors
literal-expression: Literal expressions
load: Eval and Environments
load-relative: Eval and Environments
location: Locations
log: Arithmetic operations
logand: Deprecated Logical Number Operations
logbit?: Deprecated Logical Number Operations
logcount: Deprecated Logical Number Operations
logior: Deprecated Logical Number Operations
lognot: Deprecated Logical Number Operations
logop: Logical Number Operations
logtest: Logical Number Operations
logxor: Deprecated Logical Number Operations

M

make: Allocating objects
make-array: Multi-dimensional Arrays
make-attribute: Creating XML nodes
make-bytevector: Bytevectors
make-element: Creating XML nodes
make-eq-hashtable: R6RS hash tables
make-eqv-hashtable: R6RS hash tables
make-f32vector: Uniform vectors
make-f64vector: Uniform vectors
make-hash-table: Type constructors and predicate
make-hashtable: R6RS hash tables
make-parameter: Parameter objects
make-procedure: Generic (dynamically overloaded) procedures
make-process: Processes
make-quantity: Quantities and Units
make-record-type: Creating New Record Types On-the-fly
make-s16vector: Uniform vectors
make-s32vector: Uniform vectors
make-s64vector: Uniform vectors
make-s8vector: Uniform vectors
make-string: Strings
make-temporary-file: File System Interface
make-u16vector: Uniform vectors
make-u32vector: Uniform vectors
make-u64vector: Uniform vectors
make-u8vector: Uniform vectors
make-vector: Vectors
method-body: Declaring methods
method-decl: Declaring methods
method-name: Declaring methods
mod: Arithmetic operations
mod0: Arithmetic operations
module-compile-options: Module options
module-export: Name visibility
module-extends: How a module becomes a class
module-implements: How a module becomes a class
module-name: How a module becomes a class
module-static: Static vs non-static modules
module-uri: Resources
modulo: Arithmetic operations
multi-escape-sequence: Identifiers

N

namespace: Namespace objects
namespace-prefix: Namespace objects
namespace-uri: Namespace objects
nan?: Arithmetic operations
nested-comment: Whitespace and comments
newline: Output
nondefining-datum: Datum syntax
null-environment: Eval and Environments
number: Numbersnumber: Standard Types
numerator: Arithmetic operations

O

Object: Standard Types
object: Anonymous classes
object-field-decl: Anonymous classes
object-field-or-method-decl: Anonymous classes
object-init: Anonymous classes
open-binary-input-file: Ports
open-binary-output-file: Ports
open-input-bytevector: String and bytevector ports
open-input-file: Ports
open-input-string: String and bytevector ports
open-output-bytevector: String and bytevector ports
open-output-file: Ports
open-output-string: String and bytevector ports
operand: Procedure calls
operator: Procedure calls
opt-arg: Extended Formal Arguments List
opt-return-type: Extended Formal Arguments List
opt-type-specifier: Types
option-pair: Defining new classes
optional-exponent: Numbers
optional-sign: Numbers
options: Command-line arguments
or: Conditionals
output-port: Standard Types
output-port-open?: Ports
output-port?: Ports

P

pair: Standard Types
parameterize: Parameter objects
parse-format: Formatted Output (Common-Lisp-style)
path: Paths - file name, URLs, and URIs
path-authority: Extracting Path components
path-directory: Extracting Path components
path-extension: Extracting Path components
path-file: Extracting Path components
path-fragment: Extracting Path components
path-host: Extracting Path components
path-last: Extracting Path components
path-parent: Extracting Path components
path-port: Extracting Path components
path-query: Extracting Path components
path-scheme: Extracting Path components
path-user-info: Extracting Path components
path?: Paths - file name, URLs, and URIs
peculiar-identifier: Identifiers
peek-char: Input
peek-u8: Input
port-char-encoding: Miscellaeous
port-column: Line numbers and other input port properties
port-line: Line numbers and other input port properties
port?: Ports
primitive-array-get: Old low-level array macros
primitive-array-length: Old low-level array macros
primitive-array-new: Old low-level array macros
primitive-array-set: Old low-level array macros
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: Exception handling
primitive-virtual-method: Low-level Method invocation
procedure: Standard Types
procedure-call: Procedure calls
procedure-property: Procedure properties
process-command-line-assignments: Processes
processing-instruction: Creating XML nodes
promise: Blank promises
promise-set-alias!: Blank promises
promise-set-exception!: Blank promises
promise-set-thunk!: Blank promises
promise-set-value!: Blank promises
promise[T]: Lazy and eager types
property-access-abbreviation: Property access using colon notation
property-initializer: Allocating objects
property-name: Property access using colon notation
property-owner-expression: Property access using colon notation
provide: Requiring (importing) a module

Q

QName: QNames and namespaces
quantity: Quantities and Unitsquantity: Standard Types
quantity->number: Quantities and Units
quantity->unit: Quantities and Units
quantity?: Quantities and Units
quasisyntax: Convenience forms
quot-attribute-datum: Attributes
quotient: Arithmetic operations

R

r6rs-abbreviation: Abbreviations
rational: Standard Types
rational-valued?: Arithmetic operations
rationalize: Arithmetic operations
read: Input
read-bytevector: Input
read-bytevector!: Input
read-char: Input
read-line: Input
read-string: Input
read-u8: Input
real: Standard Types
real-valued?: Arithmetic operations
receive: Multiple values
record-accessor: Creating New Record Types On-the-fly
record-constructor: Creating New Record Types On-the-fly
record-modifier: Creating New Record Types On-the-fly
record-predicate: Creating New Record Types On-the-fly
record-type-descriptor: Creating New Record Types On-the-fly
record-type-field-names: Creating New Record Types On-the-fly
record-type-name: Creating New Record Types On-the-fly
record?: Creating New Record Types On-the-fly
regex: Java regular expressions
regex-match: Java regular expressions
regex-match-positions: Java regular expressions
regex-quote: Java regular expressions
regex-split: Java regular expressions
regex‑replace: Java regular expressions
regex‑replace*: Java regular expressions
remainder: Arithmetic operations
rename-file: File System Interface
req-arg: Extended Formal Arguments List
req-opt-args: Extended Formal Arguments List
request-body-string: Request body
request-context-path: Request URL components
request-header: Request headers
request-header-map: Request headers
request-input-port: Request body
request-input-stream: Request body
request-local-host: Request IP addresses and ports
request-local-IP-address: Request IP addresses and ports
request-local-path: Request URL components
request-local-port: Request IP addresses and ports
request-local-socket-address: Request IP addresses and ports
request-method: Miscellaneous request properties
request-parameter: Request parameters
request-parameter-map: Request parameters
request-parameters: Request parameters
request-path: Request URL components
request-path-info: Servlet-specific script functions
request-path-translated: Miscellaneous request properties
request-query-string: Request URL components
request-remote-host: Request IP addresses and ports
request-remote-IP-address: Request IP addresses and ports
request-remote-port: Request IP addresses and ports
request-remote-socket-address: Request IP addresses and ports
request-scheme: Miscellaneous request properties
request-script-path: Request URL components
request-servlet-path: Servlet-specific script functions
request-URI: Request URL components
request-uri: Request URL components
request-url: Request URL components
require: Requiring (importing) a module
resolve-uri: Extracting Path components
resource-url: Resources
response-content-type: Generating HTTP responses
response-header: Generating HTTP responses
response-status: Generating HTTP responses
rest-arg: Extended Formal Arguments List
rest-key-args: Extended Formal Arguments List
return-type: Extended Formal Arguments List
reverse!: Lists
round: Arithmetic operations
runnable: Threads

S

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: Servlet-specific script functions
set-input-port-line-number!: Line numbers and other input port properties
set-input-port-prompter!: Line numbers and other input port properties
set-port-line!: Line numbers and other input port properties
set-procedure-property!: Procedure properties
setter: Locations
shape: Multi-dimensional Arrays
share-array: Multi-dimensional Arrays
sin: Arithmetic operations
sleep: Threads
slot-ref: Using field and static-field methods
slot-set!: Using field and static-field methods
special-initial: Identifiers
special-subsequent: Identifiers
sqrt: Arithmetic operations
statement: Bodies
static-field: Using field and static-field methods
string: Stringsstring: Standard Types
String: Standard Types
string->keyword: Keywords
string->list: Strings
string->symbol: Simple symbols
string->vector: Vectors
string-append: Strings
string-capitalize!: Deprecated in-place case modification
string-ci-hash: Hash functionsstring-ci-hash: Hash functions
string-ci<=?: Strings
string-ci<?: Strings
string-ci=?: Strings
string-ci>=?: Strings
string-ci>?: Strings
string-copy: Strings
string-downcase: Strings
string-downcase!: Deprecated in-place case modification
string-foldcase: Strings
string-for-each: Strings
string-hash: Hash functionsstring-hash: Hash functions
string-length: Strings
string-normalize-nfc: Strings
string-normalize-nfd: Strings
string-normalize-nfkc: Strings
string-normalize-nfkd: Strings
string-ref: Strings
string-titlecase: Strings
string-upcase: Strings
string-upcase!: Deprecated in-place case modification
string<=?: Strings
string<?: Strings
string=?: Strings
string>=?: Strings
string>?: Strings
string?: Strings
subsequent: Identifiers
substring: Strings
symbol: Datum syntaxsymbol: Compound symbolssymbol: Standard Types
symbol->string: Simple symbols
symbol-hash: Hash functions
symbol-local-name: Compound symbols
symbol-namespace: Compound symbols
symbol-namespace-uri: Compound symbols
symbol-prefix: Compound symbols
symbol-read-case: Line numbers and other input port properties
symbol=?: Compound symbols
symbol?: Simple symbols
synchronized: Threads
synchronized methods: Synchronized methods
syntax->datum: Syntax-object and datum conversions
syntax-object->datum: Syntax-object and datum conversions
system: Processes
system-tmpdir: File System Interface

T

tan: Arithmetic operations
test-expression: Conditionals
textual-port?: Ports
this: Object, Classes and Modules
throw: Exception handling
tokenize-string-to-string-array: Processes
Tomcat: Installing a servlet under Tomcat
trace: Debugging
truncate: Arithmetic operations
try-catch: Exception handling
try-finally: Exception handling
type: Types

U

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
u8-ready?: Input
u8vector: Uniform vectors
u8vector->list: Uniform vectors
u8vector-length: Uniform vectors
u8vector-ref: Uniform vectors
u8vector-set!: Uniform vectors
u8vector?: Uniform vectors
unescaped-data: Formatting XML
uniform-vector: Datum syntax
unit-name: Quantities and Units
unit-term: Quantities and Units
unless: Conditionals
unsyntax: Convenience forms
unsyntax-splicing: Convenience forms
untrace: Debugging
URI: Paths - file name, URLs, and URIs
URI?: Paths - file name, URLs, and URIs
URL: Paths - file name, URLs, and URIs

V

values: Multiple values
values-append: Multiple values
variable-reference: Variable references
vector: Datum syntaxvector: Vectorsvector: Standard Types
vector->list: Vectors
vector->string: Vectors
vector-append: Vectors
vector-copy: Vectors
vector-copy!: Vectors
vector-fill!: Vectors
vector-for-each: Vectors
vector-length: Vectors
vector-map: Vectors
vector-ref: Vectors
vector-set!: Vectors
vector?: Vectors

W

warn-as-error: Options for warnings and errors
warn-invoke-unknown-method: Options for warnings and errors
warn-undefined-variable: Options for warnings and errors
warn-unknown-member: Options for warnings and errors
when: Conditionals
whitespace: Whitespace and comments
with-compile-options: Module options
with-input-from-file: Ports
with-output-to-file: Ports
with-syntax: Convenience forms
write: Output
write-bytevector: Output
write-char: Output
write-shared: Output
write-simple: Output
write-string: Output
write-u8: Output

X

xml-attribute: Attributes
xml-attribute-value: Attributes
xml-CDATA-constructor: CDATA sections
xml-CDATA-content: CDATA sections
xml-character-reference: Elements contents (children)
xml-comment-constructor: XML comments
xml-comment-content: XML comments
xml-constructor: XML literals
xml-element-constructor: Element constructors
xml-element-datum: Elements contents (children)
xml-enclosed-expression: Element constructors
xml-entity-name: Elements contents (children)
xml-escaped: Elements contents (children)
xml-literal: XML literals
xml-local-part: QNames and namespaces
xml-name-form: Element constructors
xml-namespace-declaration-attribute: QNames and namespaces
xml-PI-constructor: Processing instructions
xml-PI-content: Processing instructions
xml-PI-target: Processing instructions
xml-prefix: QNames and namespaces

Previous sibling: License

Previous page: License for the Kawa manual