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
any-bits-set?: SRFI-60 Logical Number Operations
apos-attribute-datum: Attributes
apply: Procedures
arg-with-default: Extended Formal Arguments List
arithmetic-shift: SRFI-60 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: SRFI-60 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-count: SRFI-60 Logical Number Operations
bit-extract: Deprecated Logical Number Operations
bit-field: SRFI-60 Logical Number Operations
bit-set?: SRFI-60 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-merge: SRFI-60 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
boolean: Boolean values
boolean=?: Boolean values
boolean?: Boolean values
booleans->integer: SRFI-60 Logical Number Operations
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
case-else-clause: Conditionals
case-key: Conditionals
catch: Named exceptions
ceiling: Arithmetic operations
char: Characters
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-or-entity-name: Special characters
char-ready?: Input
char-ref: Special characters
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: Characters character: Standard Types
character-except-x: Identifiers
character-or-eof: Characters
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
cname: Named quasi-literals
command-line: System inquiry
command-line-arguments: System inquiry
command-parse: Processes
comment: Whitespace and comments comment: 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-bit: SRFI-60 Logical Number Operations
copy-bit-field: SRFI-60 Logical Number Operations
copy-file: File System Interface
cos: Arithmetic operations
create-directory: File System Interface
current-error-port: Ports
current-input-port: Ports
current-jiffy: Time-related functions
current-output-port: Ports
current-second: Time-related functions
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
datum-label: Datum labels
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-early-constant: Definitions
define-enum: Enumeration types
define-macro: Macros
define-namespace: Namespace aliases
define-private: Definitions
define-private-alias: Locations
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 labels
defining-datum: Datum labels
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
digit-value: Characters
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
emergency-exit: Processes
enclosed-modifier: Formatting
enclosed-part: Embedded expressions
entity-ref: Special characters
environment-bound?: Eval and Environments
eof-object: Input
eof-object?: Input
equal-hash: Hash functions
error: Simple error objects
error-object-irritants: Simple error objects
error-object-message: Simple error objects
error-object?: Simple error objects
error-response: Generating HTTP responses
escape-sequence: Identifiers
eval: Eval and Environments
exact-integer-sqrt: Arithmetic operations
exact-integer?: Arithmetic operations
exit: Processes
exp: Arithmetic operations
expand: Macros
exponent-marker: Numbers
export: Name visibility
export-spec: Name visibility
expression: Primitive expression syntax
extended-datum-literal: Named quasi-literals
extended-string-literal: String templates

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
features: 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-error?: Exception handling
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
first-set-bit: SRFI-60 Logical Number Operations
floor: Arithmetic operations
floor-quotient: Arithmetic operations
floor-remainder: Arithmetic operations
floor/: Arithmetic operations
fluid-let: Eval and Environments
flush-output-port: Output
force: Delayed evaluation force: 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

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: System inquiry
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 labels
infinite?: Arithmetic operations
initial: Identifiers
initial-ignored: Multiline string literals
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->list: SRFI-60 Logical Number Operations
integer-length: SRFI-60 Logical Number Operations
integer-valued?: Arithmetic operations
interaction-environment: Eval and Environments
interlexeme-space: Whitespace and comments
intraline-whitespace: 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

J

JavaFX: Building JavaFX applications
jiffies-per-second: Time-related functions

K

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

L

lambda-expression: Extended Formal Arguments List
lazy: Delayed evaluation
lcm: Arithmetic operations
let: Local binding constructs
let*: Local binding constructs
let*-values: Multiple values
let-values: Multiple values
letrec: Local binding constructs
letrec*: Local binding constructs
letter: Identifiers
lexeme: Formal account
lexeme-datum: Datum syntax
library-reference: Requiring (importing) a module
line-ending: Whitespace and comments
list: Datum syntax list: Standard Types
list->f32vector: Uniform vectors
list->f64vector: Uniform vectors
list->integer: SRFI-60 Logical Number Operations
list->s16vector: Uniform vectors
list->s32vector: Uniform vectors
list->s64vector: Uniform vectors
list->s8vector: Uniform vectors
list->string: Basic string procedures
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
log2-binary-factors: SRFI-60 Logical Number Operations
logand: SRFI-60 Logical Number Operations
logbit?: SRFI-60 Logical Number Operations
logcount: SRFI-60 Logical Number Operations
logior: SRFI-60 Logical Number Operations
lognot: SRFI-60 Logical Number Operations
logop: Logical Number Operations
logtest: Logical Number Operations
logxor: SRFI-60 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-list: Lists
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: Basic string procedures
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
mnemonic-escape: Simple string literals
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

