Index

#/

Primitive Exceptions, Input Parsing, Input Parsing, Output Printing

#/n n n

#/backspace

Input Parsing, Output Printing

#/linefeed

#/newline

Input Parsing, Output Printing

#/nul

Strings, Input Parsing, Output Printing

#/null

Input Parsing, Output Printing

#/page

#/return

#/rubout

#/space

#/tab

#<>

#<undefined>

#<void>

#"

#n=

#n#

#n=

#n#

#%

#`

'append

'auto-else

'binary

'call/cc"

'call/cc=call/ec

'case-insensitive

'case-sensitive

'constants

'error

'execute

'keywords

'macos

'no-auto-else

'no-constants

'no-keywords

'no-set"

'read

'replace

'set"

'text

'truncate

'unix

'windows

'write

+inf.0

+nan.0

-help

-inf.0

-nan.0

.zo

/

<regexp>

add1

andmap

angle

append"

arity

arity-at-least

arity-at-least-value

arity-at-least?

banner

begin

begin-expansion-time

begin0

bignum

bitwise operators

bitwise-and

bitwise-ior

bitwise-not

bitwise-xor

box

box?

boxes

break-enabled

call-with-current-continuation

call-with-escaping-continuation

call-with-input-file

Opening File Ports, Opening File Ports, Primitive Exceptions

call-with-output-file

call-with-values

Multiple Return Values

call/cc

call/ec

Cond and Case, Global Variable Namespaces, Global Variable Namespaces, Primitive Exceptions

case

case sensitivity

case-lambda

catch

char->integer

char-ci=?

char-ready?

Semaphores, Primitive Exceptions

char=?

Characters

characters

Characters, Input Parsing

printing: Output Printing

class

Creating Classes

class*

Creating Classes, Primitive Exceptions

class?

classes

creating: Creating Classes

collect-garbage

communication

Expansion Time Binding and , Compilation

compile

Compilation

compile-file

compiling

Compilation

complex

compound-unit

Global Variable Namespaces, Global Variable Namespaces, Primitive Exceptions

cond

constant names

constant-name

constant-name-all-globals

continuations

escaping: Continuations

control flow

Directories, Primitive Exceptions

current-directory

current-error-port

Current Ports

current-eval

Evaluation Handler

current-exception-handler

Exceptions

current-input-port

Current Ports

current-load

Load Handler

current-milliseconds

Miscellaneous Extensions, Miscellaneous Extensions, Miscellaneous Extensions

current-output-port

Current Ports

current-print

Print Handler

current-prompt-read

Prompt Read Handler

current-seconds

current-thread

cycles

Graphs

date

day

Global Variable Namespaces, Debug Info Handler

debug info handlers

debug-info-handler

Debug Info Handler

define

Primitive Exceptions, Constant Names

embedded: Let

define-expansion-time

define-id-macro

Identifier Macros

define-macro

Defining Macros, Compilation

define-struct

Structures

defined?

delete-directory

delete-file

derived class

directory-exists?

Directories, Primitive Exceptions

directory-list

display

dst?

Miscellaneous Extensions, Miscellaneous Extensions

dynamic-enable-break

User Breaks

dynamic-wind

Dynamic Wind

environment variables

eq?

equal?

eqv?

error

error display handlers

Global Variable Namespaces, Error Display Handler

error escape handlers

Threads, Error Escape Handler

error-display-handler

Error Display Handler

error-escape-handler

Error Escape Handler

error-print-width

Evaluation Handler, Evaluation Handler

errors

Primitive Exceptions, Errors

eval

eval-when

Global Variable Namespaces, Evaluation Handler

evaluation handlers

evaluation order

Evaluation Order

event loop

exception handlers

Threads

exceptions

Exceptions

primitive: Primitive Exceptions

execute

execute*

Exit Handlers, Miscellaneous Extensions

exit

exit handlers

Global Variable Namespaces, Exit Handlers

exit-handler

Exit Handlers

exiting

Exit Handlers

exn

Primitive Exceptions, Debug Info Handler

exn:application:arity

Primitive Exceptions, Multiple Return Values

exn:application:fprintf:extra-arguments

exn:application:fprintf:no-argument

exn:application:mode-conflict

exn:application:range:struct

Global Variable Namespaces, Expanding Macros

exn:application:type

Numbers, Characters, Strings, Vectors, Global Variable Namespaces, String Ports, File Ports, Miscellaneous Extensions

exn:cond

Cond and Case, Cond and Case

exn:else

exn:i/o:filesystem:directory

exn:i/o:filesystem:filename

exn:i/o:user-port

Custom Ports

exn:misc:constant

exn:misc:continuation

Defining Macros, Defining Macros

exn:misc:defmacro

exn:misc:expansion-time

Expansion Time Binding and , Expansion Time Binding and

exn:misc:hash-table

exn:misc:process

exn:misc:unsupported

exn:misc:user-break

User Breaks

exn:obj:class

Generic Procedures

exn:object:class-ivar

Generic Procedures

exn:object:inherit

exn:object:init:multi

Creating Objects

exn:object:init:never

Creating Objects

exn:object:ivar

Instance Variable Access

exn:read:char

exn:read:unsupported

Input Parsing, Graphs

exn:read:vector-length

exn:struct:super-type

Structures

exn:unit:arity

exn:unit:export

exn:unit:import

exn:unit:non-unit

exn:user

Errors

exn:variable

expand-defmacro

Expanding Macros

expand-defmacro-once

Expanding Macros

expand-path

expansion time

expansion-time-value?

expressions

shared structure: Graphs

file-exists?

