Go to the previous section.

Index

!

  • ! in mutation procedure names

    "

  • "
  • " as external representation

    #

  • #
  • # as format parameter
  • # in external representation of number
  • #!optional
  • #!rest
  • #(
  • #( as external representation
  • #* as external representation
  • #[ as external representation
  • #\
  • #\ as external representation
  • #\altmode
  • #\backnext
  • #\backspace
  • #\call
  • #\linefeed
  • #\newline
  • #\page
  • #\return
  • #\rubout
  • #\space
  • #\tab
  • #b
  • #b as external representation
  • #d
  • #d as external representation
  • #e
  • #e as external representation
  • #f
  • #f as external representation
  • #f, as pathname component
  • #i
  • #i as external representation
  • #o
  • #o as external representation
  • #t
  • #t as external representation
  • #x
  • #x as external representation
  • #| as external representation

    %

  • %delete-dib

    '

  • '
  • ' as external representation

    (

  • (
  • ( as external representation
  • ()

    )

  • )
  • ) as external representation

    *

  • *
  • *default-pathname-defaults*
  • *random-state*
  • *unparse-with-maximum-readability?*
  • *unparser-list-breadth-limit*
  • *unparser-list-depth-limit*
  • *unparser-radix*
  • *unparser-string-length-limit*

    +

  • +
  • + in entries

    ,

  • ,
  • , as external representation
  • ,@
  • ,@ as external representation

    -

  • -
  • -1+
  • ->namestring
  • ->pathname
  • ->truename
  • -ci, in string procedure name
  • -| notational convention

    .

  • .
  • . as external representation
  • ... in entries

    /

  • /

    1

  • 1+
  • 1D table (defn)
  • 1d-table/alist
  • 1d-table/get
  • 1d-table/lookup
  • 1d-table/put!
  • 1d-table/remove!
  • 1d-table?

    2

  • 2d-get
  • 2d-get-alist-x
  • 2d-get-alist-y
  • 2d-put!
  • 2d-remove!

    ;

  • ; as external representation

    <

  • <
  • <=

    =

  • =
  • =>
  • => in cond clause
  • => notational convention

    >

  • >
  • >=

    ?

  • ? in predicate names

    [

  • [ in entries

    \

  • \
  • \ as escape character in string
  • \f
  • \n
  • \t

    ]

  • ] in entries

    `

  • `
  • ` as external representation

    a

  • abs
  • absolute pathname (defn)
  • absolute value, of number
  • access
  • access time, of file
  • access, used with set!
  • acos
  • addition, of numbers
  • address hashing
  • alist (defn)
  • alist->rb-tree
  • alist->wt-tree
  • alist-copy
  • alist?
  • alphabetic case, of interned symbol
  • alphabetic case, of string
  • alphabetic case-insensitivity of programs (defn)
  • alphabetic character (defn)
  • alphanumeric character (defn)
  • and
  • angle
  • apostrophe, as external representation
  • append
  • append!
  • append-map
  • append-map!
  • append-map*
  • append-map*!
  • appending, of bit strings
  • appending, of lists
  • appending, of strings
  • appending, of symbols
  • appending, to output file
  • application hook (defn)
  • application, of procedure
  • apply
  • apply hook (defn)
  • apply-hook-extra
  • apply-hook-procedure
  • apply-hook?
  • argument evaluation order
  • ASCII character
  • ASCII character (defn)
  • ascii->char
  • ascii-range->char-set
  • asin
  • aspect, of graphics character (defn)
  • assignment
  • assoc
  • association list (defn)
  • association table (defn)
  • association-procedure
  • assq
  • assv
  • asterisk, as external representation
  • atan
  • attribute, of file

    b

  • backquote, as external representation
  • backslash, as escape character in string
  • balanced binary trees
  • beep
  • begin
  • bell, ringing on console
  • binary file ports
  • binary trees
  • binary trees, as discrete maps
  • binary trees, as sets
  • bind-cell-contents!
  • binding expression (defn)
  • binding expression, fluid (or dynamic)
  • binding expression, lexical
  • binding, of variable
  • bit string (defn)
  • bit string index (defn)
  • bit string length (defn)
  • bit-string->signed-integer
  • bit-string->unsigned-integer
  • bit-string-allocate
  • bit-string-and
  • bit-string-and!
  • bit-string-andc
  • bit-string-andc!
  • bit-string-append
  • bit-string-clear!
  • bit-string-copy
  • bit-string-fill!
  • bit-string-length
  • bit-string-move!
  • bit-string-movec!
  • bit-string-not
  • bit-string-or
  • bit-string-or!
  • bit-string-ref
  • bit-string-set!
  • bit-string-xor
  • bit-string-xor!
  • bit-string-zero?
  • bit-string=?
  • bit-string?
  • bit-substring
  • bit-substring-move-right!
  • bitmap-from-dib
  • bitmaps
  • bitmaps, graphics
  • bitwise-logical operations, on fixnums
  • block structure
  • blocking mode, of port
  • BOA constructor
  • BOA constructor (defn)
  • body, of special form (defn)
  • bool
  • boolean object
  • boolean object (defn)
  • boolean object, equivalence predicate
  • boolean/and
  • boolean/or
  • boolean=?
  • boolean?
  • bound variable (defn)
  • bracket, in entries
  • bucky bit, of character (defn)
  • bucky bit, prefix (defn)
  • buffering, of graphics output
  • buffering, of output
  • built-in procedure
  • byte
  • byte vector

    c

  • caaaar
  • caaadr
  • caaar
  • caadar
  • caaddr
  • caadr
  • caar
  • cadaar
  • cadadr
  • cadar
  • caddar
  • cadddr
  • caddr
  • cadr
  • call by need evaluation (defn)
  • call-with-binary-input-file
  • call-with-binary-output-file
  • call-with-current-continuation
  • call-with-input-file
  • call-with-output-file
  • call-with-temporary-filename
  • call-with-values
  • capitalization, of string
  • car
  • car field, of pair (defn)
  • case
  • case clause
  • case conversion, of character
  • case sensitivity, of string operations
  • case, of interned symbol
  • case, of string
  • case-insensitivity of programs (defn)
  • cd
  • cdaaar
  • cdaadr
  • cdaar
  • cdadar
  • cdaddr
  • cdadr
  • cdar
  • cddaar
  • cddadr
  • cddar
  • cdddar
  • cddddr
  • cdddr
  • cddr
  • cdr
  • cdr field, of pair (defn)
  • ceiling
  • ceiling->exact
  • cell (defn)
  • cell-contents
  • cell?
  • char
  • char*
  • char->ascii
  • char->digit
  • char->integer
  • char->name
  • char->string
  • char-alphabetic?
  • char-alphanumeric?
  • char-ascii?
  • char-bits
  • char-bits-limit
  • char-ci<=?
  • char-ci<?
  • char-ci=?
  • char-ci>=?
  • char-ci>?
  • char-code
  • char-code-limit
  • char-downcase
  • char-graphic?
  • char-integer-limit
  • char-lower-case?
  • char-numeric?
  • char-ready?
  • char-set
  • char-set-difference
  • char-set-intersection
  • char-set-invert
  • char-set-member?
  • char-set-members
  • char-set-union
  • char-set:alphabetic
  • char-set:alphanumeric
  • char-set:graphic
  • char-set:lower-case
  • char-set:not-graphic
  • char-set:not-whitespace
  • char-set:numeric
  • char-set:standard
  • char-set:upper-case
  • char-set:whitespace
  • char-set?
  • char-standard?
  • char-upcase
  • char-upper-case?
  • char-whitespace?
  • char<=?
  • char<?
  • char=?
  • char>=?
  • char>?
  • char?
  • character (defn)
  • character bits (defn)
  • character code (defn)
  • character set
  • character, alphabetic (defn)
  • character, alphanumeric (defn)
  • character, ASCII (defn)
  • character, graphic (defn)
  • character, input from port
  • character, named (defn)
  • character, numeric (defn)
  • character, output to port
  • character, searching string for
  • character, standard
  • character, standard (defn)
  • character, whitespace (defn)
  • characters, special, in programs
  • chars->char-set
  • child, of environment (defn)
  • circle, graphics
  • circular list
  • circular structure
  • circular-list
  • clause, of case expression
  • clause, of cond expression
  • clear
  • clearing the console screen
  • clip rectangle, graphics (defn)
  • clipping, of graphics
  • close-all-open-files
  • close-input-port
  • close-output-port
  • close-port
  • closing environment, of procedure (defn)
  • closing, of file port
  • closing, of port
  • code, of character (defn)
  • color
  • color-map-size
  • combination (defn)
  • comma, as external representation
  • comment, extended, in programs (defn)
  • comment, in programs (defn)
  • comparison, for equivalence
  • comparison, of bit strings
  • comparison, of boolean objects
  • comparison, of characters
  • comparison, of numbers
  • comparison, of strings
  • compiled, procedure type
  • compiled-procedure?
  • complex?
  • component selection, of bit string
  • component selection, of cell
  • component selection, of character
  • component selection, of list
  • component selection, of pair
  • component selection, of stream
  • component selection, of string
  • component selection, of vector
  • component selection, of weak pair
  • component, of pathname, literal
  • component, of pathname, missing
  • component, of pathname, unspecific
  • component, of pathname, wildcard
  • components, of pathname
  • compound procedure
  • compound-procedure?
  • conc-name
  • cond
  • cond clause
  • condition-type:bad-range-argument
  • condition-type:file-operation-error
  • condition-type:unassigned-variable
  • condition-type:unbound-variable
  • condition-type:wrong-number-of-arguments
  • condition-type:wrong-type-argument
  • conditional expression (defn)
  • conjugate
  • cons
  • cons*
  • cons-stream
  • console, clearing
  • console, port
  • console, ringing the bell
  • console-i/o-port
  • console-input-port
  • console-output-port
  • constant
  • constant expression (defn)
  • constant, and quasiquote
  • constant, and quote
  • construction, of bit string
  • construction, of cell
  • construction, of character
  • construction, of character set
  • construction, of circular list
  • construction, of continuation
  • construction, of environment
  • construction, of EOF object
  • construction, of file input port
  • construction, of file output port
  • construction, of hash table
  • construction, of list
  • construction, of pair
  • construction, of pathname
  • construction, of port
  • construction, of procedure
  • construction, of promise
  • construction, of stream
  • construction, of string
  • construction, of string input port
  • construction, of string output port
  • construction, of symbols
  • construction, of vector
  • construction, of weak pair
  • constructor
  • continuation
  • continuation, alternate invocation
  • continuation, and dynamic binding
  • continuation?
  • control, bucky bit prefix (defn)
  • conventions, lexical
  • conventions, naming
  • conventions, notational
  • conversion, pathname to string
  • cooked mode, of terminal port
  • coordinates, graphics
  • copier
  • copy-area
  • copy-bitmap
  • copy-file
  • copying, of alist
  • copying, of bit string
  • copying, of file
  • copying, of port
  • copying, of string
  • copying, of tree
  • copying, of vector
  • cos
  • create-dib
  • create-image
  • crop-bitmap
  • current environment (defn)
  • current input port (defn)
  • current input port, rebinding
  • current output port (defn)
  • current output port, rebinding
  • current working directory
  • current working directory (defn)
  • current-input-port
  • current-output-port
  • cursor, graphics (defn)
  • custom operations, on graphics device
  • custom operations, on port
  • cutting, of bit string
  • cutting, of list
  • cutting, of string
  • cutting, of vector

    d

  • d, as exponent marker in number
  • debug
  • default object (defn)
  • default-object?
  • defaulting, of pathname
  • define
  • define, procedure (defn)
  • define-color
  • define-similar-windows-type
  • define-structure
  • define-windows-type
  • defining foreign procedures
  • defining foreign types
  • definition
  • definition, internal
  • definition, internal (defn)
  • definition, top-level
  • definition, top-level (defn)
  • del-assoc
  • del-assoc!
  • del-assq
  • del-assq!
  • del-assv
  • del-assv!
  • delay
  • delete
  • delete!
  • delete-association-procedure
  • delete-dib
  • delete-file
  • delete-member-procedure
  • deletion, of alist element
  • deletion, of file
  • deletion, of list element
  • delimiter, in programs (defn)
  • delq
  • delq!
  • delv
  • delv!
  • denominator
  • device coordinates, graphics (defn)
  • device, pathname component
  • dib
  • dib-blt
  • dib-from-bitmap
  • dib-height
  • dib-set-pixels-unaligned
  • dib-width
  • difference, of numbers
  • digit->char
  • directive, format (defn)
  • directory path (defn)
  • directory, converting pathname to
  • directory, current working (defn)
  • directory, pathname component
  • directory, predicate for
  • directory, reading
  • directory-namestring
  • directory-pathname
  • directory-pathname-as-file
  • directory-read
  • discard-char
  • discard-chars
  • discrete maps, using binary trees
  • discretionary flushing, of buffered output
  • discretionary-flush-output
  • discretionary-output-flush
  • disembodied property list
  • display
  • display, clearing
  • display, X graphics
  • division, of integers
  • division, of numbers
  • DLL, DIBUTILS.DLL
  • DLL, exports
  • DLL, GDI32.DLL
  • DLL, KERNEL32.DLL
  • DLL, loading
  • DLL, USER32.DLL
  • do
  • dot, as external representation
  • dotted notation, for pair (defn)
  • dotted pair (see pair)
  • double precision, of inexact number
  • double quote, as external representation
  • draw-ellipse
  • draw-image
  • draw-subimage
  • drawing mode, graphics (defn)
  • dynamic binding
  • dynamic binding, and continuations
  • dynamic binding, versus static scoping
  • dynamic types (defn)
  • dynamic-wind

    e

  • e, as exponent marker in number
  • eighth
  • element, of list (defn)
  • ellipse, graphics
  • ellipsis, in entries
  • else
  • else clause, of case expression (defn)
  • else clause, of cond expression (defn)
  • empty list (defn)
  • empty list, external representation
  • empty list, predicate for
  • empty stream, predicate for
  • empty string, predicate for
  • empty-stream?
  • end of file object (see EOF object)
  • end, of substring (defn)
  • end, of subvector (defn)
  • enough-namestring
  • enough-pathname
  • entity (defn)
  • entity-extra
  • entity-procedure
  • entity?
  • entry format
  • enumerate-graphics-device-types
  • environment (defn)
  • environment, current (defn)
  • environment, extension (defn)
  • environment, initial (defn)
  • environment, of procedure
  • environment, procedure closing (defn)
  • environment, procedure invocation (defn)
  • environment-assign!
  • environment-assignable?
  • environment-bindings
  • environment-bound-names
  • environment-bound?
  • environment-has-parent?
  • environment-lookup
  • environment-parent
  • environment?
  • EOF object, construction
  • EOF object, predicate for
  • eof-object?
  • eq-hash
  • eq-hash-mod
  • eq?
  • equal-hash-mod
  • equal?
  • equivalence predicate (defn)
  • equivalence predicate, for bit strings
  • equivalence predicate, for boolean objects
  • equivalence predicate, for characters
  • equivalence predicate, for fixnums
  • equivalence predicate, for flonums
  • equivalence predicate, for numbers
  • equivalence predicate, for pathname host
  • equivalence predicate, for pathnames
  • equivalence predicate, for strings
  • equivalence predicate, of hash table
  • equivalence predicates, for characters
  • eqv-hash-mod
  • eqv?
  • error
  • error, in examples
  • error, unassigned variable
  • error, unbound variable (defn)
  • error--> notational convention
  • errors, notational conventions
  • escape character, for string
  • escape procedure (defn)
  • escape procedure, alternate invocation
  • eval
  • evaluation order, of arguments
  • evaluation, call by need (defn)
  • evaluation, in examples
  • evaluation, lazy (defn)
  • evaluation, of s-expression
  • even number
  • even?
  • exact->inexact
  • exact-integer?
  • exact-nonnegative-integer?
  • exact-rational?
  • exact?
  • exactness
  • examples
  • except-last-pair
  • except-last-pair!
  • existence, testing of file
  • exit, non-local
  • exp
  • exponent marker (defn)
  • expression (defn)
  • expression, binding (defn)
  • expression, conditional (defn)
  • expression, constant (defn)
  • expression, input from port
  • expression, iteration (defn)
  • expression, literal (defn)
  • expression, output to port
  • expression, procedure call (defn)
  • expression, special form (defn)
  • expt
  • extended comment, in programs (defn)
  • extension, of environment (defn)
  • extent, of dynamic binding (defn)
  • extent, of objects
  • external representation (defn)
  • external representation, and quasiquote
  • external representation, and quote
  • external representation, for bit string
  • external representation, for character
  • external representation, for empty list
  • external representation, for list
  • external representation, for number
  • external representation, for pair
  • external representation, for procedure
  • external representation, for string
  • external representation, for symbol
  • external representation, for vector
  • external representation, generating
  • external representation, parsing
  • extra object, of application hook

    f

  • f, as exponent marker in number
  • false
  • false, boolean object
  • false, boolean object (defn)
  • false, in conditional expression (defn)
  • false, predicate for
  • false?
  • fifth
  • file name
  • file, converting pathname directory to
  • file, end-of-file marker (see EOF object)
  • file, input and output ports
  • file-access
  • file-access-time
  • file-access-time-direct
  • file-access-time-indirect
  • file-attributes
  • file-attributes-direct
  • file-attributes-indirect
  • file-directory?
  • file-exists?
  • file-modes
  • file-modification-time
  • file-modification-time-direct
  • file-modification-time-indirect
  • file-namestring
  • file-pathname
  • file-readable?
  • file-symbolic-link?
  • file-system interface
  • file-writable?
  • filename (defn)
  • fill-polygon
  • filling, of bit string
  • filling, of string
  • filling, of vector
  • filtering, of list
  • find-color
  • find-module
  • first
  • fix:*
  • fix:+
  • fix:-
  • fix:-1+
  • fix:1+
  • fix:<
  • fix:<=
  • fix:=
  • fix:>
  • fix:>=
  • fix:and
  • fix:andc
  • fix:divide
  • fix:fixnum?
  • fix:gcd
  • fix:lsh
  • fix:negative?
  • fix:not
  • fix:or
  • fix:positive?
  • fix:quotient
  • fix:remainder
  • fix:xor
  • fix:zero?
  • fixnum (defn)
  • flo:*
  • flo:+
  • flo:-
  • flo:/
  • flo:<
  • flo:=
  • flo:>
  • flo:abs
  • flo:acos
  • flo:asin
  • flo:atan
  • flo:atan2
  • flo:ceiling
  • flo:ceiling->exact
  • flo:cos
  • flo:exp
  • flo:expt
  • flo:flonum?
  • flo:floor
  • flo:floor->exact
  • flo:log
  • flo:negate
  • flo:negative?
  • flo:positive?
  • flo:round
  • flo:round->exact
  • flo:sin
  • flo:sqrt
  • flo:tan
  • flo:truncate
  • flo:truncate->exact
  • flo:zero?
  • flonum (defn)
  • flonum-unparser-cutoff
  • floor
  • floor->exact
  • fluid binding
  • fluid-let
  • flush-output
  • flushing, of buffered output
  • fold-left
  • fold-right
  • font-structure
  • for-all?
  • for-each
  • force
  • forcing, of promise
  • foreign type declarations
  • form, special (defn)
  • formal parameter list, of lambda (defn)
  • format
  • format directive (defn)
  • format, entry
  • fourth
  • fresh-line

    g

  • gcd
  • gdi32.dll
  • ge
  • general-car-cdr
  • generate-uninterned-symbol
  • generating, external representation
  • gensym (see uninterned symbol)
  • geometry string, X graphics
  • get-default
  • graphic character (defn)
  • graphics
  • graphics, bitmaps
  • graphics, buffering of output
  • graphics, circle
  • graphics, clipping
  • graphics, coordinate systems
  • graphics, cursor (defn)
  • graphics, custom operations
  • graphics, device coordinates (defn)
  • graphics, drawing
  • graphics, drawing mode (defn)
  • graphics, ellipse
  • graphics, images
  • graphics, line style (defn)
  • graphics, opening and closing devices
  • graphics, output characteristics
  • graphics, virtual coordinates (defn)
  • graphics-bind-drawing-mode
  • graphics-bind-line-style
  • graphics-clear
  • graphics-close
  • graphics-coordinate-limits
  • graphics-device-coordinate-limits
  • graphics-disable-buffering
  • graphics-drag-cursor
  • graphics-draw-line
  • graphics-draw-point
  • graphics-draw-text
  • graphics-enable-buffering
  • graphics-erase-point
  • graphics-flush
  • graphics-move-cursor
  • graphics-operation
  • graphics-reset-clip-rectangle
  • graphics-set-clip-rectangle
  • graphics-set-coordinate-limits
  • graphics-set-drawing-mode
  • graphics-set-line-style
  • graphics-type-available?
  • greatest common divisor, of numbers
  • growing, of vector
  • guarantee-i/o-port
  • guarantee-input-port
  • guarantee-output-port

    h

  • handle
  • hash
  • hash table
  • hash-table->alist
  • hash-table/clean!
  • hash-table/clear!
  • hash-table/constructor
  • hash-table/count
  • hash-table/datum-list
  • hash-table/entries-list
  • hash-table/entries-vector
  • hash-table/entry-datum
  • hash-table/entry-key
  • hash-table/entry-valid?
  • hash-table/for-each
  • hash-table/get
  • hash-table/key-hash
  • hash-table/key-list
  • hash-table/key=?
  • hash-table/lookup
  • hash-table/make
  • hash-table/make-entry
  • hash-table/put!
  • hash-table/rehash-size
  • hash-table/rehash-threshold
  • hash-table/remove!
  • hash-table/set-entry-datum!
  • hash-table/size
  • hash-table?
  • hashing, of key in hash table
  • hashing, of object
  • hashing, of string
  • hashing, of symbol
  • hbitmap
  • hbrush
  • hcursor
  • hdc
  • head
  • height, of graphics character (defn)
  • hicon
  • hinstance
  • hmenu
  • home directory, as pathname
  • hook, application (defn)
  • host, in filename
  • host, pathname component
  • host-namestring
  • host=?
  • host?
  • hpalette
  • hpen
  • hrgn
  • hwnd
  • hyper, bucky bit prefix (defn)

    i

  • I/O, to files
  • I/O, to strings
  • i/o-port?
  • identifier (defn)
  • identity, additive
  • identity, multiplicative
  • if
  • imag-part
  • image/destroy
  • image/fill-from-byte-vector
  • image/height
  • image/width
  • image?
  • images, graphics
  • immutable
  • implementation restriction
  • implemented-primitive-procedure?
  • implicit begin
  • improper list (defn)
  • index, of bit string (defn)
  • index, of list (defn)
  • index, of string (defn)
  • index, of subvector (defn)
  • index, of vector (defn)
  • inexact->exact
  • inexact?
  • inheritance, of environment bindings (defn)
  • init-file-pathname
  • initial environment (defn)
  • initial size, of hash table
  • initial-offset
  • input
  • input operations
  • input port operations
  • input port, console
  • input port, current (defn)
  • input port, file
  • input port, string
  • input-port/char-ready?
  • input-port/copy
  • input-port/custom-operation
  • input-port/discard-char
  • input-port/discard-chars
  • input-port/operation
  • input-port/operation-names
  • input-port/operation/char-ready?
  • input-port/operation/discard-char
  • input-port/operation/discard-chars
  • input-port/operation/peek-char
  • input-port/operation/read-char
  • input-port/operation/read-string
  • input-port/peek-char
  • input-port/read-char
  • input-port/read-string
  • input-port/state
  • input-port?
  • insensitivity, to case in programs (defn)
  • installed, as pathname component
  • int
  • integer division
  • integer, converting to bit string
  • integer->char
  • integer-ceiling
  • integer-divide
  • integer-divide-quotient
  • integer-divide-remainder
  • integer-floor
  • integer-round
  • integer-truncate
  • integer?
  • interaction-i/o-port
  • interactive input ports (defn)
  • intern
  • internal definition
  • internal definition (defn)
  • internal representation, for character
  • internal representation, for inexact number
  • interned symbol (defn)
  • interning, of symbols
  • interpreted, procedure type
  • interpreter-environment?
  • inverse, additive, of number
  • inverse, multiplicative, of number
  • inverse, of bit string
  • inverse, of boolean object
  • invocation environment, of procedure (defn)
  • iteration expression (defn)

    k

  • kernel32.dll
  • key, of association list element (defn)
  • keyword constructor
  • keyword constructor (defn)
  • keyword, of special form (defn)
  • keyword-constructor

    l

  • l, as exponent marker in number
  • lambda
  • lambda expression (defn)
  • lambda list (defn)
  • lambda, implicit in define
  • lambda, implicit in let
  • last-pair
  • latent types (defn)
  • lazy evaluation (defn)
  • lcm
  • least common multiple, of numbers
  • length
  • length, of bit string
  • length, of bit string (defn)
  • length, of list (defn)
  • length, of stream
  • length, of string
  • length, of string (defn)
  • length, of vector (defn)
  • let
  • let*
  • letrec
  • letrec, implicit in define
  • lexical binding expression
  • lexical conventions
  • lexical scoping (defn)
  • library, system pathname
  • limitations
  • line style, graphics (defn)
  • list
  • list (defn)
  • list index (defn)
  • list, association (defn)
  • list, converting to stream
  • list, converting to string
  • list, converting to vector
  • list, external representation
  • list, improper (defn)
  • list->stream
  • list->string
  • list->vector
  • list-copy
  • list-deletor
  • list-deletor!
  • list-head
  • list-ref
  • list-search-negative
  • list-search-positive
  • list-tail
  • list-transform-negative
  • list-transform-positive
  • list?
  • literal component, of pathname
  • literal expression (defn)
  • literal, and quasiquote
  • literal, and quote
  • literal, identifier as
  • load-bitmap
  • load-option
  • loading DLLs
  • local-host
  • location
  • location, of variable
  • locks, and dynamic-wind
  • log
  • logical operations, on fixnums
  • long
  • long precision, of inexact number
  • looping (see iteration expressions)
  • lowercase
  • lowercase, character conversion
  • lowercase, in string

    m

  • magnitude
  • magnitude, of real number
  • make-1d-table
  • make-apply-hook
  • make-bit-string
  • make-cell
  • make-char
  • make-circular-list
  • make-entity
  • make-environment
  • make-eof-object
  • make-eq-hash-table
  • make-equal-hash-table
  • make-eqv-hash-table
  • make-graphics-device
  • make-i/o-port
  • make-initialized-vector
  • make-input-port
  • make-list
  • make-object-hash-table
  • make-output-port
  • make-pathname
  • make-polar
  • make-primitive-procedure
  • make-random-state
  • make-rb-tree
  • make-record-type
  • make-rectangular
  • make-string
  • make-string-hash-table
  • make-symbol-hash-table
  • make-vector
  • make-wt-tree
  • make-wt-tree-type
  • manifest types (defn)
  • map
  • map*
  • map-window
  • mapping, of list
  • mapping, of stream
  • matching, of strings
  • max
  • maximum length, of string (defn)
  • maximum, of numbers
  • member
  • member-procedure
  • memoization, of promise
  • memq
  • memv
  • merge-pathnames
  • merging, of pathnames
  • meta, bucky bit prefix (defn)
  • method, unparser (defn)
  • min
  • minimum, of numbers
  • missing component, of pathname
  • modification time, of file
  • modification, of bit string
  • modification, of string
  • modification, of vector
  • modulo
  • modulus, of hashing procedure
  • modulus, of integers
  • move-window
  • moving, of bit string elements
  • moving, of string elements
  • moving, of vector elements
  • multiple values, from procedure
  • multiplication, of numbers
  • must be, notational convention
  • mutable
  • mutation procedure (defn)

    n

  • name, of character
  • name, of file
  • name, of symbol
  • name, of value (defn)
  • name, pathname component
  • name->char
  • named
  • named lambda (defn)
  • named let (defn)
  • named-lambda
  • naming conventions
  • nearest-repl/environment
  • negative number
  • negative?
  • nesting, of quasiquote expressions
  • newest, as pathname component
  • newline
  • newline character (defn)
  • newline character, output to port
  • newline translation
  • nil
  • ninth
  • non-local exit
  • not
  • notation, dotted (defn)
  • notational conventions
  • notification-output-port
  • null string, predicate for
  • null?
  • number
  • number, external representation
  • number, pseudo-random
  • number->string
  • number-wt-type
  • number?
  • numerator
  • numeric character (defn)
  • numeric precision, inexact
  • numerical input and output
  • numerical operations
  • numerical types

    o

  • object hashing
  • object-hash
  • object-hashed?
  • object-unhash
  • odd number
  • odd?
  • oldest, as pathname component
  • one-dimensional table (defn)
  • open-binary-i/o-file
  • open-binary-input-file
  • open-binary-output-file
  • open-dib
  • open-i/o-file
  • open-input-file
  • open-output-file
  • operand, of procedure call (defn)
  • operator, of procedure call (defn)
  • option, run-time-loadable
  • optional component, in entries
  • optional parameter (defn)
  • or
  • order, of argument evaluation
  • ordering, of characters
  • ordering, of numbers
  • ordering, of strings
  • output
  • output port operations
  • output port, console
  • output port, current (defn)
  • output port, file
  • output port, string
  • output procedures
  • output-port/copy
  • output-port/custom-operation
  • output-port/discretionary-flush-output
  • output-port/flush-output
  • output-port/operation
  • output-port/operation-names
  • output-port/operation/discretionary-flush-output
  • output-port/operation/flush-output
  • output-port/operation/write-char
  • output-port/operation/write-string
  • output-port/operation/write-substring
  • output-port/state
  • output-port/write-char
  • output-port/write-string
  • output-port/write-substring
  • output-port/x-size
  • output-port/y-size
  • output-port?

    p

  • padding, of string
  • pair (defn)
  • pair, external representation
  • pair, weak (defn)
  • pair?
  • parameter list, of lambda (defn)
  • parameter, optional (defn)
  • parameter, required (defn)
  • parameter, rest (defn)
  • parent, of directory
  • parent, of environment (defn)
  • parenthesis, as external representation
  • parse-namestring
  • parsing, of external representation
  • pasting, of bit strings
  • pasting, of lists
  • pasting, of strings
  • pasting, of symbols
  • path, directory (defn)
  • pathname
  • pathname (defn)
  • pathname component, literal
  • pathname component, missing
  • pathname component, wildcard
  • pathname components
  • pathname, absolute (defn)
  • pathname, relative (defn)
  • pathname-absolute?
  • pathname-as-directory
  • pathname-default
  • pathname-default-device
  • pathname-default-directory
  • pathname-default-name
  • pathname-default-type
  • pathname-default-version
  • pathname-device
  • pathname-directory
  • pathname-host
  • pathname-name
  • pathname-new-device
  • pathname-new-directory
  • pathname-new-name
  • pathname-new-type
  • pathname-new-version
  • pathname-simplify
  • pathname-type
  • pathname-version
  • pathname-wild?
  • pathname=?
  • pathname?
  • peek-char
  • period, as external representation
  • physical size, of hash table (defn)
  • plus sign, in entries
  • port
  • port (defn)
  • port primitives
  • port, console
  • port, current
  • port, file
  • port, string
  • port/copy
  • port/input-blocking-mode
  • port/input-terminal-mode
  • port/operation
  • port/operation-names
  • port/output-blocking-mode
  • port/output-terminal-mode
  • port/set-input-blocking-mode
  • port/set-input-terminal-mode
  • port/set-output-blocking-mode
  • port/set-output-terminal-mode
  • port/state
  • port/with-input-blocking-mode
  • port/with-input-terminal-mode
  • port/with-output-blocking-mode
  • port/with-output-terminal-mode
  • port?
  • positive number
  • positive?
  • pp
  • precision, of inexact number
  • predicate
  • predicate (defn)
  • predicate, equivalence (defn)
  • predicate->char-set
  • prefix, of string
  • pretty printer
  • primitive procedure (defn)
  • primitive, procedure type
  • primitive-procedure-name
  • primitive-procedure?
  • print name, of symbol
  • print-procedure
  • printed output, in examples
  • printing graphics output
  • procedure
  • procedure call (defn)
  • procedure define (defn)
  • procedure, closing environment (defn)
  • procedure, compiled
  • procedure, compound
  • procedure, construction
  • procedure, entry format
  • procedure, escape (defn)
  • procedure, interpreted
  • procedure, invocation environment (defn)
  • procedure, of application hook
  • procedure, primitive
  • procedure, type
  • procedure-arity
  • procedure-arity-valid?
  • procedure-environment
  • procedure?
  • product, of numbers
  • promise (defn)
  • promise, construction
  • promise, forcing
  • promise-forced?
  • promise-value
  • promise?
  • prompt-for-command-char
  • prompt-for-command-expression
  • prompt-for-confirmation
  • prompt-for-evaluated-expression
  • prompt-for-expression
  • prompting
  • proper tail recursion (defn)
  • property list
  • property list, of symbol
  • pseudo-random number
  • pwd

    q

  • quasiquote
  • quote
  • quote, as external representation
  • quotient
  • quotient, of integers
  • quotient, of numbers
  • quoting

    r

  • R4RS
  • random
  • random number
  • random-state?
  • rational, simplest (defn)
  • rational?
  • rationalize
  • rationalize->exact
  • raw mode, of terminal port
  • rb-tree->alist
  • rb-tree/copy
  • rb-tree/datum-list
  • rb-tree/delete!
  • rb-tree/empty?
  • rb-tree/equal?
  • rb-tree/height
  • rb-tree/insert!
  • rb-tree/key-list
  • rb-tree/lookup
  • rb-tree/size
  • rb-tree?
  • read
  • read-char
  • read-char-no-hang
  • read-only
  • read-string
  • real-part
  • real?
  • record-accessor
  • record-constructor
  • record-modifier
  • record-predicate
  • record-type descriptor (defn)
  • record-type-descriptor
  • record-type-field-names
  • record-type-name
  • record-type?
  • record-updater
  • record?
  • recursion (see tail recursion)
  • red-black binary trees
  • reduce
  • reduce-right
  • reduction, of list
  • reference, variable (defn)
  • region of variable binding, do
  • region of variable binding, internal definition
  • region of variable binding, lambda
  • region of variable binding, let
  • region of variable binding, let*
  • region of variable binding, letrec
  • region, of variable binding (defn)
  • rehash size, of hash table (defn)
  • rehash threshold, of hash table (defn)
  • relative pathname (defn)
  • remainder
  • remainder, of integers
  • rename-file
  • renaming, of file
  • REP loop (defn)
  • REP loop, environment of
  • replacement, of string component
  • representation, external (defn)
  • required parameter (defn)
  • resize-window
  • resizing, of hash table
  • resource-id
  • resources, X graphics
  • rest parameter (defn)
  • result of evaluation, in examples
  • result, unspecified (defn)
  • reversal, of list
  • reverse
  • reverse!
  • ringing the console bell
  • root, as pathname component
  • rotation, of graphics character (defn)
  • round
  • round->exact
  • run-time-loadable option
  • runtime system

    s

  • s, as exponent marker in number
  • s-expression
  • save-bitmap
  • scheme concepts
  • Scheme standard
  • scope (see region)
  • scoping, lexical (defn)
  • scoping, static
  • screen, clearing
  • searching, of alist
  • searching, of list
  • searching, of string
  • second
  • selecting, of stream component
  • selection, components of pathname
  • selection, of bit string component
  • selection, of cell component
  • selection, of character component
  • selection, of list component
  • selection, of pair component
  • selection, of string component
  • selection, of vector component
  • selection, of weak pair component
  • semicolon, as external representation
  • sensitivity, to case in programs (defn)
  • sequence
  • sequencing expressions
  • set!
  • set, of characters
  • set-apply-hook-extra!
  • set-apply-hook-procedure!
  • set-background-color
  • set-border-color
  • set-border-width
  • set-car!
  • set-cdr!
  • set-cell-contents!
  • set-current-input-port!
  • set-current-output-port!
  • set-entity-extra!
  • set-entity-procedure!
  • set-file-modes!
  • set-file-times!
  • set-font
  • set-foreground-color
  • set-hash-table/rehash-size!
  • set-hash-table/rehash-threshold!
  • set-input-port/state!
  • set-interaction-i/o-port!
  • set-internal-border-width
  • set-line-color
  • set-line-width
  • set-mouse-color
  • set-mouse-shape
  • set-notification-output-port!
  • set-output-port/state!
  • set-port/state!
  • set-record-type-unparser-method!
  • set-string-length!
  • set-text-aspect
  • set-text-height
  • set-text-rotation
  • set-text-slant
  • set-trace-output-port!
  • set-window-name
  • set-working-directory-pathname!
  • sets, using binary trees
  • seventh
  • shadowing, of variable binding (defn)
  • short
  • short precision, of inexact number
  • signal an error (defn)
  • signed-integer->bit-string
  • simplest rational (defn)
  • simplest-exact-rational
  • simplest-rational
  • simplification, of pathname
  • sin
  • single precision, of inexact number
  • singleton-wt-tree
  • sixth
  • size, of hash table (defn)
  • slant, of graphics character (defn)
  • sort
  • special characters, in programs
  • special form
  • special form (defn)
  • special form, entry category
  • specified result, in examples
  • sqrt
  • standard character
  • standard character (defn)
  • standard operations, on port
  • standard ports
  • standard Scheme (defn)
  • standard-unparser-method
  • starbase graphics
  • starbase-graphics-device-type
  • start, of substring (defn)
  • start, of subvector (defn)
  • static scoping
  • static scoping (defn)
  • static types (defn)
  • stream
  • stream (defn)
  • stream, converting to list
  • stream->list
  • stream-car
  • stream-cdr
  • stream-first
  • stream-length
  • stream-map
  • stream-null?
  • stream-pair?
  • stream-ref
  • stream-rest
  • stream-tail
  • string
  • string index (defn)
  • string length (defn)
  • string, character (defn)
  • string, converting to input port
  • string, converting to list
  • string, input and output ports
  • string, input from port
  • string, interning as symbol
  • string, of bits (defn)
  • string, output to port
  • string->input-port
  • string->list
  • string->number
  • string->symbol
  • string->uninterned-symbol
  • string-append
  • string-capitalize
  • string-capitalize!
  • string-capitalized?
  • string-ci<=?
  • string-ci<?
  • string-ci=?
  • string-ci>=?
  • string-ci>?
  • string-compare
  • string-compare-ci
  • string-copy
  • string-downcase
  • string-downcase!
  • string-fill!
  • string-find-next-char
  • string-find-next-char-ci
  • string-find-next-char-in-set
  • string-find-previous-char
  • string-find-previous-char-ci
  • string-find-previous-char-in-set
  • string-hash
  • string-hash-mod
  • string-head
  • string-length
  • string-lower-case?
  • string-match-backward
  • string-match-backward-ci
  • string-match-forward
  • string-match-forward-ci
  • string-maximum-length
  • string-null?
  • string-pad-left
  • string-pad-right
  • string-prefix-ci?
  • string-prefix?
  • string-ref
  • string-replace
  • string-replace!
  • string-set!
  • string-suffix-ci?
  • string-suffix?
  • string-tail
  • string-trim
  • string-trim-left
  • string-trim-right
  • string-upcase
  • string-upcase!
  • string-upper-case?
  • string-wt-type
  • string<=?
  • string<?
  • string=?
  • string>=?
  • string>?
  • string?
  • strong types (defn)
  • strong-hash-table/constructor
  • strongly held keys, of hash table
  • sublist
  • substring
  • substring (defn)
  • substring, of bit string
  • substring, output to port
  • substring, searching string for
  • substring->list
  • substring-capitalize!
  • substring-capitalized?
  • substring-ci<?
  • substring-ci=?
  • substring-downcase!
  • substring-fill!
  • substring-find-next-char
  • substring-find-next-char-ci
  • substring-find-next-char-in-set
  • substring-find-previous-char
  • substring-find-previous-char-ci
  • substring-find-previous-char-in-set
  • substring-lower-case?
  • substring-match-backward
  • substring-match-backward-ci
  • substring-match-forward
  • substring-match-forward-ci
  • substring-move-left!
  • substring-move-right!
  • substring-prefix-ci?
  • substring-prefix?
  • substring-replace
  • substring-replace!
  • substring-suffix-ci?
  • substring-suffix?
  • substring-upcase!
  • substring-upper-case?
  • substring<?
  • substring=?
  • substring?
  • subtraction, of numbers
  • subvector
  • subvector (defn)
  • subvector->list
  • subvector-fill!
  • subvector-move-left!
  • subvector-move-right!
  • suffix, of string
  • sum, of numbers
  • super, bucky bit prefix (defn)
  • symbol (defn)
  • symbol->string
  • symbol-append
  • symbol-hash
  • symbol?
  • symbolic link, predicate for
  • syntactic keyword
  • syntactic keyword (defn)
  • syntactic keyword, identifier as
  • system-global-environment
  • system-library-directory-pathname
  • system-library-pathname

    t

  • t
  • table, association (defn)
  • table, one-dimensional (defn)
  • tail
  • tail recursion (defn)
  • tail recursion, vs. iteration expression
  • tan
  • tenth
  • terminal mode, of port
  • terminal screen, clearing
  • text-aspect
  • text-height
  • text-rotation
  • text-slant
  • the-empty-stream
  • the-environment
  • there-exists?
  • third
  • token, in programs (defn)
  • top, bucky bit prefix (defn)
  • top-level definition
  • top-level definition (defn)
  • total ordering (defn)
  • trace-output-port
  • tree, copying
  • tree-copy
  • trees, balanced binary
  • trimming, of string
  • true
  • true, boolean object
  • true, boolean object (defn)
  • true, in conditional expression (defn)
  • truename, of input file
  • truncate
  • truncate->exact
  • type
  • type predicate, for 1D table
  • type predicate, for alist
  • type predicate, for apply hook
  • type predicate, for bit string
  • type predicate, for boolean
  • type predicate, for cell
  • type predicate, for character
  • type predicate, for character set
  • type predicate, for compiled procedure
  • type predicate, for compound procedure
  • type predicate, for continuation
  • type predicate, for empty list
  • type predicate, for entity
  • type predicate, for environment
  • type predicate, for EOF object
  • type predicate, for fixnum
  • type predicate, for flonum
  • type predicate, for hash table
  • type predicate, for interpreter environment
  • type predicate, for list
  • type predicate, for number
  • type predicate, for pair
  • type predicate, for pathname
  • type predicate, for pathname host
  • type predicate, for port
  • type predicate, for primitive procedure
  • type predicate, for procedure
  • type predicate, for promise
  • type predicate, for record
  • type predicate, for record type
  • type predicate, for stream pair
  • type predicate, for string
  • type predicate, for symbol
  • type predicate, for vector
  • type predicate, for weak pair
  • type, of procedure
  • type, pathname component
  • types, latent (defn)
  • types, manifest (defn)
  • types, Windows

    u

  • uint
  • ulong
  • unassigned variable
  • unassigned variable (defn)
  • unassigned variable, and assignment
  • unassigned variable, and definition
  • unassigned variable, and dynamic bindings
  • unassigned variable, and named let
  • unbound variable
  • unbound variable (defn)
  • unchecked
  • unhash
  • uninterned symbol (defn)
  • unparser method (defn)
  • unparser/set-tagged-pair-method!
  • unparser/set-tagged-vector-method!
  • unquote
  • unquote-splicing
  • unsigned-integer->bit-string
  • unspecifiable component, of pathname
  • unspecific, as pathname component
  • unspecified result (defn)
  • unwind protect
  • unwind-protect
  • up, as pathname component
  • uppercase
  • uppercase, character conversion
  • uppercase, in string
  • usable size, of hash table (defn)
  • user-homedir-pathname
  • user-initial-environment
  • user32.dll
  • ushort

    v

  • V as format parameter
  • valid index, of bit string (defn)
  • valid index, of list (defn)
  • valid index, of string (defn)
  • valid index, of subvector (defn)
  • valid index, of vector (defn)
  • valid-hash-number?
  • value, of variable (defn)
  • values
  • values, multiple
  • variable binding
  • variable binding, do
  • variable binding, fluid-let
  • variable binding, internal definition
  • variable binding, lambda
  • variable binding, let
  • variable binding, let*
  • variable binding, letrec
  • variable binding, top-level definition
  • variable reference (defn)
  • variable, adding to environment
  • variable, assigning values to
  • variable, binding region (defn)
  • variable, entry category
  • variable, identifier as
  • vector
  • vector (defn)
  • vector index (defn)
  • vector length (defn)
  • vector, byte
  • vector, converting to list
  • vector-8b-fill!
  • vector-8b-find-next-char
  • vector-8b-find-next-char-ci
  • vector-8b-find-previous-char
  • vector-8b-find-previous-char-ci
  • vector-8b-ref
  • vector-8b-set!
  • vector->list
  • vector-copy
  • vector-eighth
  • vector-fifth
  • vector-fill!
  • vector-first
  • vector-fourth
  • vector-grow
  • vector-head
  • vector-length
  • vector-ref
  • vector-second
  • vector-set!
  • vector-seventh
  • vector-sixth
  • vector-tail
  • vector-third
  • vector?
  • version, pathname component
  • virtual coordinates, graphics (defn)

    w

  • warning
  • weak pair (defn)
  • weak pair, and 1D table
  • weak types (defn)
  • weak-car
  • weak-cdr
  • weak-cons
  • weak-hash-table/constructor
  • weak-pair/car?
  • weak-pair?
  • weak-set-car!
  • weak-set-cdr!
  • weakly held keys, of hash table
  • weight-balanced binary trees
  • where
  • whitespace character (defn)
  • whitespace, in programs (defn)
  • wild, as pathname component
  • wildcard component, of pathname
  • Win32 API names
  • Win32 graphics
  • Windows types
  • windows-procedure
  • with-current-unparser-state
  • with-input-from-binary-file
  • with-input-from-file
  • with-input-from-port
  • with-input-from-string
  • with-interaction-i/o-port
  • with-notification-output-port
  • with-output-to-binary-file
  • with-output-to-file
  • with-output-to-port
  • with-output-to-string
  • with-output-to-truncated-string
  • with-string-output-port
  • with-trace-output-port
  • with-working-directory-pathname
  • withdraw-window
  • within-continuation
  • word
  • working directory (see current working directory)
  • working-directory-pathname
  • write
  • write-char
  • write-dib
  • write-image-file
  • write-line
  • write-string
  • write-substring
  • write-to-string
  • wt-tree/add
  • wt-tree/add!
  • wt-tree/delete
  • wt-tree/delete!
  • wt-tree/delete-min
  • wt-tree/delete-min!
  • wt-tree/difference
  • wt-tree/empty?
  • wt-tree/fold
  • wt-tree/for-each
  • wt-tree/index
  • wt-tree/index-datum
  • wt-tree/index-pair
  • wt-tree/intersection
  • wt-tree/lookup
  • wt-tree/member?
  • wt-tree/min
  • wt-tree/min-datum
  • wt-tree/min-pair
  • wt-tree/rank
  • wt-tree/set-equal?
  • wt-tree/size
  • wt-tree/split<
  • wt-tree/split>
  • wt-tree/subset?
  • wt-tree/union
  • wt-tree?

    x

  • X display, graphics
  • X geometry string, graphics
  • X graphics
  • X resources, graphics
  • X window system
  • x-character-bounds/ascent
  • x-character-bounds/descent
  • x-character-bounds/lbearing
  • x-character-bounds/rbearing
  • x-character-bounds/width
  • x-close-all-displays
  • x-close-display
  • x-font-structure/all-chars-exist
  • x-font-structure/character-bounds
  • x-font-structure/default-char
  • x-font-structure/direction
  • x-font-structure/max-ascent
  • x-font-structure/max-bounds
  • x-font-structure/max-descent
  • x-font-structure/min-bounds
  • x-font-structure/name
  • x-font-structure/start-index
  • x-geometry-string
  • x-open-display
  • x-size

    y

  • y-size

    z

  • zero
  • zero?

    • Go to the previous section.