This is librep.info, produced by makeinfo version 4.2 from librep.texi.

INFO-DIR-SECTION Programming Languages
START-INFO-DIR-ENTRY
* librep: (librep).		A flexible Lisp environment
END-INFO-DIR-ENTRY

   This is Edition 1.2, last updated 8 September 2000, of `The librep
Manual', for librep, Version 0.13.

   Copyright 1999-2000 John Harper.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.


File: librep.info,  Node: Function index,  Next: Variable index,  Prev: News,  Up: Top

Function index
**************

* Menu:

* *:                                     Arithmetic Functions.
* +:                                     Arithmetic Functions.
* -:                                     Arithmetic Functions.
* /:                                     Arithmetic Functions.
* /=:                                    Comparison Predicates.
* 1+:                                    Arithmetic Functions.
* 1-:                                    Arithmetic Functions.
* <:                                     Comparison Predicates.
* <=:                                    Comparison Predicates.
* =:                                     Comparison Predicates.
* >:                                     Comparison Predicates.
* >=:                                    Comparison Predicates.
* _:                                     i18n.
* abs:                                   Real Number Functions.
* accept-process-output:                 Process I/O.
* acos:                                  Mathematical Functions.
* active-processes:                      Process Objects.
* add-hook:                              Normal Hooks.
* all-threads:                           Creating Threads.
* alpha-char-p:                          Characters.
* alphanumericp:                         Characters.
* and:                                   Conditional Structures.
* append:                                Building Lists.
* apply:                                 Calling Functions.
* apropos:                               Obarrays.
* aref:                                  Array Functions.
* arrayp:                                Array Functions.
* aset:                                  Array Functions.
* asin:                                  Mathematical Functions.
* assoc:                                 Association Lists.
* assq:                                  Association Lists.
* atan:                                  Mathematical Functions.
* atom:                                  Cons Cells.
* autoload:                              Autoloading.
* backquote:                             Backquoting.
* backtrace:                             Debugging.
* beep:                                  Beeping.
* bindtextdomain:                        i18n.
* boundp:                                Void Variables.
* break:                                 Debugging.
* bytecodep:                             Compilation Functions.
* call-hook:                             Normal Hooks.
* call-process:                          Synchronous Processes.
* call-with-current-continuation:        Continuations.
* call-with-dynamic-root:                Thread Contexts.
* call/cc:                               Continuations.
* canonical-file-name:                   File Names.
* capitalize-string:                     String Functions.
* car:                                   Cons Cells.
* case:                                  Conditional Structures.
* catch:                                 Catch and Throw.
* cdr:                                   Cons Cells.
* ceiling:                               Real Number Functions.
* char-downcase:                         Characters.
* char-upcase:                           Characters.
* close-file:                            Destroying File Objects.
* closure-function:                      Anonymous Functions.
* closurep:                              Anonymous Functions.
* compile-directory:                     Compilation Functions.
* compile-file:                          Compilation Functions.
* compile-form:                          Compilation Functions.
* compile-function:                      Compilation Functions.
* compile-module:                        Compilation Functions.
* complete-string:                       String Functions.
* concat:                                Strings.
* cond:                                  Conditional Structures.
* condition-case:                        Errors.
* cons:                                  Cons Cells.
* consp:                                 Cons Cells.
* continue-process:                      Process States.
* copy-file:                             Manipulating Files.
* copy-file-from-local-fs:               File Handlers.
* copy-file-to-local-fs:                 File Handlers.
* copy-sequence:                         Sequence Functions.
* copy-stream:                           Output Functions.
* cos:                                   Mathematical Functions.
* current-thread:                        Creating Threads.
* current-time:                          Timestamps.
* current-time-string:                   Formatting Dates.
* datum-ref:                             Datums.
* datum-set:                             Datums.
* declare:                               Compiler Declarations.
* defconst:                              Defining Variables.
* define <1>:                            Definitions.
* define:                                Defining Variables.
* define-datum-printer:                  Datums.
* define-interface:                      Module Interfaces.
* define-macro:                          Definitions.
* define-record-discloser:               Records.
* define-record-type:                    Records.
* define-structure:                      Module Definition.
* define-structures:                     Module Definition.
* defmacro:                              Defining Macros.
* defun:                                 Defining Functions.
* defvar:                                Defining Variables.
* delete:                                Modifying Lists.
* delete-directory:                      Manipulating Directories.
* delete-file:                           Manipulating Files.
* delete-from-queue:                     Queues.
* delete-if:                             Mapping Functions.
* delete-if-not:                         Mapping Functions.
* delete-timer:                          Timers.
* delq:                                  Modifying Lists.
* denominator:                           Rational Functions.
* dequeue:                               Queues.
* digit-char-p:                          Characters.
* directory-file-name:                   File Names.
* directory-files:                       Manipulating Directories.
* disassemble-fun:                       Disassembly.
* do:                                    Looping Structures.
* elt:                                   Sequence Functions.
* enqueue:                               Queues.
* eq:                                    Equality Predicates.
* eq-hash:                               Hash Tables.
* eql:                                   Equality Predicates.
* equal:                                 Equality Predicates.
* equal-hash:                            Hash Tables.
* eval:                                  Evaluation.
* eval-after-load:                       Load Function.
* eval-when-compile:                     Compiler Declarations.
* evenp:                                 Numeric Predicates.
* exact->inexact:                        Rational Functions.
* exactp:                                Numeric Predicates.
* exp:                                   Mathematical Functions.
* expand-file-name:                      File Names.
* expand-last-match:                     Regexp Functions.
* expt:                                  Mathematical Functions.
* featurep:                              Features.
* file-binding:                          Functions on File Objects.
* file-bound-stream:                     Functions on File Objects.
* file-directory-p:                      File Information.
* file-exists-p:                         File Information.
* file-handler-data:                     Functions on File Objects.
* file-modes:                            File Information.
* file-modes-as-string:                  File Information.
* file-modtime:                          File Information.
* file-name-absolute-p:                  File Names.
* file-name-as-directory:                File Names.
* file-name-directory:                   File Names.
* file-name-nondirectory:                File Names.
* file-newer-than-file-p:                File Information.
* file-nlinks:                           File Information.
* file-owner-p:                          File Information.
* file-readable-p:                       File Information.
* file-regular-p:                        File Information.
* file-size:                             File Information.
* file-symlink-p:                        File Information.
* file-writable-p:                       File Information.
* filep:                                 File Objects.
* filter:                                Mapping Functions.
* find-symbol:                           Obarrays.
* fix-time:                              Timestamps.
* floor:                                 Real Number Functions.
* fluid:                                 Fluid Variables.
* fluid-set:                             Fluid Variables.
* flush-file:                            Functions on File Objects.
* format:                                Formatted Output.
* funcall:                               Calling Functions.
* functionp:                             Functions.
* garbage-collect:                       Garbage Collection.
* gcd:                                   Integer Functions.
* gensym:                                Creating Symbols.
* get:                                   Property Lists.
* get-command-line-option:               Command Line Options.
* get-output-stream-string:              Output Streams.
* getenv:                                Environment Variables.
* has-type-p:                            Datums.
* if:                                    Conditional Structures.
* inexact->exact:                        Real Number Functions.
* inexactp:                              Numeric Predicates.
* input-stream-p:                        Streams.
* integerp:                              Numeric Predicates.
* intern:                                Interning.
* intern-symbol:                         Interning.
* interrupt-process:                     Signalling Processes.
* keywordp:                              Keyword Symbols.
* kill-process:                          Signalling Processes.
* last:                                  Accessing List Elements.
* lcm:                                   Integer Functions.
* length:                                Sequence Functions.
* let <1>:                               Looping Structures.
* let:                                   Local Variables.
* let*:                                  Local Variables.
* let-fluids:                            Fluid Variables.
* letrec:                                Local Variables.
* list:                                  Building Lists.
* list*:                                 Building Lists.
* listp:                                 Lists.
* load:                                  Load Function.
* local-file-name:                       File Names.
* log:                                   Mathematical Functions.
* logand:                                Bitwise Functions.
* logior:                                Bitwise Functions.
* lognot:                                Bitwise Functions.
* logxor:                                Bitwise Functions.
* lower-case-p:                          Characters.
* lsh:                                   Bitwise Functions.
* macroexpand:                           Macro Expansion.
* macroexpand-1:                         Macro Expansion.
* macrop:                                Macros.
* make-closure:                          Anonymous Functions.
* make-datum:                            Datums.
* make-directory:                        Manipulating Directories.
* make-file-from-stream:                 File Handlers.
* make-fluid:                            Fluid Variables.
* make-guardian:                         Guardians.
* make-keyword:                          Keyword Symbols.
* make-list:                             Building Lists.
* make-mutex:                            Mutexes.
* make-obarray:                          Obarrays.
* make-process:                          Process Objects.
* make-queue:                            Queues.
* make-string:                           Strings.
* make-string-input-stream:              Input Streams.
* make-string-output-stream:             Output Streams.
* make-suspended-thread:                 Creating Threads.
* make-symbol:                           Creating Symbols.
* make-symlink:                          Manipulating Symlinks.
* make-table:                            Hash Tables.
* make-temp-name:                        File Names.
* make-thread:                           Creating Threads.
* make-timer:                            Timers.
* make-vector:                           Vectors.
* make-weak-table:                       Hash Tables.
* makunbound:                            Void Variables.
* mapc:                                  Mapping Functions.
* mapcar:                                Mapping Functions.
* mapconcat:                             String Functions.
* match-end:                             Regexp Functions.
* match-start:                           Regexp Functions.
* max:                                   Comparison Predicates.
* maybe-obtain-mutex:                    Mutexes.
* member:                                Accessing List Elements.
* memq:                                  Accessing List Elements.
* message:                               Messages.
* min:                                   Comparison Predicates.
* mod:                                   Integer Functions.
* modulo:                                Integer Functions.
* mutexp:                                Mutexes.
* nconc:                                 Modifying Lists.
* negativep:                             Numeric Predicates.
* not:                                   Conditional Structures.
* nreverse:                              Modifying Lists.
* nth:                                   Accessing List Elements.
* nthcdr:                                Accessing List Elements.
* null:                                  Lists.
* numberp:                               Numbers.
* numerator:                             Rational Functions.
* obtain-mutex:                          Mutexes.
* oddp:                                  Numeric Predicates.
* open-file:                             Creating File Objects.
* or:                                    Conditional Structures.
* output-stream-p:                       Streams.
* parse-date:                            Parsing Dates.
* positivep:                             Numeric Predicates.
* prin1:                                 Output Functions.
* prin1-to-string:                       Output Functions.
* princ:                                 Output Functions.
* print:                                 Output Functions.
* process-args:                          Process Objects.
* process-connection-type:               Asynchronous Processes.
* process-dir:                           Process Objects.
* process-error-stream:                  Process I/O.
* process-exit-status:                   Process Information.
* process-exit-value:                    Process Information.
* process-function:                      Process States.
* process-id:                            Process Information.
* process-in-use-p:                      Process States.
* process-output-stream:                 Process I/O.
* process-prog:                          Process Objects.
* process-running-p:                     Process States.
* process-stopped-p:                     Process States.
* processp:                              Process Objects.
* prog1:                                 Sequencing Structures.
* prog2:                                 Sequencing Structures.
* progn:                                 Sequencing Structures.
* provide:                               Features.
* put:                                   Property Lists.
* queue->list:                           Queues.
* queue-empty-p:                         Queues.
* queue-length:                          Queues.
* queuep:                                Queues.
* quote:                                 Quoting.
* quote-regexp:                          Regexp Functions.
* quotient:                              Integer Functions.
* random:                                Random Numbers.
* rassoc:                                Association Lists.
* rassq:                                 Association Lists.
* rationalp:                             Numeric Predicates.
* read <1>:                              The Lisp Reader.
* read:                                  Input Functions.
* read-char:                             Input Functions.
* read-from-string:                      Input Functions.
* read-line:                             Input Functions.
* read-symlink:                          Manipulating Symlinks.
* realp:                                 Numeric Predicates.
* release-mutex:                         Mutexes.
* remainder:                             Integer Functions.
* remote-ftp-add-passwd:                 Remote Files.
* remove:                                Building Lists.
* remove-hook:                           Normal Hooks.
* remq:                                  Building Lists.
* rename-file:                           Manipulating Files.
* require:                               Features.
* reverse:                               Building Lists.
* round:                                 Real Number Functions.
* rplaca:                                Cons Cells.
* rplacd:                                Cons Cells.
* run-byte-code:                         Compilation Functions.
* seconds->time:                         Timestamps.
* seek-file:                             Functions on File Objects.
* sequencep <1>:                         Sequence Functions.
* sequencep:                             Sequences.
* set:                                   Setting Variables.
* set-file-handler-data:                 Functions on File Objects.
* set-file-modes:                        File Information.
* set-input-handler:                     Functions on File Objects.
* set-process-args:                      Process Objects.
* set-process-connection-type:           Asynchronous Processes.
* set-process-dir:                       Process Objects.
* set-process-error-stream:              Process I/O.
* set-process-function:                  Process States.
* set-process-output-stream:             Process I/O.
* set-process-prog:                      Process Objects.
* set-timer:                             Timers.
* setenv:                                Environment Variables.
* setplist:                              Property Lists.
* setq:                                  Setting Variables.
* signal:                                Errors.
* signal-process:                        Signalling Processes.
* sin:                                   Mathematical Functions.
* sit-for:                               Process I/O.
* sleep-for:                             Sleeping.
* sort:                                  Modifying Lists.
* space-char-p:                          Characters.
* special-form-p:                        Special Forms.
* sqrt:                                  Mathematical Functions.
* start-process:                         Asynchronous Processes.
* stderr-file:                           Creating File Objects.
* stdin-file:                            Creating File Objects.
* stdout-file:                           Creating File Objects.
* step:                                  Debugging.
* stop-process:                          Process States.
* streamp:                               Streams.
* string-capitalized-p:                  String Functions.
* string-downcase:                       String Functions.
* string-equal:                          Strings.
* string-hash:                           Hash Tables.
* string-head-eq:                        String Functions.
* string-lessp:                          Strings.
* string-looking-at:                     Regexp Functions.
* string-lower-case-p:                   String Functions.
* string-match:                          Regexp Functions.
* string-replace:                        Regexp Functions.
* string-upcase:                         String Functions.
* string-upper-case-p:                   String Functions.
* string<:                               Strings.
* string=:                               Strings.
* stringp:                               Strings.
* structure:                             Module Definition.
* subr-name:                             Functions.
* subrp:                                 Functions.
* substring:                             Strings.
* symbol-hash:                           Hash Tables.
* symbol-name:                           Symbol Attributes.
* symbol-plist:                          Property Lists.
* symbol-value:                          Variables.
* symbolp:                               Symbols.
* system:                                Shell Commands.
* system-name:                           System Information.
* table-bound-p:                         Hash Tables.
* table-ref:                             Hash Tables.
* table-set:                             Hash Tables.
* table-unset:                           Hash Tables.
* table-walk:                            Hash Tables.
* tablep:                                Hash Tables.
* tan:                                   Mathematical Functions.
* textdomain:                            i18n.
* thread-delete:                         Deleting Threads.
* thread-deleted-p:                      Deleting Threads.
* thread-forbid:                         Manipulating Threads.
* thread-join:                           Manipulating Threads.
* thread-permit:                         Manipulating Threads.
* thread-suspend:                        Manipulating Threads.
* thread-suspended-p:                    Manipulating Threads.
* thread-wake:                           Manipulating Threads.
* thread-yield:                          Manipulating Threads.
* threadp:                               Creating Threads.
* throw:                                 Catch and Throw.
* time-:                                 Timestamps.
* time->seconds:                         Timestamps.
* time-later-p:                          Timestamps.
* trace:                                 Debugging.
* translate-string:                      String Functions.
* truncate:                              Real Number Functions.
* unintern:                              Interning.
* unless:                                Conditional Structures.
* unsetenv:                              Environment Variables.
* untrace:                               Debugging.
* unwind-protect:                        Cleanup Forms.
* upper-case-p:                          Characters.
* useless-function:                      Descriptions.
* user-full-name:                        User Information.
* user-home-directory:                   User Information.
* user-login-name:                       User Information.
* vector:                                Vectors.
* vectorp:                               Vectors.
* when:                                  Conditional Structures.
* while:                                 Looping Structures.
* with-fluids:                           Fluid Variables.
* with-internal-definitions:             Definitions.
* without-interrupts:                    Manipulating Threads.
* write:                                 Output Functions.
* zerop:                                 Numeric Predicates.


File: librep.info,  Node: Variable index,  Next: Concept index,  Prev: Function index,  Up: Top

Variable index
**************

* Menu:

* after-gc-hook:                         Garbage Collection.
* after-load-alist:                      Load Function.
* backtrace-on-error:                    Errors.
* command-line-args <1>:                 Command Line Options.
* command-line-args:                     Invocation.
* date-vec-day:                          Parsing Dates.
* date-vec-day-abbrev:                   Parsing Dates.
* date-vec-epoch-time:                   Parsing Dates.
* date-vec-hour:                         Parsing Dates.
* date-vec-minute:                       Parsing Dates.
* date-vec-month:                        Parsing Dates.
* date-vec-month-abbrev:                 Parsing Dates.
* date-vec-second:                       Parsing Dates.
* date-vec-timezone:                     Parsing Dates.
* date-vec-year:                         Parsing Dates.
* debug-on-error:                        Errors.
* default-directory:                     File Names.
* dl-load-path:                          Load Function.
* downcase-table:                        String Functions.
* features:                              Features.
* file-handler-alist:                    File Handlers.
* flatten-table:                         String Functions.
* format-hooks-alist:                    Formatted Output.
* garbage-threshold:                     Garbage Collection.
* grains-of-sand:                        Descriptions.
* idle-garbage-threshold:                Garbage Collection.
* lisp-lib-directory:                    Load Function.
* load-filename:                         Load Function.
* load-path:                             Load Function.
* max-lisp-depth:                        Evaluation.
* obarray:                               Obarrays.
* operating-system:                      System Information.
* print-escape:                          Output Functions.
* print-length:                          Output Functions.
* print-level:                           Output Functions.
* process-environment:                   Process Objects.
* remote-auto-backend-alist:             Remote Files.
* remote-default-backend:                Remote Files.
* remote-default-user:                   Remote Files.
* remote-ftp-anon-passwd:                Remote Files.
* remote-ftp-anon-users:                 Remote Files.
* remote-ftp-display-progress:           Remote Files.
* remote-ftp-show-messages:              Remote Files.
* remote-host-user-alist:                Remote Files.
* rep-build-id:                          System Information.
* rep-version:                           System Information.
* seconds-per-day:                       Timestamps.
* standard-error:                        Output Streams.
* standard-input:                        Input Streams.
* standard-output:                       Output Streams.
* upcase-table:                          String Functions.


File: librep.info,  Node: Concept index,  Prev: Variable index,  Up: Top

Concept index
*************

* Menu:

* Accessing list elements:               Accessing List Elements.
* Alists:                                Association Lists.
* Anonymous functions:                   Anonymous Functions.
* Arguments, command line:               Command Line Options.
* Arithmetic Functions:                  Arithmetic Functions.
* Array functions:                       Array Functions.
* Arrays:                                Sequences.
* Association lists:                     Association Lists.
* Asynchronous processes:                Asynchronous Processes.
* Asynchronous timers:                   Timers.
* Atom:                                  Cons Cells.
* Autoload forms:                        Autoload Forms.
* Autoloading:                           Autoloading.
* Backquoting:                           Backquoting.
* Beeping:                               Beeping.
* Bitwise functions:                     Bitwise Functions.
* Block structured definitions:          Definitions.
* Boolean values:                        nil and t.
* Boolean values, predicate functions:   Predicate Functions.
* Bugs, reporting:                       Reporting bugs.
* Building lists:                        Building Lists.
* Calendar date and time:                Time and Date.
* Calling functions:                     Calling Functions.
* Catch and throw:                       Catch and Throw.
* Characters:                            Characters.
* Circular lists:                        Infinite Lists.
* Cleanup forms:                         Cleanup Forms.
* Command line options:                  Command Line Options.
* Comment styles:                        Comment Styles.
* Comments:                              Read Syntax.
* Comparison predicates:                 Comparison Predicates.
* Compilation functions:                 Compilation Functions.
* Compilation tips:                      Compilation Tips.
* Compilation, disassembly of forms:     Disassembly.
* Compiled Lisp:                         Compiled Lisp.
* Compiler declarations:                 Compiler Declarations.
* Compiling macros:                      Compiling Macros.
* Conditional structures:                Conditional Structures.
* Cons cells:                            Cons Cells.
* Continuations:                         Continuations.
* Control Structures:                    Control Structures.
* Control structures, conditionals:      Conditional Structures.
* Control structures, looping:           Looping Structures.
* Control structures, non-local exits:   Non-Local Exits.
* Control structures, sequencing:        Sequencing Structures.
* Copying:                               Copying.
* Creating file objects:                 Creating File Objects.
* Creating symbols:                      Creating Symbols.
* Creating threads:                      Creating Threads.
* Data type representation:              Data Type Representation.
* Data types:                            Data Types.
* Data types, datums:                    Datums.
* Data types, hash tables:               Hash Tables.
* Data types, queues:                    Queues.
* Data types, records:                   Records.
* Data types, summary of:                Types Summary.
* Date and time:                         Time and Date.
* Date and time, timestamps:             Timestamps.
* Dates, formatting as strings:          Formatting Dates.
* Dates, parsing:                        Parsing Dates.
* Datums:                                Datums.
* Debugging:                             Debugging.
* Declarations, compiler:                Compiler Declarations.
* Defining functions:                    Defining Functions.
* Defining lisp subrs:                   Defining Lisp Subrs.
* Defining macros:                       Defining Macros.
* Defining variables:                    Defining Variables.
* Definitions, block structured:         Definitions.
* Deleting threads:                      Deleting Threads.
* Descriptions:                          Descriptions.
* Destroying file objects:               Destroying File Objects.
* Disassembly:                           Disassembly.
* Distribution conditions:               Copying.
* Dynamically loaded libraries:          Shared Libraries.
* Embedding librep:                      librep Internals.
* Environment variables:                 Environment Variables.
* Equality predicates:                   Equality Predicates.
* Errors:                                Errors.
* Escape sequences in strings:           Strings.
* Evaluating Lisp forms:                 Evaluation.
* Evaluation:                            Evaluation.
* Executing rep scripts:                 Invocation.
* Executing shell commands:              Shell Commands.
* Expansion, of macros:                  Macro Expansion.
* Features:                              Features.
* File Handlers:                         File Handlers.
* File handlers, remote files:           Remote Files.
* File information:                      File Information.
* File names:                            File Names.
* File objects:                          File Objects.
* File objects, creating:                Creating File Objects.
* File objects, destroying:              Destroying File Objects.
* File objects, functions:               Functions on File Objects.
* Files:                                 Files.
* Files, closing:                        Destroying File Objects.
* Files, manipulating:                   Manipulating Files.
* Files, manipulating directories:       Manipulating Directories.
* Files, opening:                        Creating File Objects.
* Files, remote:                         Remote Files.
* Fluid variables:                       Fluid Variables.
* Formatted output:                      Formatted Output.
* Formatting dates:                      Formatting Dates.
* Forms, autoload:                       Autoload Forms.
* Forms, constant:                       Self-Evaluating Forms.
* Forms, function call:                  Function Call Forms.
* Forms, macro call:                     Macro Call Forms.
* Forms, self-evaluating:                Self-Evaluating Forms.
* Forms, special:                        Special Forms.
* Forms, symbol:                         Symbol Forms.
* Forms, variable:                       Symbol Forms.
* Function call forms:                   Function Call Forms.
* Function exits:                        Function Exits.
* Functions:                             Functions.
* Functions as hooks:                    Functions As Hooks.
* Functions on File Objects:             Functions on File Objects.
* Functions, anonymous:                  Anonymous Functions.
* Functions, block structured:           Definitions.
* Functions, calling:                    Calling Functions.
* Functions, compilation:                Compilation Functions.
* Functions, defining:                   Defining Functions.
* Functions, descriptions of:            Descriptions.
* Functions, input:                      Input Functions.
* Functions, lambda expressions:         Lambda Expressions.
* Functions, loading:                    Load Function.
* Functions, local:                      Local Functions.
* Functions, mapping:                    Mapping Functions.
* Functions, output:                     Output Functions.
* Garbage collection:                    Garbage Collection.
* Garbage collection internals:          Garbage Collection Internals.
* Garbage collection, guardians:         Guardians.
* Guardians:                             Guardians.
* Hash tables:                           Hash Tables.
* Hooks:                                 Hooks.
* Hooks, functions as:                   Functions As Hooks.
* Hooks, normal:                         Normal Hooks.
* Implicitly Interpreting rep scripts:   Invocation.
* Infinite lists:                        Infinite Lists.
* Input and output:                      Streams.
* Input functions:                       Input Functions.
* Input streams:                         Input Streams.
* Integer functions:                     Integer Functions.
* Integers:                              Numbers.
* Interface, C:                          librep Internals.
* Internals:                             librep Internals.
* Internals, data types:                 Data Type Representation.
* Internals, defining subrs:             Defining Lisp Subrs.
* Internals, garbage collection:         Garbage Collection Internals.
* Internals, introduction to:            Intro To Internals.
* Internals, useful functions:           Useful Functions.
* Internationalisation:                  i18n.
* Interning:                             Interning.
* Introduction:                          Introduction.
* Introduction to librep internals:      Intro To Internals.
* Introduction, Lisp:                    Intro.
* Invocation:                            Invocation.
* Keyword symbols:                       Keyword Symbols.
* Lambda expressions:                    Lambda Expressions.
* Libraries, shared:                     Shared Libraries.
* librep Internals:                      librep Internals.
* librep internals:                      librep Internals.
* Licence:                               Copying.
* Lisp forms, evaluating:                Evaluation.
* Lisp, the rep dialect:                 The language.
* List forms:                            List Forms.
* List structure:                        List Structure.
* Lists:                                 Lists.
* Lists, accessing elements:             Accessing List Elements.
* Lists, association:                    Association Lists.
* Lists, building:                       Building Lists.
* Lists, circular:                       Infinite Lists.
* Lists, mapping:                        Mapping Functions.
* Lists, modifying:                      Modifying Lists.
* Load function:                         Load Function.
* Loading:                               Loading.
* Loading programs:                      Loading.
* Loading, on reference:                 Autoloading.
* Local functions:                       Local Functions.
* Local variables:                       Local Variables.
* Looping structures:                    Looping Structures.
* Macro call forms:                      Macro Call Forms.
* Macro expansion:                       Macro Expansion.
* Macros:                                Macros.
* Macros, backquoting:                   Backquoting.
* Macros, compiling:                     Compiling Macros.
* Macros, defining:                      Defining Macros.
* Manipulating files:                    Manipulating Files.
* Manipulating Symbolic Links:           Manipulating Symlinks.
* Manipulating threads:                  Manipulating Threads.
* Manual notation:                       Notation.
* Mapping functions:                     Mapping Functions.
* Matching strings:                      Regexp Functions.
* Mathematical functions:                Mathematical Functions.
* Messages:                              Messages.
* Modifying lists:                       Modifying Lists.
* Modules:                               Modules.
* Modules, and special variables:        Modules and Special Variables.
* Modules, definition of:                Module Definition.
* Modules, interfaces:                   Module Interfaces.
* Modules, loading:                      Module Loading.
* Mutexes:                               Mutexes.
* Mutual exclusion devices:              Mutexes.
* Names of files:                        File Names.
* News:                                  News.
* nil and t:                             nil and t.
* Non-local exits:                       Non-Local Exits.
* Non-local exits, catch and throw:      Catch and Throw.
* Non-local exits, cleanup forms:        Cleanup Forms.
* Non-local exits, errors:               Errors.
* Non-local exits, function exits:       Function Exits.
* Normal hooks:                          Normal Hooks.
* Notation:                              Notation.
* Numbers:                               Numbers.
* Numbers, arithmetic functions:         Arithmetic Functions.
* Numbers, bitwise functions:            Bitwise Functions.
* Numbers, integer functions:            Integer Functions.
* Numbers, mathematical functions:       Mathematical Functions.
* Numbers, predicates on:                Numeric Predicates.
* Numbers, pseudo random:                Random Numbers.
* Numbers, rational functions:           Rational Functions.
* Numbers, real number functions:        Real Number Functions.
* Numeric predicates:                    Numeric Predicates.
* Obarrays:                              Obarrays.
* Options, command line:                 Command Line Options.
* Output functions:                      Output Functions.
* Output streams:                        Output Streams.
* Output, formatted:                     Formatted Output.
* Parsing dates:                         Parsing Dates.
* Predicate functions:                   Predicate Functions.
* Predicates on numbers:                 Numeric Predicates.
* Predicates, comparison:                Comparison Predicates.
* Predicates, equality:                  Equality Predicates.
* Predicates, type:                      Type Predicates.
* Printed representation:                Printed Representation.
* Process I/O:                           Process I/O.
* Process information:                   Process Information.
* Process objects:                       Process Objects.
* Process states:                        Process States.
* Processes:                             Processes.
* Processes, asynchronous:               Asynchronous Processes.
* Processes, signalling:                 Signalling Processes.
* Processes, synchronous:                Synchronous Processes.
* Programs, loading:                     Loading.
* Property lists:                        Property Lists.
* Pseudo-random numbers:                 Random Numbers.
* Queues:                                Queues.
* Quoting:                               Quoting.
* Random numbers:                        Random Numbers.
* Rational functions:                    Rational Functions.
* Read syntax:                           Read Syntax.
* Read-eval-print loop:                  The REPL.
* Reader, the Lisp:                      The Lisp Reader.
* Reading directories:                   Manipulating Directories.
* Real number functions:                 Real Number Functions.
* Records:                               Records.
* Regexp functions:                      Regexp Functions.
* Regexp syntax:                         Regexp Syntax.
* Regexps:                               Regular Expressions.
* Regular expression syntax:             Regexp Syntax.
* Regular expressions:                   Regular Expressions.
* Remote files:                          Remote Files.
* rep, the Lisp dialect:                 The language.
* Reporting bugs:                        Reporting bugs.
* Representation of data types:          Data Type Representation.
* Scope and extent:                      Scope and Extent.
* Scripts, executing implicitly:         Invocation.
* Self-evaluating forms:                 Self-Evaluating Forms.
* Sequence functions:                    Sequence Functions.
* Sequences:                             Sequences.
* Sequences, cons cells:                 Cons Cells.
* Sequencing structures:                 Sequencing Structures.
* Setting variables:                     Setting Variables.
* Shared libraries:                      Shared Libraries.
* Shell commands, executing:             Shell Commands.
* Signalling processes:                  Signalling Processes.
* Sleeping:                              Sleeping.
* Special forms:                         Special Forms.
* Streams:                               Streams.
* Streams, formatted output:             Formatted Output.
* Streams, input:                        Input Streams.
* Streams, input functions:              Input Functions.
* Streams, output:                       Output Streams.
* Streams, output functions:             Output Functions.
* String functions:                      String Functions.
* String matching:                       Regexp Functions.
* Strings, escape sequences:             Strings.
* Style, comments:                       Comment Styles.
* Subprocesses:                          Processes.
* Subrs, defining:                       Defining Lisp Subrs.
* Symbol attributes:                     Symbol Attributes.
* Symbol forms:                          Symbol Forms.
* Symbol syntax:                         Symbol Syntax.
* Symbolic Links, manipulating:          Manipulating Symlinks.
* Symbols:                               Symbols.
* Symbols, creating:                     Creating Symbols.
* Symbols, interning:                    Interning.
* Symbols, keywords:                     Keyword Symbols.
* Symbols, obarrays:                     Obarrays.
* Symbols, property lists:               Property Lists.
* Synchronous processes:                 Synchronous Processes.
* Syntax of objects:                     Read Syntax.
* Syntax of regexps:                     Regexp Syntax.
* System information:                    System Information.
* t:                                     nil and t.
* The language:                          The language.
* The Lisp reader:                       The Lisp Reader.
* The REPL:                              The REPL.
* Thread contexts:                       Thread Contexts.
* Thread implementation notes:           Thread Implementation Notes.
* Threads:                               Threads.
* Threads, creating:                     Creating Threads.
* Threads, deleting:                     Deleting Threads.
* Threads, manipulating:                 Manipulating Threads.
* Threads, mutexes:                      Mutexes.
* Time and date:                         Time and Date.
* Time, formatting as strings:           Formatting Dates.
* Time, parsing:                         Parsing Dates.
* Timers, asynchronous:                  Timers.
* Timestamps:                            Timestamps.
* Tips:                                  Tips.
* Tips, comment styles:                  Comment Styles.
* Tips, compilation:                     Compilation Tips.
* Type predicates:                       Type Predicates.
* Types summary:                         Types Summary.
* Useful functions:                      Useful Functions.
* User information:                      User Information.
* Variables:                             Variables.
* Variables, defining:                   Defining Variables.
* Variables, descriptions of:            Descriptions.
* Variables, fluid:                      Fluid Variables.
* Variables, local:                      Local Variables.
* Variables, scope and extent of:        Scope and Extent.
* Variables, setting:                    Setting Variables.
* Variables, void:                       Void Variables.
* Void variables:                        Void Variables.