O

Object: Standard Types
object: Anonymous classes
object-field-decl: Anonymous classes
object-field-or-method-decl: Anonymous classes
object-init: Anonymous classes
oct-digit: Identifiers
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: Native exception handling
primitive-virtual-method: Low-level Method invocation
procedure: Standard Types
procedure-call: Procedure calls
procedure-property: Procedure properties
process-command-line-assignments: System inquiry
processing-instruction: Creating XML nodes
promise: Blank promises promise: Lazy and eager types
promise-set-alias!: Blank promises
promise-set-exception!: Blank promises
promise-set-thunk!: Blank promises
promise-set-value!: Blank promises
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 Units quantity: 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
raise: Exception handling
raise-continuable: Exception handling
rational: Standard Types
rational-valued?: Arithmetic operations
rationalize: Arithmetic operations
read: Input
read-bytevector: Input
read-bytevector!: Input
read-char: Input
read-error?: Exception handling
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!: SRFI-1 list library
reverse-bit-field: SRFI-60 Logical Number Operations
rotate-bit-field: SRFI-60 Logical Number Operations
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 topics
scheme-report-environment: Eval and Environments
scheme-window: Miscellaneous topics
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
shebang-comment: Whitespace and comments
sin: Arithmetic operations
sleep: Time-related functions
slot-ref: Using field and static-field methods
slot-set!: Using field and static-field methods
special-escape: Multiline string literals
special-initial: Identifiers
special-subsequent: Identifiers
sqrt: Arithmetic operations
square: Arithmetic operations
statement: Bodies
static-field: Using field and static-field methods
string: Strings string: Basic string procedures string: Simple string literals string: Standard Types
String: Standard Types
string->keyword: Keywords
string->list: Basic string procedures
string->symbol: Simple symbols
string->utf8: Bytevectors
string->vector: Vectors
string-append: Basic string procedures
string-append!: Basic string procedures
string-capitalize!: Deprecated in-place case modification
string-ci-hash: Hash functions string-ci-hash: Hash functions
string-ci<=?: String Comparisons
string-ci<?: String Comparisons
string-ci=?: String Comparisons
string-ci>=?: String Comparisons
string-ci>?: String Comparisons
string-copy: Basic string procedures
string-copy!: Basic string procedures
string-cursor: String Cursor API
string-cursor-end: String Cursor API
string-cursor-for-each: String Cursor API
string-cursor-next: String Cursor API
string-cursor-prev: String Cursor API
string-cursor-ref: String Cursor API
string-cursor-start: String Cursor API
string-cursor<=?: String Cursor API
string-cursor<?: String Cursor API
string-cursor=?: String Cursor API
string-cursor>=?: String Cursor API
string-cursor>?: String Cursor API
string-downcase: String Conversions
string-downcase!: Deprecated in-place case modification
string-element: Simple string literals
string-fill!: Basic string procedures
string-foldcase: String Conversions
string-for-each: Basic string procedures
string-hash: Hash functions string-hash: Hash functions
string-length: Basic string procedures
string-literal-part: String templates
string-map: Basic string procedures
string-normalize-nfc: String Conversions
string-normalize-nfd: String Conversions
string-normalize-nfkc: String Conversions
string-normalize-nfkd: String Conversions
string-ref: Basic string procedures
string-replace!: Basic string procedures
string-set!: Basic string procedures
string-titlecase: String Conversions
string-upcase: String Conversions
string-upcase!: Deprecated in-place case modification
string<=?: String Comparisons
string<?: String Comparisons
string=?: String Comparisons
string>=?: String Comparisons
string>?: String Comparisons
string?: Basic string procedures
subsequent: Identifiers
substring: Basic string procedures
substring-cursor: String Cursor API
symbol: Datum syntax symbol: Compound symbols symbol: Standard Types
symbol->string: Simple symbols
symbol-element: Identifiers
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

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
utf8->string: Bytevectors

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: About