Index

Symbols

!: Definitions
#!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
&D[: Coordinates - points and dimensions
&P[: Coordinates - points and dimensions
*: Arithmetic operations*: Quaternions
*print-base*: Miscellaneous
*print-miser-width*: Miscellaneous
*print-radix*: Miscellaneous
*print-right-margin*: Miscellaneous
*print-xml-indent*: Miscellaneous
+: Arithmetic operations+: Quaternions
-: Arithmetic operations-: Quaternions
--no-warn-whatever: Options for warnings and errors
--output-format: Options for controlling output formatting
--warn-whatever: Options for warnings and errors
->image: Images
->paint: Colors and paints
->shape: Array shape
/: Arithmetic operations/: Quaternions
?: Conditionals
~$: 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

A

abbrev-prefix: Abbreviations
abbreviation: Abbreviations
abs: Arithmetic operations
acos: Arithmetic operationsacos: Quaternions
acosh: Arithmetic operations
affine-transform: Affine transforms
alist->hash-table: Type constructors and predicate
alternate: Conditionals
and: Conditionals
angle: Quaternions
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: Apply procedures
arglist: Explicit argument list objects
arglist-arg-count: Argument list library
arglist-arg-ref: Argument list library
arglist-key-count: Argument list library
arglist-key-index: Argument list library
arglist-key-ref: Argument list library
arglist-key-start: Argument list library
arglist-key-value: Argument list library
arglist-walk: Argument list library
argvector: Explicit argument list objects
arithmetic-shift: SRFI-60 Logical Number Operations
array: Array typesarray: Array construction
array->vector: Transformations and views
array-bound: Array literals and printing
array-copy!: Modifying arrays
array-end: Array shape
array-fill!: Modifying arrays
array-flatten: Transformations and views
array-index-ref: Array indexing
array-index-share: Transformations and views
array-literal: Array literals and printing
array-literal-header: Array literals and printing
array-rank: Array shape
array-ref: Array indexing
array-reshape: Transformations and views
array-set!: Modifying arrays
array-shape: Array shape
array-size: Array shape
array-start: Array shape
array-transform: Transformations and views
array?: Multi-dimensional Arrays
arrayN: Array types
arrayN[etype]: Array types
array[etype]: Array types
as: Type tests and conversions
as-xml: Formatting XML
ash: SRFI-60 Logical Number Operations
asin: Arithmetic operationsasin: Quaternions
asinh: Arithmetic operations
atan: Arithmetic operationsatan: Quaternions
atanh: 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: Programs and Bodies
boolean: Boolean values
boolean=?: Boolean values
boolean?: Boolean values
booleans->integer: SRFI-60 Logical Number Operations
border: Combining pictures
bound-identifier=?: Identifier predicates
bounded-range: Ranges
build-array: Array construction
byte: Numerical types
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: Characterscharacter: Standard Types
character-except-x: Identifiers
character-or-eof: Characters
child-value: Allocating objects
circle: Shapes
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
coding specifier: Programs and Bodies
colatitude: The (kawa quaternions) module
colon notation: Property access using colon notation
command-line: System inquiry
command-line-arguments: System inquiry
command-parse: Deprecated functions
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: Numerical types
complex-part: The (kawa quaternions) module
compound-datum: Datum syntax
cond: Conditionals
cond-clause: Conditionals
cond-expand: Syntax and conditional compilation
cond-expand-clause: Syntax and conditional compilation
configure options: Build Kawa using configure and make
conjugate: The (kawa quaternions) module
consequent: Conditionals
constant: Literal expressions
constant-fold: Apply 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 operationscos: Quaternions
cosh: Arithmetic operations
create-directory: File System Interface
cross-product: The (kawa quaternions) module
current-activity: Android view construction
current-error-port: Ports
current-input-port: Ports
current-jiffy: Time-related functions
current-output-port: Ports
current-path: Paths - file name, URLs, and URIs
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: Partial application
cute: Partial application

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: Prompts for interactive consoles (REPLs)
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-library: R7RS explicit library modules
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-values: Multiple values
define-variable: Definitions
define-xml-namespace: Namespace aliases
defined-datum: Datum labels
defining-datum: Datum labels
defmacro: Macros
deg: Quantities and Units
delay: Delayed evaluation
delay-force: 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
Dimension: Coordinates - points and dimensions
disassemble: Debugging
display: Output
div: Arithmetic operations
div-and-mod: Arithmetic operations
div0: Arithmetic operations
div0-and-mod0: Arithmetic operations
domterm-load-stylesheet: Using DomTerm
dot-product: The (kawa quaternions) module
double: Numerical types
draw: Stroking (outlining) a shape
dynamic: Standard Types
dynamic-wind: Exception handling

E

eager: Delayed evaluation
element-name: Creating XML nodes
ellipsis: Pattern language
emergency-exit: Exiting the current process
enclosed-modifier: Formatting
enclosed-part: Embedded expressions
encoding specifier: Programs and Bodies
entity-ref: Special characters
environment: Eval and Environments
environment-bound?: Eval and Environments
environment-fold: 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
euler-xyx: Rotation Representation Conversions
euler-xzx: Rotation Representation Conversions
euler-yxy: Rotation Representation Conversions
euler-yzy: Rotation Representation Conversions
euler-zxz: Rotation Representation Conversions
euler-zyz: Rotation Representation Conversions
eval: Eval and Environments
exact complex number: Exactness
exact-integer-sqrt: Arithmetic operations
exact-integer?: Arithmetic operations
exactness: Exactness
exit: Exiting the current process
exp: Arithmetic operationsexp: Quaternions
expand: Macros
explicit-source-name: Importing from a library
exponent-marker: Numbers
export: Name visibility
export-spec: Name visibility
expression: Primitive expression syntax
expt: Arithmetic operationsexpt: Quaternions
extended-datum-literal: Named quasi-literals
extended-string-literal: String templates
extrinsic-xyx: Rotation Representation Conversions
extrinsic-xyz: Rotation Representation Conversions
extrinsic-xzx: Rotation Representation Conversions
extrinsic-yxy: Rotation Representation Conversions
extrinsic-yxz: Rotation Representation Conversions
extrinsic-yzx: Rotation Representation Conversions
extrinsic-yzy: Rotation Representation Conversions
extrinsic-zxy: Rotation Representation Conversions
extrinsic-zxz: Rotation Representation Conversions
extrinsic-zyx: Rotation Representation Conversions
extrinsic-zyz: Rotation Representation Conversions

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
fill: Filling a shape with a color
finite?: Arithmetic operations
first-set-bit: SRFI-60 Logical Number Operations
float: Numerical types
floor: Arithmetic operations
floor-quotient: Arithmetic operations
floor-remainder: Arithmetic operations
floor/: Arithmetic operations
fluid-let: Eval and Environments
flush-output-port: Output
for-each: Mapping functions
force: Delayed evaluationforce: Threads
force*: Delayed evaluation
force-output: Output
formal-arguments: Lambda Expressions and Formal Parameters
formals: Lambda Expressions and Formal Parameters
format: Formatted Output (Common-Lisp-style)
format-array: Array literals and printingformat-array: Miscellaneous
free-identifier=?: Identifier predicates
future: Threads

G

gcd: Arithmetic operations
gentemp: Macros
get-environment-variable: System inquiry
get-environment-variables: System inquiry
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
grad: Quantities and Units
guard: Patternsguard: Exception handling

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
hbox: Combining pictures
hex-digit: Identifiers
hex-scalar-value: Identifiers
home-directory: System inquiry
html:tag: Creating HTML nodes

I

identifier: Identifiers
identifier?: Identifier predicates
if: Conditionals
imag-part: Quaternions
image: Images
image-height: Images
image-read: Images
image-width: Images
image-write: Images
import: Importing from a library
import-only-name: Importing from a library
import-set: Importing from a library
include: Syntax and conditional compilation
include-ci: Syntax and conditional compilation
include-relative: Syntax and conditional compilation
index-array: Array construction
indexnum: Datum labels
inexact complex number: Exactness
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: Prompts for interactive consoles (REPLs)
input-port-read-state: Line numbers and other input port properties
input-port?: Ports
input-prompt1: Prompts for interactive consoles (REPLs)
input-prompt2: Prompts for interactive consoles (REPLs)
instance?: Type tests and conversions
int: Numerical types
integer: Numerical 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
intrinsic-xyx: Rotation Representation Conversions
intrinsic-xyz: Rotation Representation Conversions
intrinsic-xzx: Rotation Representation Conversions
intrinsic-xzy: Rotation Representation Conversions
intrinsic-yxy: Rotation Representation Conversions
intrinsic-yxz: Rotation Representation Conversions
intrinsic-yzx: Rotation Representation Conversions
intrinsic-yzy: Rotation Representation Conversions
intrinsic-zxy: Rotation Representation Conversions
intrinsic-zxz: Rotation Representation Conversions
intrinsic-zyx: Rotation Representation Conversions
intrinsic-zyz: Rotation Representation Conversions
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
istring: Strings
istring?: Basic string procedures

J

JavaFX: Building JavaFX applications
jiffies-per-second: Time-related functions
jmag-part: The (kawa quaternions) module

K

kawa-abbreviation: Abbreviations
kawac: Compiling using Ant
key-arg: Lambda Expressions and Formal Parameters
keyword: Keywordskeyword: Standard Types
keyword->string: Keywords
keyword?: Keywords
kmag-part: The (kawa quaternions) module

L

lambda-expression: Lambda Expressions and Formal Parameters
lazy: Delayed evaluation
lcm: Arithmetic operations
length: Sequences
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-declaration: R7RS explicit library modules
library-definition: R7RS explicit library modules
library-name: R7RS explicit library modules
library-name-parts: R7RS explicit library modules
library-reference: Importing from a library
line: Shapes
line-ending: Whitespace and comments
list: Datum syntaxlist: 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: Conversions
list->u16vector: Uniform vectors
list->u32vector: Uniform vectors
list->u64vector: Uniform vectors
list->u8vector: Uniform vectors
list->vector: Vectors
list-pattern: Pattern language
literal-expression: Literal expressions
load: Eval and Environments
load-relative: Eval and Environments
location: Locations
log: Arithmetic operationslog: Quaternions
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
long: Numerical types
longitude: The (kawa quaternions) module
lpattern: Patterns

M

magnitude: Quaternions
make: Allocating objects
make-array: Array construction
make-attribute: Creating XML nodes
make-axis/angle: Rotation Representation Conversions
make-bytevector: Bytevectors
make-element: Creating XML nodes
make-eq-hashtable: R6RS hash tables
make-eqv-hashtable: R6RS hash tables
make-euler-xyx: Rotation Representation Conversions
make-euler-xzx: Rotation Representation Conversions
make-euler-yxy: Rotation Representation Conversions
make-euler-yzy: Rotation Representation Conversions
make-euler-zxz: Rotation Representation Conversions
make-euler-zyz: Rotation Representation Conversions
make-extrinsic-xyx: Rotation Representation Conversions
make-extrinsic-xyz: Rotation Representation Conversions
make-extrinsic-xzx: Rotation Representation Conversions
make-extrinsic-xzy: Rotation Representation Conversions
make-extrinsic-yxy: Rotation Representation Conversions
make-extrinsic-yxz: Rotation Representation Conversions
make-extrinsic-yzx: Rotation Representation Conversions
make-extrinsic-yzy: Rotation Representation Conversions
make-extrinsic-zxy: Rotation Representation Conversions
make-extrinsic-zxz: Rotation Representation Conversions
make-extrinsic-zyx: Rotation Representation Conversions
make-extrinsic-zyz: Rotation Representation Conversions
make-f32vector: Uniform vectors
make-f64vector: Uniform vectors
make-hash-table: Type constructors and predicate
make-hashtable: R6RS hash tables
make-intrinsic-xyx: Rotation Representation Conversions
make-intrinsic-xyz: Rotation Representation Conversions
make-intrinsic-xzx: Rotation Representation Conversions
make-intrinsic-xzy: Rotation Representation Conversions
make-intrinsic-yxy: Rotation Representation Conversions
make-intrinsic-yxz: Rotation Representation Conversions
make-intrinsic-yzx: Rotation Representation Conversions
make-intrinsic-yzy: Rotation Representation Conversions
make-intrinsic-zxy: Rotation Representation Conversions
make-intrinsic-zxz: Rotation Representation Conversions
make-intrinsic-zyx: Rotation Representation Conversions
make-intrinsic-zyz: Rotation Representation Conversions
make-list: Lists
make-parameter: Parameter objects
make-polar: Quaternions
make-procedure: Generic (dynamically overloaded) procedures
make-process: Deprecated functions
make-promise: Blank promises
make-quantity: Quantities and Units
make-record-type: Creating New Record Types On-the-fly
make-rectangular: Quaternions
make-rotation-procedure: Rotation Operations
make-rpy: Rotation Representation Conversions
make-s16vector: Uniform vectors
make-s32vector: Uniform vectors
make-s64vector: Uniform vectors
make-s8vector: Uniform vectors
make-string: String mutation
make-tait-bryan-xyz: Rotation Representation Conversions
make-tait-bryan-xzy: Rotation Representation Conversions
make-tait-bryan-yxz: Rotation Representation Conversions
make-tait-bryan-yzx: Rotation Representation Conversions
make-tait-bryan-zxy: Rotation Representation Conversions
make-tait-bryan-zyx: Rotation Representation Conversions
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
make-vector-quaternion: The (kawa quaternions) module
map: Mapping functions
match: Conditionals
match-clause: Conditionals
match-key: Conditionals
method-body: Declaring methods
method-decl: Declaring methods
method-name: Declaring methods
method-option: Declaring methods
mnemonic-escape: Simple string literals
mod: Arithmetic operations
mod0: Arithmetic operations
module-class: Resources
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
mstring: Strings
multi-escape-sequence: Identifiers

N

named-literal-part: Named quasi-literals
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
not: Conditionals
null-environment: Eval and Environments
number: Numbersnumber: Numerical types
number->string: Numerical input and output
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
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-return-type: Lambda Expressions and Formal Parameters
opt-type-specifier: Types
option-pair: Defining new classes
optional-arg: Lambda Expressions and Formal Parameters
optional-exponent: Numbers
optional-sign: Numbers
options: Command-line arguments
or: Conditionals
output-port: Standard Types
output-port-open?: Ports
output-port?: Ports

P

padding: Combining pictures
pair: Standard Types
parameter: 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-bytes: Functions
path-data: Functions
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
pattern: Patterns
pattern-literal: Patterns
peculiar-identifier: Identifiers
peek-char: Input
peek-u8: Input
picture->jpanel: Display in Swing
picture->svg-node: Export to SVG
picture-write-svg: Export to SVG
pipe-process: Pipe-lines
Point: Coordinates - points and dimensions
polygon: Shapes
port-char-encoding: Miscellaneous
port-column: Line numbers and other input port properties
port-line: Line numbers and other input port properties
port?: Ports
pprint: Pretty-printing Scheme forms
pprint-end-logical-block: Generic pretty-printing functions
pprint-ident: Generic pretty-printing functions
pprint-logical-block: Generic pretty-printing functions
pprint-newline: Generic pretty-printing functions
pprint-start-logical-block: Generic pretty-printing functions
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
process-exit-ok?: Waiting for process exit
process-exit-wait: Waiting for process exit
process-keyword-argument: Creating a process
processing-instruction: Creating XML nodes
program-unit: Programs and Bodies
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
prompts: Output
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: Importing from a library

Q

QName: QNames and namespaces
quantity: Numerical typesquantity: Quantities and Units
quantity->number: Quantities and Units
quantity->unit: Quantities and Units
quantity?: Quantities and Units
quasisyntax: Convenience forms
quaternion: The (kawa quaternions) module
quaternion->rotation-matrix: Rotation Representation Conversions
quaternion?: The (kawa quaternions) module
quot-attribute-datum: Attributes
quotient: Arithmetic operations

R

r6rs-abbreviation: Abbreviations
rad: Quantities and Units
raise: Exception handling
raise-continuable: Exception handling
range-end: Ranges
rational: Numerical types
rational-valued?: Arithmetic operations
rationalize: Arithmetic operations
re-center: Combining pictures
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: Numerical types
real-part: Quaternions
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
rectangle: Shapes
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
rename-pair: Importing from a library
repeat expression: Repeat patterns and expressions
repeat pattern: Repeat patterns and expressions
repeat variable: Repeat patterns and expressions
report-syntax-error: Signaling errors in macro transformers
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: Importing from a library
required-arg: Lambda Expressions and Formal Parameters
required-or-guard: Lambda Expressions and Formal Parameters
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: Lambda Expressions and Formal Parameters
rest-key-args: Lambda Expressions and Formal Parameters
rest-parameter: Lambda Expressions and Formal Parameters
reverse!: SRFI-1 list library
reverse-bit-field: SRFI-60 Logical Number Operations
reverse-list->string: Conversions
rotate: Affine transforms
rotate-bit-field: SRFI-60 Logical Number Operations
rotate-vector: Rotation Operations
rotation-angle: Rotation Representation Conversions
rotation-axis: Rotation Representation Conversions
rotation-axis/angle: Rotation Representation Conversions
rotation-matrix->quaternion: Rotation Representation Conversions
rotx: Rotation Representation Conversions
roty: Rotation Representation Conversions
rotz: Rotation Representation Conversions
round: Arithmetic operations
rpy: Rotation Representation Conversions
run-process: Creating a process
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
scale: Affine transforms
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-frame-size!: Display in Swing
set-input-port-line-number!: Line numbers and other input port properties
set-input-port-prompter!: Prompts for interactive consoles (REPLs)
set-port-line!: Line numbers and other input port properties
set-procedure-property!: Procedure properties
setter: Locations
shape: Array shape
share-array: Transformations and views
shebang-comment: Whitespace and comments
short: Numerical types
show-picture: Display in Swing
sin: Arithmetic operationssin: Quaternions
sinh: 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 operationssqrt: Quaternions
square: Arithmetic operations
statement: Programs and Bodies
statements: Programs and Bodies
static-field: Using field and static-field methods
string: Stringsstring: Basic string proceduresstring: Simple string literalsstring: Standard Types
String: Standard Types
string->keyword: Keywords
string->list: Conversions
string->number: Numerical input and output
string->symbol: Simple symbols
string->utf16: Converting to or from strings
string->utf16be: Converting to or from strings
string->utf16le: Converting to or from strings
string->utf8: Converting to or from strings
string->vector: Conversions
string-any: Basic string procedures
string-append: Concatenation and replacing
string-append!: String mutation
string-capitalize!: Deprecated in-place case modification
string-ci-hash: Hash functionsstring-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-concatenate: Concatenation and replacing
string-concatenate-reverse: Concatenation and replacing
string-contains: Searching and matching
string-contains-right: Searching and matching
string-copy: String mutation
string-copy!: String mutation
string-count: Mapping and folding
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-next-quiet: 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: Conversions
string-downcase!: Deprecated in-place case modification
string-drop: Selection
string-drop-right: Selection
string-element: Simple string literals
string-every: Basic string procedures
string-fill!: String mutation
string-filter: Mapping and folding
string-fold: Mapping and folding
string-fold-right: Mapping and folding
string-foldcase: Conversions
string-for-each: Mapping and folding
string-for-each-index: Mapping and folding
string-hash: Hash functionsstring-hash: Hash functions
string-index: Searching and matching
string-index-right: Searching and matching
string-join: Concatenation and replacing
string-length: Basic string procedures
string-literal-part: String templates
string-map: Mapping and folding
string-map-index: Mapping and folding
string-normalize-nfc: Conversions
string-normalize-nfd: Conversions
string-normalize-nfkc: Conversions
string-normalize-nfkd: Conversions
string-null?: Basic string procedures
string-pad: Selection
string-pad-right: Selection
string-prefix-length: Searching and matching
string-prefix?: Searching and matching
string-ref: Basic string procedures
string-remove: Mapping and folding
string-repeat: Replication & splitting
string-replace: Concatenation and replacing
string-replace!: String mutation
string-set!: String mutation
string-skip: Searching and matching
string-skip-right: Searching and matching
string-split: Replication & splitting
string-suffix-length: Searching and matching
string-suffix?: Searching and matching
string-tabulate: Immutable String Constructors
string-take: Selection
string-take-right: Selection
string-titlecase: Conversions
string-trim: Selection
string-trim-both: Selection
string-trim-right: Selection
string-unfold: Immutable String Constructors
string-unfold-right: Immutable String Constructors
string-upcase: 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: Selection
substring-cursor: String Cursor API
supplied-var: Lambda Expressions and Formal Parameters
symbol: Datum syntaxsymbol: Compound symbolssymbol: 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
syntax->datum: Syntax-object and datum conversions
syntax-error: Signaling errors in macro transformers
syntax-object->datum: Syntax-object and datum conversions
syntax-pattern: Pattern language
syntax-rule: Pattern language
syntax-template: Pattern language
system: Deprecated functions
system-tmpdir: File System Interface

T

tait-bryan-xyz: Rotation Representation Conversions
tait-bryan-xzy: Rotation Representation Conversions
tait-bryan-yxz: Rotation Representation Conversions
tait-bryan-yzx: Rotation Representation Conversions
tait-bryan-zxy: Rotation Representation Conversions
tait-bryan-zyx: Rotation Representation Conversions
tan: Arithmetic operationstan: Quaternions
tanh: Arithmetic operations
template-element: Pattern language
test-expression: Boolean values
test-or-match: Conditionals
textual-port?: Ports
this: Object, Classes and Modules
throw: Named exceptions
tokenize-string-to-string-array: Deprecated functions
Tomcat: Installing a servlet under Tomcat
tr-literal: Pattern language
trace: Debugging
transformer-spec: Pattern language
translate: Affine transforms
truncate: Arithmetic operations
truncate-quotient: Arithmetic operations
truncate-remainder: Arithmetic operations
truncate/: Arithmetic operations
try-catch: Native exception handling
try-finally: Native 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
ubyte: Numerical types
uint: Numerical types
ulong: Numerical types
unbounded-range: Ranges
unescaped-data: Formatting XML
uniform-tag: Uniform vectors
uniform-vector: Uniform vectors
unit-name: Quantities and Units
unit-quaternion: The (kawa quaternions) module
unit-term: Quantities and Units
unit-vector: The (kawa quaternions) module
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
ushort: Numerical types
utf16->string: Converting to or from strings
utf16be->string: Converting to or from strings
utf16le->string: Converting to or from strings
utf8->string: Converting to or from strings

V

values: Multiple values
values-append: Multiple values
variable-reference: Variable references
vbox: Combining pictures
vectag: Array literals and printing
vector: Datum syntaxvector: Vectorsvector: Standard Types
vector->list: Vectors
vector->string: Conversions
vector-append: Vectors
vector-copy: Vectors
vector-copy!: Vectors
vector-fill!: Vectors
vector-for-each: Mapping functions
vector-length: Vectors
vector-map: Mapping functions
vector-part: The (kawa quaternions) module
vector-pattern: Pattern language
vector-quaternion->list: The (kawa quaternions) module
vector-quaternion?: The (kawa quaternions) module
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-uninitialized: Options for warnings and errors
warn-unknown-member: Options for warnings and errors
warn-unreachable: Options for warnings and errors
warn-unused: Options for warnings and errors
warn-void-used: Options for warnings and errors
when: Conditionals
whitespace: Whitespace and comments
with-compile-options: Module options
with-composite: Compositing - Controlling how pictures are combined
with-exception-handler: Exception handling
with-input-from-file: Ports
with-output-to-file: Ports
with-paint: Colors and paints
with-syntax: Convenience forms
with-transform: Affine transforms
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
xsubstring: Replication & splitting

Z

zbox: Combining pictures

Up: The Kawa Scheme language

Previous: Kawa Scheme Tutorial