Files, Miscellaneous Extensions, Miscellaneous Extensions

file-modify-seconds

file-or-directory-permissions

file-position

File Ports

files

File Ports

filesystem-root-list

find-executable-path

fixnum

flonum

fluid-let

flush-output

File Ports

for-each

format

fprintf

garbage collection

gensym

getenv

global variables

Defining Macros, Identifier Macros, Expansion Time Binding and , Global Names, Miscellaneous Extensions

global-defined-value

graphs

Input Parsing, Graphs

printing: Output Printing

hash tables

hash-table-for-each

hash-table-get

hash-table-map

hash-table-put"

hash-table-remove"

hash-table?

hour

id-macro?

infinity

inherit

inheritance

input-port-post-semaphore

instance variables

accessibility: Instance Variables
accessing: Instance Variable Access
declaring: Instance Variables

integer->char

Characters, Characters

invoke-open-unit

Invoking Units

invoke-unit

Invoking Units

is-a?

ivar

Instance Variable Access

ivar-in-class?

keyword-name

keywords

kill-thread

let

Let

let*

Let

let-expansion-time

Identifier Macros, Identifier Macros

let-id-macro

let-macro

Defining Macros

let-struct

Structures

let-values

Multiple Return Values

let/cc

let/ec

Primitive Exceptions, Load Handler, Compilation, Miscellaneous Extensions

letrec

Void and Undefined, Let

letrec*

Void and Undefined, Let

libraries

list*

list-ref

list-tail

load

Input Parsing, Evaluation Handler, Evaluation Handler, Load Handler, Load Handler, Compilation

load handlers

Load Handler

load-extension

Dynamic Extensions

load-with-cd

load/cd

Compilation, Miscellaneous Extensions

local

local-expansion-time-value

logical operators

seebitwise operators

macro?

Defining Macros

macros

Defining Macros, Compilation

expanding: Expanding Macros
identifier: Identifier Macros

make-directory

make-eval

Generic Procedures, Primitive Exceptions

make-generic

make-global-value-list

make-hash-table

make-make-semaphore

Initialization Variables, Creating Objects

make-object

make-string

Strings

make-vector

Vectors

make-weak-box

Weak Boxes

minute

modulo

month

MzLib library

MzLib Library

MzScheme

stand-alone: This Manual

names

constant: Constant Names

namespaces

normal-case-path

not-a-number

number->string

numbers

object-class

object?

objects

creating: Creating Objects

open-input-file

Opening File Ports, Opening File Ports, Primitive Exceptions

open-input-string

String Ports

open-output-file

open-output-string

String Ports

ormap

overriding

pathnames

expansion: Pathnames

pattern matching

pipe

Pipes

ports

Threads, Global Variable Namespaces, Semaphores, Ports

custom: Custom Ports
file: File Ports
flushing: File Ports
string: String Ports

primitive-name

primitive?

print handlers

print-box

print-graph

print-struct

printf

printing

private

procedure?

Dispatching

process

process*

processes

promise?

prompt read handlers

Prompt Read Handler

public

putenv

quotient

raise

Exceptions

random

random-seed

rational

Global Variable Namespaces, Global Variable Namespaces, Primitive Exceptions

read

read-accept-bar-quote

read-accept-box

read-accept-compiled

Compilation

read-accept-graph

Graphs

read-accept-type-symbol

Evaluation Handler, Evaluation Handler, Print Handler, Print Handler, Prompt Read Handler, Prompt Read Handler, Miscellaneous Extensions

read-eval-print-loop

read-line

regexp

regexp-match

regexp-match-positions

regexp-replace

regexp?

regular expressions

relative-path?

remainder

rename

rename-file

require-library

MzLib Library

resolve-path

reverse"

second

Miscellaneous Extensions, Miscellaneous Extensions

seconds->date

secure-primitive-exception-types

semaphore-callback

semaphore-post

semaphore-try-wait?

semaphore-wait

semaphore?

semaphores

send

Instance Variable Access

sequence

set

set-box"

set-thread-weight"

set"

share

sleep

split-path

string->symbol

string->uninterned-symbol

string-ci=?

Strings

string-ref

string-set

string=?

Strings

strings

as ports: String Ports
pattern matching: Regular Expressions
reading to and writing from: String Ports

struct->vector

struct-length

struct-ref

struct-setter-procedure?

struct-type?

struct?

structures

printing: Output Printing

sub1

subclass?

subprocesses

substring

Creating Objects, Primitive Exceptions, Primitive Exceptions

super

Initial Values

super-init

superclasses

symbols

generating: Miscellaneous Extensions
printing: Output Printing

syntax?

system

system*

system-type

tail calls

thread

Threads

thread descriptor

thread-weight

thread?

threads

communication: Semaphores
synchronization: Semaphores

time

time-apply

type-symbol?

type;tex2html_html_special_mark_quot;symbols

Primitive Exceptions, Global Names

unbox

Boxes

undefine

undefined values

Void and Undefined

uninterned symbols

unit

Creating Units

unit?

units

Units

compound: Creating Compound Units
creating: Creating Units
invoking: Invoking Units

unless

Instance Variable Access, Primitive Exceptions

uq-ivar

uq-make-generic

Generic Procedures

user break polling handlers

Global Variable Namespaces, User Breaks

user-break-poll-handler

User Breaks

values

Multiple Return Values

vector-ref

vector-set

vectors

version

void

Void and Undefined

weak-box-value

Weak Boxes

weak-box?

Weak Boxes

week-day

when

with-input-from-file

Opening File Ports, Opening File Ports, Primitive Exceptions

with-output-to-file

write

year

year-day