This is guile.info, produced by makeinfo version 4.3 from guile.texi.

INFO-DIR-SECTION The Algorithmic Language Scheme
START-INFO-DIR-ENTRY
* Guile Reference: (guile).     The Guile reference manual.
END-INFO-DIR-ENTRY

   Guile Reference Manual Copyright (C) 1996 Free Software Foundation
Copyright (C) 1997 Free Software Foundation
Copyright (C) 2000 Free Software Foundation
Copyright (C) 2001 Free Software Foundation
Copyright (C) 2002 Free Software Foundation

   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.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Free Software Foundation.


File: guile.info,  Node: Procedure Index,  Next: Variable Index,  Prev: Concept Index,  Up: Top

Procedure Index
***************

   This is an alphabetical list of all the procedures and macros in
Guile.

   When looking for a particular procedure, please look under its Scheme
name as well as under its C name.  The C name can be constructed from
the Scheme names by a simple transformation described in the section
*Note Transforming Scheme name to C name::.

* Menu:

* $abs:                                  Primitive Numerics.
* $acos:                                 Primitive Numerics.
* $acosh:                                Primitive Numerics.
* $asin:                                 Primitive Numerics.
* $asinh:                                Primitive Numerics.
* $atan:                                 Primitive Numerics.
* $atan2:                                Primitive Numerics.
* $atanh:                                Primitive Numerics.
* $cos:                                  Primitive Numerics.
* $cosh:                                 Primitive Numerics.
* $exp:                                  Primitive Numerics.
* $expt:                                 Primitive Numerics.
* $log:                                  Primitive Numerics.
* $sin:                                  Primitive Numerics.
* $sinh:                                 Primitive Numerics.
* $sqrt:                                 Primitive Numerics.
* $tan:                                  Primitive Numerics.
* $tanh:                                 Primitive Numerics.
* %library-dir:                          Build Config.
* %make-void-port:                       Void Ports.
* %package-data-dir:                     Build Config.
* %read-delimited!:                      Line/Delimited.
* %read-line:                            Line/Delimited.
* %search-load-path:                     Loading.
* %site-dir:                             Build Config.
* %thread-handler:                       Higher level thread procedures.
* * <1>:                                 C Hooks.
* *:                                     Arithmetic.
* *gh_scm2chars:                         Scheme to C.
* *gh_scm2doubles:                       Scheme to C.
* *gh_scm2floats:                        Scheme to C.
* *gh_scm2longs:                         Scheme to C.
* *gh_scm2newstr:                        Scheme to C.
* *gh_scm2shorts:                        Scheme to C.
* *gh_symbol2newstr:                     Scheme to C.
* +:                                     Arithmetic.
* -:                                     Arithmetic.
* ->char-set:                            SRFI-14 Creating Character Sets.
* /:                                     Arithmetic.
* <:                                     Comparison.
* <=:                                    Comparison.
* <group>-disable:                       User level options interfaces.
* <group>-enable:                        User level options interfaces.
* <group>-options:                       User level options interfaces.
* <group>-set!:                          User level options interfaces.
* =:                                     Comparison.
* >:                                     Comparison.
* >=:                                    Comparison.
* abs:                                   Arithmetic.
* accept:                                Network Sockets and Communication.
* access?:                               File System.
* acons:                                 Adding or Setting Alist Entries.
* acos:                                  Scientific.
* acosh:                                 Scientific.
* add-hook!:                             Hook Reference.
* advance-dfa!:                          Rx Regexps.
* alarm:                                 Signals.
* alist-cons:                            SRFI-1 Association Lists.
* alist-copy:                            SRFI-1 Association Lists.
* alist-delete:                          SRFI-1 Association Lists.
* alist-delete!:                         SRFI-1 Association Lists.
* and:                                   and or.
* angle:                                 Complex.
* any:                                   SRFI-1 Searching.
* append:                                Append/Reverse.
* append!:                               Append/Reverse.
* append-map:                            SRFI-1 Fold and Map.
* append-map!:                           SRFI-1 Fold and Map.
* append-reverse:                        SRFI-1 Length Append etc.
* append-reverse!:                       SRFI-1 Length Append etc.
* apply:                                 Fly Evaluation.
* apply:nconc2last:                      Fly Evaluation.
* array->list:                           Conventional Arrays.
* array-contents:                        Conventional Arrays.
* array-copy!:                           Conventional Arrays.
* array-copy-in-order!:                  Conventional Arrays.
* array-dimensions:                      Conventional Arrays.
* array-equal?:                          Conventional Arrays.
* array-fill!:                           Conventional Arrays.
* array-for-each:                        Array Mapping.
* array-in-bounds?:                      Conventional Arrays.
* array-index-map!:                      Array Mapping.
* array-map!:                            Array Mapping.
* array-map-in-order!:                   Array Mapping.
* array-prototype:                       Uniform Arrays.
* array-rank:                            Conventional Arrays.
* array-ref:                             Conventional Arrays.
* array-set!:                            Conventional Arrays.
* array-shape:                           Conventional Arrays.
* array? <1>:                            Uniform Arrays.
* array?:                                Conventional Arrays.
* ash:                                   Bitwise Operations.
* asin:                                  Scientific.
* asinh:                                 Scientific.
* assoc <1>:                             SRFI-1 Association Lists.
* assoc:                                 Retrieving Alist Entries.
* assoc-ref:                             Retrieving Alist Entries.
* assoc-remove!:                         Removing Alist Entries.
* assoc-set!:                            Adding or Setting Alist Entries.
* assq:                                  Retrieving Alist Entries.
* assq-ref:                              Retrieving Alist Entries.
* assq-remove!:                          Removing Alist Entries.
* assq-set!:                             Adding or Setting Alist Entries.
* assv:                                  Retrieving Alist Entries.
* assv-ref:                              Retrieving Alist Entries.
* assv-remove!:                          Removing Alist Entries.
* assv-set!:                             Adding or Setting Alist Entries.
* async:                                 Asyncs.
* async-mark:                            Asyncs.
* atan:                                  Scientific.
* atanh:                                 Scientific.
* backtrace:                             Backtrace.
* basename:                              File System.
* batch-mode?:                           Dynamic Roots.
* begin:                                 begin.
* begin-thread:                          Higher level thread procedures.
* bind:                                  Network Sockets and Communication.
* bit-count:                             Bit Vectors.
* bit-count*:                            Bit Vectors.
* bit-extract:                           Bitwise Operations.
* bit-invert!:                           Bit Vectors.
* bit-position:                          Bit Vectors.
* bit-set*!:                             Bit Vectors.
* boolean?:                              Booleans.
* break:                                 SRFI-1 Searching.
* break!:                                SRFI-1 Searching.
* builtin-bindings:                      Obarray Symbols.
* caar:                                  Pairs.
* cadr:                                  Pairs.
* call-with-current-continuation:        Continuations.
* call-with-dynamic-root:                Dynamic Roots.
* call-with-input-file:                  File Ports.
* call-with-input-string:                String Ports.
* call-with-new-thread:                  Low level thread primitives.
* call-with-output-file:                 File Ports.
* call-with-output-string:               String Ports.
* call-with-values:                      Multiple Values.
* car:                                   Pairs.
* car+cdr:                               SRFI-1 Selectors.
* case:                                  if cond case.
* catch:                                 Catch.
* cd:                                    Processes.
* cdddar:                                Pairs.
* cddddr:                                Pairs.
* cdr:                                   Pairs.
* ceiling:                               Arithmetic.
* char->integer:                         Characters.
* char-alphabetic?:                      Characters.
* char-ci<=?:                            Characters.
* char-ci<?:                             Characters.
* char-ci=?:                             Characters.
* char-ci>=?:                            Characters.
* char-ci>?:                             Characters.
* char-downcase:                         Characters.
* char-is-both?:                         Characters.
* char-lower-case?:                      Characters.
* char-numeric?:                         Characters.
* char-ready?:                           Reading.
* char-set:                              SRFI-14 Creating Character Sets.
* char-set->list:                        SRFI-14 Querying Character Sets.
* char-set->string:                      SRFI-14 Querying Character Sets.
* char-set-adjoin:                       SRFI-14 Character-Set Algebra.
* char-set-adjoin!:                      SRFI-14 Character-Set Algebra.
* char-set-any:                          SRFI-14 Querying Character Sets.
* char-set-complement:                   SRFI-14 Character-Set Algebra.
* char-set-complement!:                  SRFI-14 Character-Set Algebra.
* char-set-contains?:                    SRFI-14 Querying Character Sets.
* char-set-copy:                         SRFI-14 Creating Character Sets.
* char-set-count:                        SRFI-14 Querying Character Sets.
* char-set-cursor:                       SRFI-14 Iterating Over Character Sets.
* char-set-cursor-next:                  SRFI-14 Iterating Over Character Sets.
* char-set-delete:                       SRFI-14 Character-Set Algebra.
* char-set-delete!:                      SRFI-14 Character-Set Algebra.
* char-set-diff+intersection:            SRFI-14 Character-Set Algebra.
* char-set-diff+intersection!:           SRFI-14 Character-Set Algebra.
* char-set-difference:                   SRFI-14 Character-Set Algebra.
* char-set-difference!:                  SRFI-14 Character-Set Algebra.
* char-set-every:                        SRFI-14 Querying Character Sets.
* char-set-filter:                       SRFI-14 Creating Character Sets.
* char-set-filter!:                      SRFI-14 Creating Character Sets.
* char-set-fold:                         SRFI-14 Iterating Over Character Sets.
* char-set-for-each:                     SRFI-14 Iterating Over Character Sets.
* char-set-hash:                         SRFI-14 Predicates/Comparison.
* char-set-intersection:                 SRFI-14 Character-Set Algebra.
* char-set-intersection!:                SRFI-14 Character-Set Algebra.
* char-set-map:                          SRFI-14 Iterating Over Character Sets.
* char-set-ref:                          SRFI-14 Iterating Over Character Sets.
* char-set-size:                         SRFI-14 Querying Character Sets.
* char-set-unfold:                       SRFI-14 Iterating Over Character Sets.
* char-set-unfold!:                      SRFI-14 Iterating Over Character Sets.
* char-set-union:                        SRFI-14 Character-Set Algebra.
* char-set-union!:                       SRFI-14 Character-Set Algebra.
* char-set-xor:                          SRFI-14 Character-Set Algebra.
* char-set-xor!:                         SRFI-14 Character-Set Algebra.
* char-set<=:                            SRFI-14 Predicates/Comparison.
* char-set=:                             SRFI-14 Predicates/Comparison.
* char-set?:                             SRFI-14 Predicates/Comparison.
* char-upcase:                           Characters.
* char-upper-case?:                      Characters.
* char-whitespace?:                      Characters.
* char<=?:                               Characters.
* char<?:                                Characters.
* char=?:                                Characters.
* char>=?:                               Characters.
* char>?:                                Characters.
* char?:                                 Characters.
* chdir:                                 Processes.
* chmod:                                 File System.
* chown:                                 File System.
* chroot:                                Processes.
* circular-list:                         SRFI-1 Constructors.
* circular-list?:                        SRFI-1 Predicates.
* close:                                 Ports and File Descriptors.
* close-all-ports-except:                Close All Ports.
* close-fdes:                            Ports and File Descriptors.
* close-input-port:                      Closing.
* close-output-port:                     Closing.
* close-pipe:                            Pipes.
* close-port:                            Closing.
* closedir:                              File System.
* closure?:                              Procedure Properties.
* command-line <1>:                      Runtime Environment.
* command-line:                          The Top of a Script File.
* compiled-regexp?:                      Rx Regexps.
* complex?:                              Complex Numbers.
* concatenate:                           SRFI-1 Length Append etc.
* concatenate!:                          SRFI-1 Length Append etc.
* cond:                                  if cond case.
* connect:                               Network Sockets and Communication.
* cons:                                  Pairs.
* cons*:                                 List Constructors.
* cons-source:                           Internal Macros.
* copy-file:                             File System.
* copy-random-state:                     Random.
* copy-tree:                             Copying.
* cos:                                   Scientific.
* cosh:                                  Scientific.
* crypt:                                 Encryption.
* ctermid:                               Terminals and Ptys.
* current-error-port:                    Default Ports.
* current-input-port:                    Default Ports.
* current-load-port:                     Loading.
* current-output-port:                   Default Ports.
* current-time:                          Time.
* cuserid:                               User Information.
* debug-disable:                         User level options interfaces.
* debug-enable:                          User level options interfaces.
* debug-object?:                         Using Traps.
* debug-options:                         User level options interfaces.
* debug-options-interface:               Low level options interfaces.
* debug-set!:                            User level options interfaces.
* define:                                Top Level.
* define*:                               define* Reference.
* define*-public:                        define* Reference.
* define-macro:                          Macros.
* define-module:                         Creating Guile Modules.
* define-public:                         Creating Guile Modules.
* define-reader-ctor:                    SRFI-10.
* defined?:                              Binding Reflection.
* defmacro:                              Macros.
* defmacro*:                             define* Reference.
* defmacro*-public:                      define* Reference.
* delete <1>:                            SRFI-1 Deleting.
* delete:                                List Modification.
* delete! <1>:                           SRFI-1 Deleting.
* delete!:                               List Modification.
* delete-duplicates:                     SRFI-1 Deleting.
* delete-duplicates!:                    SRFI-1 Deleting.
* delete-file:                           File System.
* delete1!:                              List Modification.
* delq:                                  List Modification.
* delq!:                                 List Modification.
* delq1!:                                List Modification.
* delv:                                  List Modification.
* delv!:                                 List Modification.
* delv1!:                                List Modification.
* destroy-guardian!:                     Guardians.
* dfa-continuable?:                      Rx Regexps.
* dfa-final-tag:                         Rx Regexps.
* dfa-fork:                              Rx Regexps.
* dimensions->uniform-array:             Uniform Arrays.
* directory-stream?:                     File System.
* dirname:                               File System.
* display:                               Writing.
* display-application:                   Examining Stack Frames.
* display-backtrace:                     Examining the Stack.
* display-error:                         Handling Errors.
* do:                                    while do.
* dotted-list?:                          SRFI-1 Predicates.
* doubly-weak-hash-table?:               Weak key hashes.
* drain-input:                           Reading.
* drop:                                  SRFI-1 Selectors.
* drop-right:                            SRFI-1 Selectors.
* drop-right!:                           SRFI-1 Selectors.
* drop-while:                            SRFI-1 Searching.
* dup:                                   Ports and File Descriptors.
* dup->fdes:                             Ports and File Descriptors.
* dup->inport:                           Ports and File Descriptors.
* dup->outport:                          Ports and File Descriptors.
* dup->port:                             Ports and File Descriptors.
* dup2:                                  Ports and File Descriptors.
* duplicate-port:                        Ports and File Descriptors.
* dynamic-args-call:                     Low level dynamic linking.
* dynamic-call:                          Low level dynamic linking.
* dynamic-func:                          Low level dynamic linking.
* dynamic-link:                          Low level dynamic linking.
* dynamic-object?:                       Low level dynamic linking.
* dynamic-root:                          Dynamic Roots.
* dynamic-unlink:                        Low level dynamic linking.
* dynamic-wind:                          Dynamic Wind.
* effective-version:                     Build Config.
* eighth:                                SRFI-1 Selectors.
* enclose-array:                         Conventional Arrays.
* end-of-char-set?:                      SRFI-14 Iterating Over Character Sets.
* endgrent:                              User Information.
* endhostent:                            Network Databases.
* endnetent:                             Network Databases.
* endprotoent:                           Network Databases.
* endpwent:                              User Information.
* endservent:                            Network Databases.
* entity?:                               Objects.
* environ:                               Runtime Environment.
* eof-object?:                           Reading.
* eq?:                                   Equality.
* equal?:                                Equality.
* eqv?:                                  Equality.
* error <1>:                             Handling Errors.
* error:                                 Error Reporting.
* eval:                                  Fly Evaluation.
* eval-disable:                          Evaluator Behaviour.
* eval-enable:                           Evaluator Behaviour.
* eval-options:                          Evaluator Behaviour.
* eval-options-interface <1>:            Low level options interfaces.
* eval-options-interface:                Evaluator Behaviour.
* eval-set!:                             Evaluator Behaviour.
* eval-string:                           Fly Evaluation.
* eval2:                                 Strange Eval.
* evaluator-traps-interface <1>:         Low level options interfaces.
* evaluator-traps-interface:             Evaluator Behaviour.
* even?:                                 Integer Operations.
* every:                                 SRFI-1 Searching.
* exact->inexact:                        Exactness.
* exact?:                                Exactness.
* execl:                                 Processes.
* execle:                                Processes.
* execlp:                                Processes.
* exp:                                   Scientific.
* expect:                                Expect.
* expect-strings:                        Expect.
* export:                                Creating Guile Modules.
* expt:                                  Scientific.
* false-if-exception:                    Error Reporting.
* fchmod:                                File System.
* fchown:                                File System.
* fcntl:                                 Ports and File Descriptors.
* fdes->inport:                          Ports and File Descriptors.
* fdes->outport:                         Ports and File Descriptors.
* fdes->ports:                           Ports and File Descriptors.
* fdopen:                                Ports and File Descriptors.
* feature?:                              Feature Manipulation.
* fflush:                                Writing.
* fifth:                                 SRFI-1 Selectors.
* file-port?:                            File Ports.
* fileno:                                Ports and File Descriptors.
* filter:                                SRFI-1 Filtering and Partitioning.
* filter!:                               SRFI-1 Filtering and Partitioning.
* filter-map:                            SRFI-1 Fold and Map.
* find:                                  SRFI-1 Searching.
* find-tail:                             SRFI-1 Searching.
* first:                                 SRFI-1 Selectors.
* flock:                                 Ports and File Descriptors.
* floor:                                 Arithmetic.
* fluid-ref:                             Fluids.
* fluid-set!:                            Fluids.
* fluid?:                                Fluids.
* flush-all-ports:                       Writing.
* fn:                                    Defining new Scheme procedures in C.
* fold:                                  SRFI-1 Fold and Map.
* fold-right:                            SRFI-1 Fold and Map.
* for-each <1>:                          SRFI-1 Fold and Map.
* for-each:                              List Mapping.
* force:                                 Delayed Evaluation.
* force-output:                          Writing.
* format:                                Formatted Output.
* fourth:                                SRFI-1 Selectors.
* frame-arguments:                       Examining Stack Frames.
* frame-evaluating-args?:                Examining Stack Frames.
* frame-next:                            Examining Stack Frames.
* frame-number:                          Examining Stack Frames.
* frame-overflow?:                       Examining Stack Frames.
* frame-previous:                        Examining Stack Frames.
* frame-procedure:                       Examining Stack Frames.
* frame-procedure?:                      Examining Stack Frames.
* frame-real?:                           Examining Stack Frames.
* frame-source:                          Examining Stack Frames.
* frame?:                                Examining Stack Frames.
* fstat:                                 File System.
* fsync:                                 Ports and File Descriptors.
* ftell:                                 Random Access.
* ftruncate:                             Random Access.
* gc:                                    Garbage Collection.
* gc-stats:                              Garbage Collection.
* gcd:                                   Integer Operations.
* gensym:                                Symbol Primitives.
* gentemp:                               Obarray Symbols.
* get-internal-real-time:                Time.
* get-internal-run-time:                 Time.
* get-output-string:                     String Ports.
* get-print-state:                       Writing.
* getcwd:                                Processes.
* getegid:                               Processes.
* getenv:                                Runtime Environment.
* geteuid:                               Processes.
* getgid:                                Processes.
* getgr:                                 User Information.
* getgrent:                              User Information.
* getgrgid:                              User Information.
* getgrnam:                              User Information.
* getgroups:                             Processes.
* gethost:                               Network Databases.
* gethostbyaddr:                         Network Databases.
* gethostbyname:                         Network Databases.
* gethostent:                            Network Databases.
* gethostname:                           System Identification.
* getitimer:                             Signals.
* getlogin:                              User Information.
* getnet:                                Network Databases.
* getnetbyaddr:                          Network Databases.
* getnetbyname:                          Network Databases.
* getnetent:                             Network Databases.
* getopt-long:                           getopt-long Reference.
* getpass:                               Encryption.
* getpeername:                           Network Sockets and Communication.
* getpgrp:                               Processes.
* getpid:                                Processes.
* getppid:                               Processes.
* getpriority:                           Processes.
* getproto:                              Network Databases.
* getprotobyname:                        Network Databases.
* getprotobynumber:                      Network Databases.
* getprotoent:                           Network Databases.
* getpw:                                 User Information.
* getpwent:                              User Information.
* getpwnam:                              User Information.
* getpwuid:                              User Information.
* getserv:                               Network Databases.
* getservbyname:                         Network Databases.
* getservbyport:                         Network Databases.
* getservent:                            Network Databases.
* getsockname:                           Network Sockets and Communication.
* getsockopt:                            Network Sockets and Communication.
* gettimeofday:                          Time.
* getuid:                                Processes.
* GH_ALLOW_INTS:                         Defining new Scheme procedures in C.
* gh_append:                             Calling Scheme procedures from C.
* gh_append2:                            Calling Scheme procedures from C.
* gh_append3:                            Calling Scheme procedures from C.
* gh_append4:                            Calling Scheme procedures from C.
* gh_apply:                              Calling Scheme procedures from C.
* gh_assoc:                              Calling Scheme procedures from C.
* gh_assq:                               Calling Scheme procedures from C.
* gh_assv:                               Calling Scheme procedures from C.
* gh_bool2scm:                           C to Scheme.
* gh_boolean_p:                          Type predicates.
* gh_c:                                  Calling Scheme procedures from C.
* gh_call0:                              Calling Scheme procedures from C.
* gh_call1:                              Calling Scheme procedures from C.
* gh_call2:                              Calling Scheme procedures from C.
* gh_call3:                              Calling Scheme procedures from C.
* gh_car:                                Calling Scheme procedures from C.
* gh_catch:                              Calling Scheme procedures from C.
* gh_cdr:                                Calling Scheme procedures from C.
* gh_char2scm:                           C to Scheme.
* gh_char_p:                             Type predicates.
* gh_chars2byvect:                       C to Scheme.
* gh_cons:                               Calling Scheme procedures from C.
* GH_DEFER_INTS:                         Defining new Scheme procedures in C.
* gh_define:                             Calling Scheme procedures from C.
* gh_double2scm:                         C to Scheme.
* gh_doubles2dvect:                      C to Scheme.
* gh_doubles2scm:                        C to Scheme.
* gh_enter:                              Starting and controlling the interpreter.
* gh_eq_p:                               Equality predicates.
* gh_equal_p:                            Equality predicates.
* gh_eqv_p:                              Equality predicates.
* gh_eval_file:                          Executing Scheme code.
* gh_eval_str:                           Executing Scheme code.
* gh_exact_p:                            Type predicates.
* gh_floats2fvect:                       C to Scheme.
* gh_get_substr:                         Scheme to C.
* gh_inexact_p:                          Type predicates.
* gh_ints2scm:                           C to Scheme.
* gh_is_eq:                              Calling Scheme procedures from C.
* gh_is_equal:                           Calling Scheme procedures from C.
* gh_is_eqv:                             Calling Scheme procedures from C.
* gh_length:                             Calling Scheme procedures from C.
* gh_list:                               Calling Scheme procedures from C.
* gh_list_p:                             Type predicates.
* gh_list_ref:                           Calling Scheme procedures from C.
* gh_list_tail:                          Calling Scheme procedures from C.
* gh_list_to_vector:                     Calling Scheme procedures from C.
* gh_load:                               Executing Scheme code.
* gh_long2scm:                           C to Scheme.
* gh_longs2ivect:                        C to Scheme.
* gh_make_vector:                        Calling Scheme procedures from C.
* gh_member:                             Calling Scheme procedures from C.
* gh_memq:                               Calling Scheme procedures from C.
* gh_memv:                               Calling Scheme procedures from C.
* gh_new_procedure:                      Defining new Scheme procedures in C.
* gh_null_p:                             Equality predicates.
* gh_obj_length:                         Calling Scheme procedures from C.
* gh_pair_p:                             Type predicates.
* gh_procedure_p:                        Type predicates.
* gh_repl:                               Starting and controlling the interpreter.
* gh_reverse:                            Calling Scheme procedures from C.
* gh_scm2bool:                           Scheme to C.
* gh_scm2char:                           Scheme to C.
* gh_scm2double:                         Scheme to C.
* gh_scm2long:                           Scheme to C.
* gh_scm2ulong:                          Scheme to C.
* gh_set_car_x:                          Calling Scheme procedures from C.
* gh_set_cdr_x:                          Calling Scheme procedures from C.
* gh_set_substr:                         C to Scheme.
* gh_shorts2svect:                       C to Scheme.
* gh_str02scm:                           C to Scheme.
* gh_str2scm:                            C to Scheme.
* gh_string_equal_p:                     Equality predicates.
* gh_symbol2scm:                         C to Scheme.
* gh_symbol_p:                           Type predicates.
* gh_throw:                              Calling Scheme procedures from C.
* gh_ulong2scm:                          C to Scheme.
* gh_ulongs2uvect:                       C to Scheme.
* gh_vector:                             Calling Scheme procedures from C.
* gh_vector_length:                      Calling Scheme procedures from C.
* gh_vector_p:                           Type predicates.
* gh_vector_ref:                         Calling Scheme procedures from C.
* gh_vector_set:                         Calling Scheme procedures from C.
* gmtime:                                Time.
* guardian-destroyed?:                   Guardians.
* guardian-greedy?:                      Guardians.
* GUILE_CHECK_RETVAL:                    Autoconf Macros.
* GUILE_FLAGS:                           Autoconf Macros.
* GUILE_MODULE_AVAILABLE:                Autoconf Macros.
* GUILE_MODULE_CHECK:                    Autoconf Macros.
* GUILE_MODULE_EXPORTS:                  Autoconf Macros.
* GUILE_MODULE_REQUIRED:                 Autoconf Macros.
* GUILE_MODULE_REQUIRED_EXPORT:          Autoconf Macros.
* GUILE_PROGS:                           Autoconf Macros.
* GUILE_SITE_DIR:                        Autoconf Macros.
* hash:                                  Hash Table Reference.
* hash-create-handle!:                   Hash Table Reference.
* hash-fold:                             Hash Table Reference.
* hash-get-handle:                       Hash Table Reference.
* hash-ref:                              Hash Table Reference.
* hash-remove!:                          Hash Table Reference.
* hash-set!:                             Hash Table Reference.
* hashq:                                 Hash Table Reference.
* hashq-create-handle!:                  Hash Table Reference.
* hashq-get-handle:                      Hash Table Reference.
* hashq-ref:                             Hash Table Reference.
* hashq-remove!:                         Hash Table Reference.
* hashq-set!:                            Hash Table Reference.
* hashv:                                 Hash Table Reference.
* hashv-create-handle!:                  Hash Table Reference.
* hashv-get-handle:                      Hash Table Reference.
* hashv-ref:                             Hash Table Reference.
* hashv-remove!:                         Hash Table Reference.
* hashv-set!:                            Hash Table Reference.
* hashx-create-handle!:                  Hash Table Reference.
* hashx-get-handle:                      Hash Table Reference.
* hashx-ref:                             Hash Table Reference.
* hashx-set!:                            Hash Table Reference.
* hook->list:                            Hook Reference.
* hook-empty?:                           Hook Reference.
* hook?:                                 Hook Reference.
* hostent:addr-list:                     Network Databases.
* hostent:addrtype:                      Network Databases.
* hostent:aliases:                       Network Databases.
* hostent:length:                        Network Databases.
* hostent:name:                          Network Databases.
* htonl:                                 Network Sockets and Communication.
* htons:                                 Network Sockets and Communication.
* if:                                    if cond case.
* imag-part:                             Complex.
* inet-aton:                             Network Address Conversion.
* inet-lnaof:                            Network Address Conversion.
* inet-makeaddr:                         Network Address Conversion.
* inet-netof:                            Network Address Conversion.
* inet-ntoa:                             Network Address Conversion.
* inet-ntop:                             Network Address Conversion.
* inet-pton:                             Network Address Conversion.
* inexact->exact:                        Exactness.
* inexact?:                              Exactness.
* input-port?:                           Ports.
* integer->char:                         Characters.
* integer-expt:                          Bitwise Operations.
* integer-length:                        Bitwise Operations.
* integer?:                              Integers.
* interaction-environment:               Fly Evaluation.
* intern-symbol:                         Obarray Symbols.
* iota:                                  SRFI-1 Constructors.
* isatty?:                               Terminals and Ptys.
* join-thread:                           Low level thread primitives.
* key:                                   Evaluator trap options.
* keyword->symbol:                       Keyword Procedures.
* keyword-dash-symbol:                   Keyword Primitives.
* keyword?:                              Keyword Primitives.
* kill:                                  Signals.
* lambda:                                Lambda.
* lambda*:                               lambda* Reference.
* last:                                  SRFI-1 Selectors.
* last-pair:                             List Selection.
* last-stack-frame:                      Capturing the Stack or Innermost Stack Frame.
* lazy-catch:                            Lazy Catch.
* lchown:                                File System.
* lcm:                                   Integer Operations.
* length:                                List Selection.
* length+:                               SRFI-1 Length Append etc.
* let <1>:                               while do.
* let:                                   Local Bindings.
* let*:                                  Local Bindings.
* let-keywords:                          let-keywords Reference.
* let-optional:                          let-optional Reference.
* let-optional*:                         let-optional Reference.
* letrec:                                Local Bindings.
* link:                                  File System.
* list:                                  List Constructors.
* list->char-set:                        SRFI-14 Creating Character Sets.
* list->char-set!:                       SRFI-14 Creating Character Sets.
* list->string:                          String Constructors.
* list->TAGvector:                       SRFI-4 - Procedures.
* list->uniform-array:                   Uniform Arrays.
* list->uniform-vector:                  Uniform Arrays.
* list->vector:                          Vector Creation.
* list->weak-vector:                     Weak vectors.
* list-cdr-ref:                          List Selection.
* list-cdr-set!:                         List Modification.
* list-copy:                             List Constructors.
* list-head:                             List Selection.
* list-index:                            SRFI-1 Searching.
* list-ref:                              List Selection.
* list-set!:                             List Modification.
* list-tabulate:                         SRFI-1 Constructors.
* list-tail:                             List Selection.
* list=:                                 SRFI-1 Predicates.
* list?:                                 List Predicates.
* listen:                                Network Sockets and Communication.
* load:                                  Loading.
* load-from-path:                        Loading.
* local-eval:                            Local Evaluation.
* localtime:                             Time.
* lock-mutex:                            Low level thread primitives.
* log:                                   Scientific.
* log10:                                 Scientific.
* logand:                                Bitwise Operations.
* logbit?:                               Bitwise Operations.
* logcount:                              Bitwise Operations.
* logior:                                Bitwise Operations.
* lognot:                                Bitwise Operations.
* logtest:                               Bitwise Operations.
* logxor:                                Bitwise Operations.
* lset-adjoin:                           SRFI-1 Set Operations.
* lset-adjoin!:                          SRFI-1 Set Operations.
* lset-diff+intersection:                SRFI-1 Set Operations.
* lset-diff+intersection!:               SRFI-1 Set Operations.
* lset-difference:                       SRFI-1 Set Operations.
* lset-difference!:                      SRFI-1 Set Operations.
* lset-intersection:                     SRFI-1 Set Operations.
* lset-intersection!:                    SRFI-1 Set Operations.
* lset-union:                            SRFI-1 Set Operations.
* lset-union!:                           SRFI-1 Set Operations.
* lset-xor:                              SRFI-1 Set Operations.
* lset-xor!:                             SRFI-1 Set Operations.
* lset<=:                                SRFI-1 Set Operations.
* lset=:                                 SRFI-1 Set Operations.
* lstat:                                 File System.
* macro-name:                            Internal Macros.
* macro-transformer:                     Internal Macros.
* macro-type:                            Internal Macros.
* macro?:                                Internal Macros.
* magnitude:                             Complex.
* main_prog:                             Starting and controlling the interpreter.
* major-version:                         Build Config.
* make-arbiter:                          Arbiters.
* make-array:                            Conventional Arrays.
* make-class-object:                     Objects.
* make-condition-variable:               Low level thread primitives.
* make-doubly-weak-hash-table:           Weak key hashes.
* make-fluid:                            Fluids.
* make-guardian:                         Guardians.
* make-hash-table:                       Hash Table Reference.
* make-hook:                             Hook Reference.
* make-keyword-from-dash-symbol:         Keyword Primitives.
* make-list:                             List Constructors.
* make-mutex:                            Low level thread primitives.
* make-object-property:                  Object Properties.
* make-polar:                            Complex.
* make-procedure-with-setter:            Procedures with Setters.
* make-record-type:                      Records.
* make-rectangular:                      Complex.
* make-regexp:                           Regexp Functions.
* make-shared-array:                     Conventional Arrays.
* make-shared-substring:                 Shared Substrings.
* make-soft-port:                        Soft Ports.
* make-stack:                            Capturing the Stack or Innermost Stack Frame.
* make-string:                           String Constructors.
* make-struct:                           Structure Basics.
* make-struct-layout:                    Structure Layout.
* make-subclass-object:                  Objects.
* make-TAGvector:                        SRFI-4 - Procedures.
* make-thread:                           Higher level thread procedures.
* make-undefined-variable:               Variables.
* make-uniform-array:                    Uniform Arrays.
* make-uniform-vector:                   Uniform Arrays.
* make-variable:                         Variables.
* make-vector:                           Vector Creation.
* make-vtable-vtable:                    Vtables.
* make-weak-key-hash-table:              Weak key hashes.
* make-weak-value-hash-table:            Weak key hashes.
* make-weak-vector:                      Weak vectors.
* malloc-stats:                          Garbage Collection.
* map <1>:                               SRFI-1 Fold and Map.
* map:                                   List Mapping.
* map!:                                  SRFI-1 Fold and Map.
* map-in-order:                          List Mapping.
* mask-signals:                          Asyncs.
* match:count:                           Match Structures.
* match:end:                             Match Structures.
* match:prefix:                          Match Structures.
* match:start:                           Match Structures.
* match:string:                          Match Structures.
* match:substring:                       Match Structures.
* match:suffix:                          Match Structures.
* max:                                   Arithmetic.
* member <1>:                            SRFI-1 Searching.
* member:                                List Searching.
* memoized-environment:                  Decoding Memoized Source Expressions.
* memoized?:                             Decoding Memoized Source Expressions.
* memq:                                  List Searching.
* memv:                                  List Searching.
* merge:                                 Sorting.
* merge!:                                Sorting.
* micro-version:                         Build Config.
* min:                                   Arithmetic.
* minor-version:                         Build Config.
* mkdir:                                 File System.
* mknod:                                 File System.
* mkstemp!:                              File System.
* mktime:                                Time.
* modulo:                                Integer Operations.
* monitor:                               Higher level thread procedures.
* move->fdes:                            Ports and File Descriptors.
* negative?:                             Comparison.
* netent:addrtype:                       Network Databases.
* netent:aliases:                        Network Databases.
* netent:name:                           Network Databases.
* netent:net:                            Network Databases.
* newline:                               Writing.
* nice:                                  Processes.
* nil-car:                               Emacs Lisp Support.
* nil-cdr:                               Emacs Lisp Support.
* nil-cons:                              Emacs Lisp Support.
* nil-eq:                                Emacs Lisp Support.
* ninth:                                 SRFI-1 Selectors.
* noop:                                  Asyncs.
* not:                                   Booleans.
* not-pair?:                             SRFI-1 Predicates.
* ntohl:                                 Network Sockets and Communication.
* ntohs:                                 Network Sockets and Communication.
* null:                                  Emacs Lisp Support.
* null-environment:                      Environments.
* null-list?:                            SRFI-1 Predicates.
* null?:                                 List Predicates.
* number->string:                        Conversion.
* number?:                               Numerical Tower.
* object->string:                        General Conversion.
* object-address:                        Garbage Collection.
* object-properties:                     Old-fashioned Properties.
* object-property:                       Old-fashioned Properties.
* odd?:                                  Integer Operations.
* open:                                  Ports and File Descriptors.
* open-fdes:                             Ports and File Descriptors.
* open-file:                             File Ports.
* open-input-file:                       File Ports.
* open-input-pipe:                       Pipes.
* open-input-string:                     String Ports.
* open-output-file:                      File Ports.
* open-output-pipe:                      Pipes.
* open-output-string:                    String Ports.
* open-pipe:                             Pipes.
* opendir:                               File System.
* operator?:                             Objects.
* option-ref:                            option-ref Reference.
* or:                                    and or.
* output-port?:                          Ports.
* pair-fold:                             SRFI-1 Fold and Map.
* pair-fold-right:                       SRFI-1 Fold and Map.
* pair-for-each:                         SRFI-1 Fold and Map.
* pair?:                                 Pairs.
* parse-path:                            Build Config.
* partition:                             SRFI-1 Filtering and Partitioning.
* partition!:                            SRFI-1 Filtering and Partitioning.
* pause:                                 Signals.
* pclose:                                Pipes.
* peek-char:                             Reading.
* pipe:                                  Ports and File Descriptors.
* popen:                                 Pipes.
* port->fdes:                            Ports and File Descriptors.
* port-closed?:                          Closing.
* port-column:                           Reading.
* port-filename:                         File Ports.
* port-for-each:                         Ports and File Descriptors.
* port-line:                             Reading.
* port-mode <1>:                         Ports and File Descriptors.
* port-mode:                             File Ports.
* port-revealed:                         Ports and File Descriptors.
* port-with-print-state:                 Writing.
* port?:                                 Ports.
* positive?:                             Comparison.
* pretty-print:                          Pretty Printing.
* primitive-eval:                        Fly Evaluation.
* primitive-exit:                        Processes.
* primitive-fork:                        Processes.
* primitive-load:                        Loading.
* primitive-load-path:                   Loading.
* primitive-make-property:               Property Primitives.
* primitive-move->fdes:                  Ports and File Descriptors.
* primitive-property-del!:               Property Primitives.
* primitive-property-ref:                Property Primitives.
* primitive-property-set!:               Property Primitives.
* print-disable:                         User level options interfaces.
* print-enable:                          User level options interfaces.
* print-options:                         User level options interfaces.
* print-options-interface <1>:           Low level options interfaces.
* print-options-interface:               Writing.
* print-set!:                            User level options interfaces.
* procedure:                             Procedures with Setters.
* procedure->macro:                      Internal Macros.
* procedure->memoizing-macro:            Internal Macros.
* procedure->syntax:                     Internal Macros.
* procedure-documentation:               Procedure Properties.
* procedure-environment:                 Procedure Properties.
* procedure-name:                        Procedure Properties.
* procedure-properties:                  Procedure Properties.
* procedure-property:                    Procedure Properties.
* procedure-source:                      Procedure Properties.
* procedure-with-setter?:                Procedures with Setters.
* procedure?:                            Procedure Properties.
* program-arguments <1>:                 Runtime Environment.
* program-arguments:                     The Top of a Script File.
* promise?:                              Delayed Evaluation.
* proper-list?:                          SRFI-1 Predicates.
* protoent:aliases:                      Network Databases.
* protoent:name:                         Network Databases.
* protoent:proto:                        Network Databases.
* provide:                               Feature Manipulation.
* provided?:                             Feature Manipulation.
* PTR2SCM:                               Non-immediate objects.
* putenv:                                Runtime Environment.
* pwd:                                   Processes.
* quit:                                  Dynamic Roots.
* quotient:                              Integer Operations.
* raise:                                 Signals.
* random:                                Random.
* random:exp:                            Random.
* random:hollow-sphere!:                 Random.
* random:normal:                         Random.
* random:normal-vector!:                 Random.
* random:solid-sphere!:                  Random.
* random:uniform:                        Random.
* rational?:                             Reals and Rationals.
* read:                                  Scheme Read.
* read-and-eval!:                        Strange Eval.
* read-char:                             Reading.
* read-delimited:                        Line/Delimited.
* read-delimited!:                       Line/Delimited.
* read-disable <1>:                      User level options interfaces.
* read-disable:                          Scheme Read.
* read-enable <1>:                       User level options interfaces.
* read-enable:                           Scheme Read.
* read-hash-extend:                      Reader Extensions.
* read-line:                             Line/Delimited.
* read-line!:                            Line/Delimited.
* read-only-string?:                     Read Only Strings.
* read-options <1>:                      User level options interfaces.
* read-options:                          Scheme Read.
* read-options-interface <1>:            Low level options interfaces.
* read-options-interface:                Scheme Read.
* read-set! <1>:                         User level options interfaces.
* read-set!:                             Scheme Read.
* read-string!/partial:                  Block Reading and Writing.
* readdir:                               File System.
* readlink:                              File System.
* real-part:                             Complex.
* real?:                                 Reals and Rationals.
* receive:                               Multiple Values.
* record-accessor:                       Records.
* record-constructor:                    Records.
* record-modifier:                       Records.
* record-predicate:                      Records.
* record-type-descriptor:                Records.
* record-type-fields:                    Records.
* record-type-name:                      Records.
* record?:                               Records.
* recv!:                                 Network Sockets and Communication.
* recvfrom!:                             Network Sockets and Communication.
* redirect-port:                         Ports and File Descriptors.
* reduce:                                SRFI-1 Fold and Map.
* reduce-right:                          SRFI-1 Fold and Map.
* regcomp:                               Rx Regexps.
* regexec:                               Rx Regexps.
* regexp->dfa:                           Rx Regexps.
* regexp-exec:                           Regexp Functions.
* regexp-match?:                         Match Structures.
* regexp-quote:                          Backslash Escapes.
* regexp-substitute:                     Regexp Functions.
* regexp-substitute/global:              Regexp Functions.
* regexp?:                               Regexp Functions.
* release-arbiter:                       Arbiters.
* release-port-handle:                   Ports and File Descriptors.
* remainder:                             Integer Operations.
* remove:                                SRFI-1 Filtering and Partitioning.
* remove!:                               SRFI-1 Filtering and Partitioning.
* remove-hook!:                          Hook Reference.
* rename:                                File System.
* rename-file:                           File System.
* reset-dfa!:                            Rx Regexps.
* reset-hook!:                           Hook Reference.
* restore-signals:                       Signals.
* restricted-vector-sort!:               Sorting.
* reverse:                               Append/Reverse.
* reverse!:                              Append/Reverse.
* reverse-list->string:                  SRFI-13 List/String Conversion.
* rewinddir:                             File System.
* rmdir:                                 File System.
* round:                                 Arithmetic.
* run-asyncs:                            Asyncs.
* run-hook:                              Hook Reference.
* scheme-report-environment:             Environments.
* scm-error <1>:                         Handling Errors.
* scm-error:                             Error Reporting.
* SCM2PTR:                               Non-immediate objects.
* scm_abs:                               Arithmetic.
* scm_accept:                            Network Sockets and Communication.
* scm_access:                            File System.
* scm_acons:                             Adding or Setting Alist Entries.
* scm_acosh:                             Primitive Numerics.
* scm_add_feature:                       Feature Manipulation.
* scm_add_hook_x:                        Hook Reference.
* scm_alarm:                             Signals.
* scm_append:                            Append/Reverse.
* scm_append_x:                          Append/Reverse.
* SCM_ARG1:                              Signalling Type Errors.
* SCM_ARG2:                              Signalling Type Errors.
* SCM_ARG3:                              Signalling Type Errors.
* SCM_ARG4:                              Signalling Type Errors.
* SCM_ARG5:                              Signalling Type Errors.
* SCM_ARG6:                              Signalling Type Errors.
* SCM_ARG7:                              Signalling Type Errors.
* SCM_ARGn:                              Signalling Type Errors.
* scm_array_contents:                    Conventional Arrays.
* scm_array_copy_x:                      Conventional Arrays.
* scm_array_dimensions:                  Conventional Arrays.
* scm_array_fill_x:                      Conventional Arrays.
* scm_array_for_each:                    Array Mapping.
* scm_array_in_bounds_p:                 Conventional Arrays.
* scm_array_index_map_x:                 Array Mapping.
* scm_array_map_x:                       Array Mapping.
* scm_array_p:                           Conventional Arrays.
* scm_array_prototype:                   Uniform Arrays.
* scm_array_rank:                        Conventional Arrays.
* scm_array_set_x:                       Conventional Arrays.
* scm_array_to_list:                     Conventional Arrays.
* scm_ash:                               Bitwise Operations.
* scm_asinh:                             Primitive Numerics.
* SCM_ASSERT:                            Signalling Type Errors.
* scm_assoc:                             Retrieving Alist Entries.
* scm_assoc_ref:                         Retrieving Alist Entries.
* scm_assoc_remove_x:                    Removing Alist Entries.
* scm_assoc_set_x:                       Adding or Setting Alist Entries.
* scm_assq:                              Retrieving Alist Entries.
* scm_assq_ref:                          Retrieving Alist Entries.
* scm_assq_remove_x:                     Removing Alist Entries.
* scm_assq_set_x:                        Adding or Setting Alist Entries.
* scm_assv:                              Retrieving Alist Entries.
* scm_assv_ref:                          Retrieving Alist Entries.
* scm_assv_remove_x:                     Removing Alist Entries.
* scm_assv_set_x:                        Adding or Setting Alist Entries.
* scm_async:                             Asyncs.
* scm_async_mark:                        Asyncs.
* scm_atanh:                             Primitive Numerics.
* scm_backtrace:                         Backtrace.
* scm_basename:                          File System.
* scm_bind:                              Network Sockets and Communication.
* scm_bit_count:                         Bit Vectors.
* scm_bit_count_star:                    Bit Vectors.
* scm_bit_extract:                       Bitwise Operations.
* scm_bit_invert_x:                      Bit Vectors.
* scm_bit_position:                      Bit Vectors.
* scm_bit_set_star_x:                    Bit Vectors.
* SCM_BOOL_F:                            Boolean Data.
* SCM_BOOL_NOT:                          Boolean Data.
* SCM_BOOL_T:                            Boolean Data.
* scm_boolean_p:                         Booleans.
* scm_boot_guile:                        Guile Initialization Functions.
* scm_builtin_bindings:                  Obarray Symbols.
* scm_c_call_with_current_module:        Accessing Modules from C.
* scm_c_define <1>:                      Accessing Modules from C.
* scm_c_define:                          Top Level.
* scm_c_define_gsubr:                    Subrs.
* scm_c_define_module:                   Accessing Modules from C.
* scm_c_export:                          Accessing Modules from C.
* scm_c_hook_add:                        C Hooks.
* scm_c_hook_init:                       C Hooks.
* scm_c_hook_remove:                     C Hooks.
* scm_c_lookup:                          Accessing Modules from C.
* scm_c_module_define:                   Accessing Modules from C.
* scm_c_module_lookup:                   Accessing Modules from C.
* scm_c_resolve_module:                  Accessing Modules from C.
* scm_c_run_hook:                        Hook Reference.
* scm_c_use_module:                      Accessing Modules from C.
* SCM_CAAR:                              Pair Data.
* SCM_CADR:                              Pair Data.
* scm_call_with_dynamic_root:            Dynamic Roots.
* scm_call_with_input_string:            String Ports.
* scm_call_with_output_string:           String Ports.
* SCM_CAR:                               Pair Data.
* scm_catch:                             Catch.
* SCM_CDAR:                              Pair Data.
* SCM_CDDDDR:                            Pair Data.
* SCM_CDR:                               Pair Data.
* SCM_CELL_OBJECT:                       Accessing Cell Entries.
* SCM_CELL_TYPE:                         Heap Cell Type Information.
* SCM_CELL_WORD:                         Accessing Cell Entries.
* SCM_CHAR:                              Character Data.
* scm_char_alphabetic_p:                 Characters.
* scm_char_downcase:                     Characters.
* scm_char_is_both_p:                    Characters.
* scm_char_lower_case_p:                 Characters.
* scm_char_numeric_p:                    Characters.
* scm_char_p:                            Characters.
* scm_char_ready_p:                      Reading.
* scm_char_to_integer:                   Characters.
* scm_char_upcase:                       Characters.
* scm_char_upper_case_p:                 Characters.
* scm_char_whitespace_p:                 Characters.
* SCM_CHARP:                             Character Data.
* scm_chdir:                             Processes.
* scm_chmod:                             File System.
* scm_chown:                             File System.
* scm_chroot:                            Processes.
* scm_close:                             Ports and File Descriptors.
* scm_close_all_ports_except:            Close All Ports.
* scm_close_fdes:                        Ports and File Descriptors.
* scm_close_input_port:                  Closing.
* scm_close_output_port:                 Closing.
* scm_close_port:                        Closing.
* scm_closedir:                          File System.
* scm_closure_p:                         Procedure Properties.
* SCM_CLOSUREP:                          Closures.
* SCM_CODE:                              Closures.
* scm_connect:                           Network Sockets and Communication.
* scm_cons <1>:                          Pairs.
* scm_cons:                              Pair Data.
* scm_cons_source:                       Internal Macros.
* scm_cons_star:                         List Constructors.
* SCM_CONSP <1>:                         Basic Rules for Accessing Cell Entries.
* SCM_CONSP:                             Pair Data.
* scm_copy_file:                         File System.
* scm_copy_random_state:                 Random.
* scm_copy_tree:                         Copying.
* scm_crypt:                             Encryption.
* scm_ctermid:                           Terminals and Ptys.
* scm_current_error_port:                Default Ports.
* scm_current_input_port:                Default Ports.
* scm_current_load_port:                 Loading.
* scm_current_module:                    Accessing Modules from C.
* scm_current_output_port:               Default Ports.
* scm_current_time:                      Time.
* scm_cuserid:                           User Information.
* scm_debug_object_p:                    Using Traps.
* scm_debug_options:                     Low level options interfaces.
* scm_define <1>:                        Accessing Modules from C.
* scm_define:                            Top Level.
* scm_definedp:                          Binding Reflection.
* scm_delete:                            List Modification.
* scm_delete1_x:                         List Modification.
* scm_delete_file:                       File System.
* scm_delete_x:                          List Modification.
* scm_delq:                              List Modification.
* scm_delq1_x:                           List Modification.
* scm_delq_x:                            List Modification.
* scm_delv:                              List Modification.
* scm_delv1_x:                           List Modification.
* scm_delv_x:                            List Modification.
* scm_destroy_guardian_x:                Guardians.
* scm_dimensions_to_uniform_array:       Uniform Arrays.
* scm_directory_stream_p:                File System.
* scm_dirname:                           File System.
* scm_display_application:               Examining Stack Frames.
* scm_display_backtrace:                 Examining the Stack.
* scm_display_error:                     Handling Errors.
* scm_doubly_weak_hash_table_p:          Weak key hashes.
* scm_drain_input:                       Reading.
* scm_dup2:                              Ports and File Descriptors.
* scm_dup_to_fdes:                       Ports and File Descriptors.
* scm_dynamic_args_call:                 Low level dynamic linking.
* scm_dynamic_call:                      Low level dynamic linking.
* scm_dynamic_func:                      Low level dynamic linking.
* scm_dynamic_link:                      Low level dynamic linking.
* scm_dynamic_object_p:                  Low level dynamic linking.
* scm_dynamic_root:                      Dynamic Roots.
* scm_dynamic_unlink:                    Low level dynamic linking.
* scm_dynamic_wind:                      Dynamic Wind.
* scm_effective_version:                 Build Config.
* scm_enclose_array:                     Conventional Arrays.
* scm_entity_p:                          Objects.
* SCM_ENV:                               Closures.
* scm_environ:                           Runtime Environment.
* scm_eof_object_p:                      Reading.
* SCM_EOF_VAL:                           Unique Values.
* SCM_EOL:                               Unique Values.
* scm_error_scm:                         Error Reporting.
* scm_eval:                              Fly Evaluation.
* scm_eval2:                             Strange Eval.
* scm_eval_options_interface <1>:        Low level options interfaces.
* scm_eval_options_interface:            Evaluator Behaviour.
* scm_eval_string:                       Fly Evaluation.
* scm_evaluator_traps <1>:               Low level options interfaces.
* scm_evaluator_traps:                   Evaluator Behaviour.
* scm_even_p:                            Integer Operations.
* scm_exact_p:                           Exactness.
* scm_execl:                             Processes.
* scm_execle:                            Processes.
* scm_execlp:                            Processes.
* scm_fcntl:                             Ports and File Descriptors.
* scm_fdes_to_ports:                     Ports and File Descriptors.
* scm_fdopen:                            Ports and File Descriptors.
* scm_file_port_p:                       File Ports.
* scm_fileno:                            Ports and File Descriptors.
* scm_flock:                             Ports and File Descriptors.
* scm_fluid_p:                           Fluids.
* scm_fluid_ref:                         Fluids.
* scm_fluid_set_x:                       Fluids.
* scm_flush_all_ports:                   Writing.
* scm_force:                             Delayed Evaluation.
* scm_force_output:                      Writing.
* scm_fork:                              Processes.
* scm_frame_arguments:                   Examining Stack Frames.
* scm_frame_evaluating_args_p:           Examining Stack Frames.
* scm_frame_next:                        Examining Stack Frames.
* scm_frame_number:                      Examining Stack Frames.
* scm_frame_overflow_p:                  Examining Stack Frames.
* scm_frame_p:                           Examining Stack Frames.
* scm_frame_previous:                    Examining Stack Frames.
* scm_frame_procedure:                   Examining Stack Frames.
* scm_frame_procedure_p:                 Examining Stack Frames.
* scm_frame_real_p:                      Examining Stack Frames.
* scm_frame_source:                      Examining Stack Frames.
* scm_free0:                             Garbage Collecting Simple Smobs.
* scm_fsync:                             Ports and File Descriptors.
* scm_ftell:                             Random Access.
* scm_gc:                                Garbage Collection.
* scm_gc_mark:                           Garbage Collecting Smobs.
* scm_gc_stats:                          Garbage Collection.
* scm_gensym:                            Symbol Primitives.
* scm_gentemp:                           Obarray Symbols.
* scm_get_internal_real_time:            Time.
* scm_get_internal_run_time:             Time.
* scm_get_output_string:                 String Ports.
* scm_get_print_state:                   Writing.
* scm_getcwd:                            Processes.
* scm_getegid:                           Processes.
* scm_getenv:                            Runtime Environment.
* scm_geteuid:                           Processes.
* scm_getgid:                            Processes.
* scm_getgrgid:                          User Information.
* scm_getgroups:                         Processes.
* scm_gethost:                           Network Databases.
* scm_gethostname:                       System Identification.
* scm_getitimer:                         Signals.
* scm_getlogin:                          User Information.
* scm_getnet:                            Network Databases.
* scm_getpass:                           Encryption.
* scm_getpeername:                       Network Sockets and Communication.
* scm_getpgrp:                           Processes.
* scm_getpid:                            Processes.
* scm_getppid:                           Processes.
* scm_getpriority:                       Processes.
* scm_getproto:                          Network Databases.
* scm_getpwuid:                          User Information.
* scm_getserv:                           Network Databases.
* scm_getsockname:                       Network Sockets and Communication.
* scm_getsockopt:                        Network Sockets and Communication.
* scm_gettimeofday:                      Time.
* scm_getuid:                            Processes.
* scm_gmtime:                            Time.
* scm_guardian_destroyed_p:              Guardians.
* scm_guardian_greedy_p:                 Guardians.
* scm_hash:                              Hash Table Reference.
* scm_hash_create_handle_x:              Hash Table Reference.
* scm_hash_fold:                         Hash Table Reference.
* scm_hash_get_handle:                   Hash Table Reference.
* scm_hash_ref:                          Hash Table Reference.
* scm_hash_remove_x:                     Hash Table Reference.
* scm_hash_set_x:                        Hash Table Reference.
* scm_hashq:                             Hash Table Reference.
* scm_hashq_create_handle_x:             Hash Table Reference.
* scm_hashq_get_handle:                  Hash Table Reference.
* scm_hashq_ref:                         Hash Table Reference.
* scm_hashq_remove_x:                    Hash Table Reference.
* scm_hashq_set_x:                       Hash Table Reference.
* scm_hashv:                             Hash Table Reference.
* scm_hashv_create_handle_x:             Hash Table Reference.
* scm_hashv_get_handle:                  Hash Table Reference.
* scm_hashv_ref:                         Hash Table Reference.
* scm_hashv_remove_x:                    Hash Table Reference.
* scm_hashv_set_x:                       Hash Table Reference.
* scm_hashx_create_handle_x:             Hash Table Reference.
* scm_hashx_get_handle:                  Hash Table Reference.
* scm_hashx_ref:                         Hash Table Reference.
* scm_hashx_set_x:                       Hash Table Reference.
* scm_hook_empty_p:                      Hook Reference.
* scm_hook_p:                            Hook Reference.
* scm_hook_to_list:                      Hook Reference.
* SCM_HOOKP:                             Hook Reference.
* scm_htonl:                             Network Sockets and Communication.
* scm_htons:                             Network Sockets and Communication.
* SCM_IMP <1>:                           Immediate objects.
* SCM_IMP:                               Immediates vs Non-immediates.
* scm_inet_aton:                         Network Address Conversion.
* scm_inet_makeaddr:                     Network Address Conversion.
* scm_inet_netof:                        Network Address Conversion.
* scm_inet_ntoa:                         Network Address Conversion.
* scm_inet_ntop:                         Network Address Conversion.
* scm_inet_pton:                         Network Address Conversion.
* scm_inexact_p:                         Exactness.
* scm_inexact_to_exact:                  Exactness.
* scm_init_guile:                        Guile Initialization Functions.
* scm_input_port_p:                      Ports.
* scm_integer_expt:                      Bitwise Operations.
* scm_integer_length:                    Bitwise Operations.
* scm_integer_p:                         Integers.
* scm_integer_to_char:                   Characters.
* scm_interaction_environment:           Fly Evaluation.
* scm_intern_symbol:                     Obarray Symbols.
* SCM_INUM:                              Integer Data.
* SCM_INUMP:                             Integer Data.
* scm_isatty_p:                          Terminals and Ptys.
* scm_keyword_dash_symbol:               Keyword Primitives.
* scm_keyword_p:                         Keyword Primitives.
* scm_kill:                              Signals.
* scm_last_pair:                         List Selection.
* scm_last_stack_frame:                  Capturing the Stack or Innermost Stack Frame.
* scm_lazy_catch:                        Lazy Catch.
* scm_length:                            List Selection.
* scm_link:                              File System.
* scm_list:                              List Constructors.
* scm_list_cdr_set_x:                    List Modification.
* scm_list_copy:                         List Constructors.
* scm_list_head:                         List Selection.
* scm_list_p:                            List Predicates.
* scm_list_ref:                          List Selection.
* scm_list_set_x:                        List Modification.
* scm_list_tail:                         List Selection.
* scm_list_to_uniform_array:             Uniform Arrays.
* scm_listen:                            Network Sockets and Communication.
* scm_lnaof:                             Network Address Conversion.
* scm_local_eval:                        Local Evaluation.
* scm_localtime:                         Time.
* scm_logbit_p:                          Bitwise Operations.
* scm_logcount:                          Bitwise Operations.
* scm_lognot:                            Bitwise Operations.
* scm_logtest:                           Bitwise Operations.
* scm_lookup:                            Accessing Modules from C.
* scm_lstat:                             File System.
* scm_macro_name:                        Internal Macros.
* scm_macro_p:                           Internal Macros.
* scm_macro_transformer:                 Internal Macros.
* scm_macro_type:                        Internal Macros.
* scm_major_version:                     Build Config.
* scm_makacro:                           Internal Macros.
* scm_make_arbiter:                      Arbiters.
* SCM_MAKE_CHAR:                         Character Data.
* scm_make_class_object:                 Objects.
* scm_make_doubly_weak_hash_table:       Weak key hashes.
* scm_make_fluid:                        Fluids.
* scm_make_guardian:                     Guardians.
* scm_make_hook:                         Hook Reference.
* scm_make_keyword_from_dash_symbol:     Keyword Primitives.
* scm_make_polar:                        Complex.
* scm_make_procedure_with_setter:        Procedures with Setters.
* scm_make_rectangular:                  Complex.
* scm_make_regexp:                       Regexp Functions.
* scm_make_shared_array:                 Conventional Arrays.
* scm_make_shared_substring:             Shared Substrings.
* scm_make_smob_type:                    Describing a New Type.
* scm_make_smob_type_mfpe:               Describing a New Type.
* scm_make_soft_port:                    Soft Ports.
* scm_make_stack:                        Capturing the Stack or Innermost Stack Frame.
* scm_make_string:                       String Constructors.
* scm_make_struct:                       Structure Basics.
* scm_make_struct_layout:                Structure Layout.
* scm_make_subclass_object:              Objects.
* scm_make_undefined_variable:           Variables.
* scm_make_variable:                     Variables.
* scm_make_vector:                       Vector Creation.
* scm_make_vtable_vtable:                Vtables.
* scm_make_weak_key_hash_table:          Weak key hashes.
* scm_make_weak_value_hash_table:        Weak key hashes.
* scm_make_weak_vector:                  Weak vectors.
* SCM_MAKINUM:                           Integer Data.
* scm_makmacro:                          Internal Macros.
* scm_makmmacro:                         Internal Macros.
* scm_map:                               List Mapping.
* scm_markcdr:                           Garbage Collecting Simple Smobs.
* scm_mask_signals:                      Asyncs.
* scm_member:                            List Searching.
* scm_memoized_environment:              Decoding Memoized Source Expressions.
* scm_memoized_p:                        Decoding Memoized Source Expressions.
* scm_memq:                              List Searching.
* scm_memv:                              List Searching.
* scm_merge:                             Sorting.
* scm_merge_x:                           Sorting.
* scm_micro_version:                     Build Config.
* scm_minor_version:                     Build Config.
* scm_mkdir:                             File System.
* scm_mknod:                             File System.
* scm_mkstemp:                           File System.
* scm_mktime:                            Time.
* scm_module_define:                     Accessing Modules from C.
* scm_module_lookup:                     Accessing Modules from C.
* scm_module_reverse_lookup:             Accessing Modules from C.
* scm_must_free:                         Creating Instances.
* scm_must_malloc:                       Creating Instances.
* scm_must_realloc:                      Creating Instances.
* scm_nconc2last:                        Fly Evaluation.
* SCM_NCONSP:                            Pair Data.
* SCM_NEWCELL:                           Pair Data.
* scm_newline:                           Writing.
* SCM_NEWSMOB:                           Creating Instances.
* SCM_NEWSMOB2:                          Creating Instances.
* SCM_NEWSMOB3:                          Creating Instances.
* SCM_NFALSEP:                           Boolean Data.
* scm_nice:                              Processes.
* scm_nil_car:                           Emacs Lisp Support.
* scm_nil_cdr:                           Emacs Lisp Support.
* scm_nil_cons:                          Emacs Lisp Support.
* SCM_NIMP:                              Immediates vs Non-immediates.
* SCM_NINUMP:                            Integer Data.
* scm_noop:                              Asyncs.
* scm_not:                               Booleans.
* scm_ntohl:                             Network Sockets and Communication.
* scm_ntohs:                             Network Sockets and Communication.
* scm_null:                              Emacs Lisp Support.
* scm_null_p:                            List Predicates.
* scm_number_p <1>:                      Complex Numbers.
* scm_number_p:                          Numerical Tower.
* scm_number_to_string:                  Conversion.
* scm_object_address:                    Garbage Collection.
* scm_object_properties:                 Old-fashioned Properties.
* scm_object_property:                   Old-fashioned Properties.
* scm_object_to_string:                  General Conversion.
* scm_odd_p:                             Integer Operations.
* scm_open:                              Ports and File Descriptors.
* scm_open_fdes:                         Ports and File Descriptors.
* scm_open_file:                         File Ports.
* scm_open_input_string:                 String Ports.
* scm_open_output_string:                String Ports.
* scm_opendir:                           File System.
* scm_operator_p:                        Objects.
* scm_output_port_p:                     Ports.
* SCM_PACK:                              Relationship between SCM and scm_t_bits.
* scm_pair_p:                            Pairs.
* scm_parse_path:                        Build Config.
* scm_pause:                             Signals.
* scm_peek_char:                         Reading.
* scm_pipe:                              Ports and File Descriptors.
* scm_port_closed_p:                     Closing.
* scm_port_column:                       Reading.
* scm_port_filename:                     File Ports.
* scm_port_for_each:                     Ports and File Descriptors.
* scm_port_line:                         Reading.
* scm_port_mode:                         File Ports.
* scm_port_p:                            Ports.
* scm_port_revealed:                     Ports and File Descriptors.
* scm_port_with_print_state:             Writing.
* scm_primitive_eval:                    Fly Evaluation.
* scm_primitive_exit:                    Processes.
* scm_primitive_load:                    Loading.
* scm_primitive_load_path:               Loading.
* scm_primitive_make_property:           Property Primitives.
* scm_primitive_move_to_fdes:            Ports and File Descriptors.
* scm_primitive_property_del_x:          Property Primitives.
* scm_primitive_property_ref:            Property Primitives.
* scm_primitive_property_set_x:          Property Primitives.
* scm_print_options <1>:                 Low level options interfaces.
* scm_print_options:                     Writing.
* scm_procedure:                         Procedures with Setters.
* scm_procedure_documentation:           Procedure Properties.
* scm_procedure_environment:             Procedure Properties.
* scm_procedure_name:                    Procedure Properties.
* scm_procedure_p <1>:                   Procedure Properties.
* scm_procedure_p:                       Procedures.
* scm_procedure_properties:              Procedure Properties.
* scm_procedure_property:                Procedure Properties.
* scm_procedure_source:                  Procedure Properties.
* scm_procedure_with_setter_p:           Procedures with Setters.
* SCM_PROCPROPS:                         Closures.
* scm_program_arguments:                 Runtime Environment.
* scm_promise_p:                         Delayed Evaluation.
* scm_putenv:                            Runtime Environment.
* scm_raise:                             Signals.
* scm_random:                            Random.
* scm_random_exp:                        Random.
* scm_random_hollow_sphere_x:            Random.
* scm_random_normal:                     Random.
* scm_random_normal_vector_x:            Random.
* scm_random_solid_sphere_x:             Random.
* scm_random_uniform:                    Random.
* scm_read:                              Scheme Read.
* scm_read_and_eval_x:                   Strange Eval.
* scm_read_char:                         Reading.
* scm_read_delimited_x:                  Line/Delimited.
* scm_read_hash_extend:                  Reader Extensions.
* scm_read_line:                         Line/Delimited.
* scm_read_only_string_p:                Read Only Strings.
* scm_read_options <1>:                  Low level options interfaces.
* scm_read_options:                      Scheme Read.
* scm_read_string_x_partial:             Block Reading and Writing.
* scm_readdir:                           File System.
* scm_readlink:                          File System.
* scm_real_p:                            Reals and Rationals.
* scm_recv:                              Network Sockets and Communication.
* scm_recvfrom:                          Network Sockets and Communication.
* scm_redirect_port:                     Ports and File Descriptors.
* scm_regexp_exec:                       Regexp Functions.
* scm_regexp_p:                          Regexp Functions.
* scm_release_arbiter:                   Arbiters.
* scm_remove_hook_x:                     Hook Reference.
* scm_rename:                            File System.
* scm_reset_hook_x:                      Hook Reference.
* scm_resolve_module:                    Accessing Modules from C.
* scm_restore_signals:                   Signals.
* scm_restricted_vector_sort_x:          Sorting.
* SCM_RETURN_NEWSMOB:                    Creating Instances.
* SCM_RETURN_NEWSMOB2:                   Creating Instances.
* SCM_RETURN_NEWSMOB3:                   Creating Instances.
* scm_reverse:                           Append/Reverse.
* scm_reverse_x:                         Append/Reverse.
* scm_rewinddir:                         File System.
* scm_rmdir:                             File System.
* scm_round:                             Arithmetic.
* scm_run_asyncs:                        Asyncs.
* scm_run_hook:                          Hook Reference.
* scm_search_path:                       Build Config.
* scm_seed_to_random_state:              Random.
* scm_seek:                              Random Access.
* scm_select:                            Ports and File Descriptors.
* scm_send:                              Network Sockets and Communication.
* scm_sendto:                            Network Sockets and Communication.
* scm_set_car_x:                         Pairs.
* scm_set_cdr_x:                         Pairs.
* SCM_SET_CELL_OBJECT:                   Accessing Cell Entries.
* SCM_SET_CELL_TYPE:                     Heap Cell Type Information.
* SCM_SET_CELL_WORD:                     Accessing Cell Entries.
* scm_set_current_error_port:            Default Ports.
* scm_set_current_input_port:            Default Ports.
* scm_set_current_module:                Accessing Modules from C.
* scm_set_current_output_port:           Default Ports.
* scm_set_object_procedure_x:            Objects.
* scm_set_object_properties_x:           Old-fashioned Properties.
* scm_set_object_property_x:             Old-fashioned Properties.
* scm_set_port_column_x:                 Reading.
* scm_set_port_filename_x:               File Ports.
* scm_set_port_line_x:                   Reading.
* scm_set_port_revealed_x:               Ports and File Descriptors.
* scm_set_procedure_properties_x:        Procedure Properties.
* scm_set_procedure_property_x:          Procedure Properties.
* scm_set_smob_equalp:                   Describing a New Type.
* scm_set_smob_free:                     Describing a New Type.
* scm_set_smob_mark:                     Describing a New Type.
* scm_set_smob_print:                    Describing a New Type.
* scm_set_source_properties_x:           Procedure Properties.
* scm_set_source_property_x:             Procedure Properties.
* scm_set_struct_vtable_name_x:          Vtables.
* SCM_SETCAR:                            Pair Data.
* SCM_SETCDR:                            Pair Data.
* scm_setegid:                           Processes.
* scm_seteuid:                           Processes.
* scm_setgid:                            Processes.
* scm_setgrent:                          User Information.
* scm_sethost:                           Network Databases.
* scm_sethostname:                       System Identification.
* scm_setitimer:                         Signals.
* scm_setlocale:                         Locales.
* scm_setnet:                            Network Databases.
* scm_setpgid:                           Processes.
* scm_setpriority:                       Processes.
* SCM_SETPROCPROPS:                      Closures.
* scm_setproto:                          Network Databases.
* scm_setpwent:                          User Information.
* scm_setserv:                           Network Databases.
* scm_setsid:                            Processes.
* scm_setsockopt:                        Network Sockets and Communication.
* scm_setuid:                            Processes.
* scm_setvbuf:                           Ports and File Descriptors.
* scm_shared_array_increments:           Conventional Arrays.
* scm_shared_array_offset:               Conventional Arrays.
* scm_shared_array_root:                 Conventional Arrays.
* scm_shell:                             Guile Initialization Functions.
* scm_shutdown:                          Network Sockets and Communication.
* scm_sigaction:                         Signals.
* scm_simple_format:                     Writing.
* scm_sleep:                             Signals.
* scm_sloppy_assoc:                      Sloppy Alist Functions.
* scm_sloppy_assq:                       Sloppy Alist Functions.
* scm_sloppy_assv:                       Sloppy Alist Functions.
* scm_sloppy_member:                     Sloppy Membership.
* scm_sloppy_memq:                       Sloppy Membership.
* scm_sloppy_memv:                       Sloppy Membership.
* SCM_SNAME:                             Subrs.
* SCM_SNARF_INIT:                        Writing your own snarfing macros.
* scm_socket:                            Network Sockets and Communication.
* scm_socketpair:                        Network Sockets and Communication.
* scm_sort:                              Sorting.
* scm_sort_list:                         Sorting.
* scm_sort_list_x:                       Sorting.
* scm_sort_x:                            Sorting.
* scm_sorted_p:                          Sorting.
* scm_source_properties:                 Procedure Properties.
* scm_source_property:                   Procedure Properties.
* scm_stable_sort:                       Sorting.
* scm_stable_sort_x:                     Sorting.
* scm_stack_id:                          Examining the Stack.
* scm_stack_length:                      Examining the Stack.
* scm_stack_p:                           Examining the Stack.
* scm_stack_ref:                         Examining the Stack.
* scm_stat:                              File System.
* scm_status_exit_val:                   Processes.
* scm_status_stop_sig:                   Processes.
* scm_status_term_sig:                   Processes.
* scm_strerror:                          Error Reporting.
* scm_strftime:                          Time.
* scm_string:                            String Constructors.
* scm_string_append:                     Appending Strings.
* scm_string_capitalize:                 Alphabetic Case Mapping.
* scm_string_capitalize_x:               Alphabetic Case Mapping.
* SCM_STRING_CHARS:                      Vector Data.
* scm_string_ci_to_symbol:               Symbol Primitives.
* scm_string_copy:                       String Selection.
* scm_string_downcase:                   Alphabetic Case Mapping.
* scm_string_downcase_x:                 Alphabetic Case Mapping.
* scm_string_fill_x:                     String Modification.
* scm_string_index:                      String Searching.
* scm_string_length:                     String Selection.
* SCM_STRING_LENGTH:                     Vector Data.
* scm_string_null_p:                     String Predicates.
* scm_string_p:                          String Predicates.
* scm_string_ref:                        String Selection.
* scm_string_rindex:                     String Searching.
* scm_string_set_x:                      String Modification.
* scm_string_split:                      List/String Conversion.
* scm_string_to_list:                    List/String Conversion.
* scm_string_to_number:                  Conversion.
* scm_string_to_obarray_symbol:          Obarray Symbols.
* scm_string_to_symbol:                  Symbol Primitives.
* scm_string_upcase:                     Alphabetic Case Mapping.
* scm_string_upcase_x:                   Alphabetic Case Mapping.
* SCM_STRINGP:                           Vector Data.
* scm_strptime:                          Time.
* scm_struct_p:                          Structure Basics.
* scm_struct_ref:                        Structure Basics.
* scm_struct_set_x:                      Structure Basics.
* scm_struct_vtable:                     Vtables.
* scm_struct_vtable_name:                Vtables.
* scm_struct_vtable_p:                   Vtables.
* scm_struct_vtable_tag:                 Vtables.
* scm_substring:                         String Selection.
* scm_substring_fill_x:                  String Modification.
* scm_substring_move_x:                  String Modification.
* scm_symbol_binding:                    Obarray Symbols.
* scm_symbol_bound_p:                    Obarray Symbols.
* SCM_SYMBOL_CHARS:                      Vector Data.
* scm_symbol_fref:                       Symbol Props.
* scm_symbol_fset_x:                     Symbol Props.
* scm_symbol_hash:                       Symbol Keys.
* scm_symbol_interned_p:                 Obarray Symbols.
* SCM_SYMBOL_LENGTH:                     Vector Data.
* scm_symbol_p:                          Symbol Primitives.
* scm_symbol_pref:                       Symbol Props.
* scm_symbol_pset_x:                     Symbol Props.
* scm_symbol_set_x:                      Obarray Symbols.
* scm_symbol_to_string:                  Symbol Primitives.
* SCM_SYMBOLP:                           Vector Data.
* scm_symlink:                           File System.
* scm_sync:                              File System.
* scm_sys_atan2:                         Primitive Numerics.
* scm_sys_expt:                          Primitive Numerics.
* scm_sys_library_dir:                   Build Config.
* scm_sys_make_void_port:                Void Ports.
* scm_sys_package_data_dir:              Build Config.
* scm_sys_search_load_path:              Loading.
* scm_sys_site_dir:                      Build Config.
* scm_system:                            Processes.
* scm_system_async:                      Asyncs.
* scm_system_async_mark:                 Asyncs.
* scm_tcgetpgrp:                         Terminals and Ptys.
* scm_tcsetpgrp:                         Terminals and Ptys.
* scm_throw:                             Throw.
* scm_thunk_p:                           Procedure Properties.
* scm_times:                             Time.
* scm_tmpnam:                            File System.
* scm_transpose_array:                   Conventional Arrays.
* scm_truncate:                          Arithmetic.
* scm_truncate_file:                     Random Access.
* scm_try_arbiter:                       Arbiters.
* scm_ttyname:                           Terminals and Ptys.
* scm_tzset:                             Time.
* scm_umask:                             Processes.
* scm_uname:                             System Identification.
* SCM_UNBNDP:                            Unique Values.
* SCM_UNDEFINED:                         Unique Values.
* scm_uniform_array_read_x:              Uniform Arrays.
* scm_uniform_array_write:               Uniform Arrays.
* scm_uniform_vector_length:             Uniform Arrays.
* scm_uniform_vector_ref:                Conventional Arrays.
* scm_unintern_symbol:                   Obarray Symbols.
* scm_unmask_signals:                    Asyncs.
* scm_unmemoize:                         Decoding Memoized Source Expressions.
* SCM_UNPACK:                            Relationship between SCM and scm_t_bits.
* scm_unread_char <1>:                   Ports and File Descriptors.
* scm_unread_char:                       Reading.
* scm_unread_string:                     Reading.
* SCM_UNSPECIFIED:                       Unique Values.
* scm_usleep:                            Signals.
* scm_utime:                             File System.
* scm_values:                            Multiple Values.
* scm_variable_bound_p:                  Variables.
* scm_variable_p:                        Variables.
* scm_variable_ref:                      Variables.
* scm_variable_set_x:                    Variables.
* scm_vector:                            Vector Creation.
* SCM_VECTOR_BASE:                       Vector Data.
* scm_vector_fill_x:                     Vector Accessors.
* scm_vector_length:                     Vector Accessors.
* SCM_VECTOR_LENGTH:                     Vector Data.
* scm_vector_move_left_x:                Vector Accessors.
* scm_vector_move_right_x:               Vector Accessors.
* scm_vector_p:                          Vector Creation.
* scm_vector_ref:                        Vector Accessors.
* scm_vector_set_x:                      Vector Accessors.
* scm_vector_to_list:                    Vector Creation.
* SCM_VECTORP:                           Vector Data.
* scm_version:                           Build Config.
* scm_waitpid:                           Processes.
* scm_weak_key_hash_table_p:             Weak key hashes.
* scm_weak_value_hash_table_p:           Weak key hashes.
* scm_weak_vector:                       Weak vectors.
* scm_weak_vector_p:                     Weak vectors.
* scm_with_fluids:                       Fluids.
* scm_with_traps:                        Using Traps.
* scm_write_char:                        Writing.
* scm_write_line:                        Line/Delimited.
* scm_write_string_partial:              Block Reading and Writing.
* search-path:                           Build Config.
* second:                                SRFI-1 Selectors.
* seed->random-state:                    Random.
* seek:                                  Random Access.
* select:                                Ports and File Descriptors.
* send:                                  Network Sockets and Communication.
* sendto:                                Network Sockets and Communication.
* servent:aliases:                       Network Databases.
* servent:name:                          Network Databases.
* servent:port:                          Network Databases.
* servent:proto:                         Network Databases.
* set-batch-mode?!:                      Dynamic Roots.
* set-car!:                              Pairs.
* set-cdr!:                              Pairs.
* set-current-error-port:                Default Ports.
* set-current-input-port:                Default Ports.
* set-current-output-port:               Default Ports.
* set-object-procedure!:                 Objects.
* set-object-properties!:                Old-fashioned Properties.
* set-object-property!:                  Old-fashioned Properties.
* set-port-column!:                      Reading.
* set-port-filename!:                    File Ports.
* set-port-line!:                        Reading.
* set-port-revealed!:                    Ports and File Descriptors.
* set-procedure-properties!:             Procedure Properties.
* set-procedure-property!:               Procedure Properties.
* set-source-properties!:                Procedure Properties.
* set-source-property!:                  Procedure Properties.
* set-struct-vtable-name!:               Vtables.
* set-symbol-property!:                  Symbol Props.
* setegid:                               Processes.
* setenv:                                Runtime Environment.
* seteuid:                               Processes.
* setgid:                                Processes.
* setgr:                                 User Information.
* setgrent:                              User Information.
* sethost:                               Network Databases.
* sethostent:                            Network Databases.
* sethostname:                           System Identification.
* setitimer:                             Signals.
* setlocale:                             Locales.
* setnet:                                Network Databases.
* setnetent:                             Network Databases.
* setpgid:                               Processes.
* setpriority:                           Processes.
* setproto:                              Network Databases.
* setprotoent:                           Network Databases.
* setpw:                                 User Information.
* setpwent:                              User Information.
* setserv:                               Network Databases.
* setservent:                            Network Databases.
* setsid:                                Processes.
* setsockopt:                            Network Sockets and Communication.
* setter:                                Procedures with Setters.
* setuid:                                Processes.
* setvbuf:                               Ports and File Descriptors.
* seventh:                               SRFI-1 Selectors.
* shared-array-increments:               Conventional Arrays.
* shared-array-offset:                   Conventional Arrays.
* shared-array-root:                     Conventional Arrays.
* shutdown:                              Network Sockets and Communication.
* sigaction:                             Signals.
* signal-condition-variable:             Low level thread primitives.
* simple-format:                         Writing.
* sin:                                   Scientific.
* sinh:                                  Scientific.
* sixth:                                 SRFI-1 Selectors.
* sleep:                                 Signals.
* sloppy-assoc:                          Sloppy Alist Functions.
* sloppy-assq:                           Sloppy Alist Functions.
* sloppy-assv:                           Sloppy Alist Functions.
* sloppy-member:                         Sloppy Membership.
* sloppy-memq:                           Sloppy Membership.
* sloppy-memv:                           Sloppy Membership.
* socket:                                Network Sockets and Communication.
* socketpair:                            Network Sockets and Communication.
* software-type:                         System Identification.
* sort:                                  Sorting.
* sort!:                                 Sorting.
* sort-list:                             Sorting.
* sort-list!:                            Sorting.
* sorted?:                               Sorting.
* source-properties:                     Procedure Properties.
* source-property:                       Procedure Properties.
* span:                                  SRFI-1 Searching.
* span!:                                 SRFI-1 Searching.
* split-at:                              SRFI-1 Selectors.
* split-at!:                             SRFI-1 Selectors.
* sqrt:                                  Scientific.
* stable-sort:                           Sorting.
* stable-sort!:                          Sorting.
* stack-id:                              Examining the Stack.
* stack-length:                          Examining the Stack.
* stack-ref:                             Examining the Stack.
* stack?:                                Examining the Stack.
* start-stack:                           Starting a New Stack.
* stat:                                  File System.
* status:exit-val:                       Processes.
* status:stop-sig:                       Processes.
* status:term-sig:                       Processes.
* strerror:                              Error Reporting.
* strftime:                              Time.
* string:                                String Constructors.
* string->char-set:                      SRFI-14 Creating Character Sets.
* string->char-set!:                     SRFI-14 Creating Character Sets.
* string->list <1>:                      SRFI-13 List/String Conversion.
* string->list:                          List/String Conversion.
* string->number:                        Conversion.
* string->obarray-symbol:                Obarray Symbols.
* string->symbol:                        Symbol Primitives.
* string-any:                            SRFI-13 Predicates.
* string-append:                         Appending Strings.
* string-append/shared:                  SRFI-13 Reverse/Append.
* string-capitalize:                     Alphabetic Case Mapping.
* string-capitalize!:                    Alphabetic Case Mapping.
* string-ci->symbol:                     Symbol Primitives.
* string-ci<:                            SRFI-13 Comparison.
* string-ci<=:                           SRFI-13 Comparison.
* string-ci<=?:                          String Comparison.
* string-ci<>:                           SRFI-13 Comparison.
* string-ci<?:                           String Comparison.
* string-ci=:                            SRFI-13 Comparison.
* string-ci=?:                           String Comparison.
* string-ci>:                            SRFI-13 Comparison.
* string-ci>=:                           SRFI-13 Comparison.
* string-ci>=?:                          String Comparison.
* string-ci>?:                           String Comparison.
* string-compare:                        SRFI-13 Comparison.
* string-compare-ci:                     SRFI-13 Comparison.
* string-concatenate:                    SRFI-13 Reverse/Append.
* string-concatenate-reverse:            SRFI-13 Reverse/Append.
* string-concatenate-reverse/shared:     SRFI-13 Reverse/Append.
* string-concatenate/shared:             SRFI-13 Reverse/Append.
* string-contains:                       SRFI-13 Searching.
* string-contains-ci:                    SRFI-13 Searching.
* string-copy <1>:                       SRFI-13 Selection.
* string-copy:                           String Selection.
* string-copy!:                          SRFI-13 Selection.
* string-count:                          SRFI-13 Searching.
* string-delete:                         SRFI-13 Filtering/Deleting.
* string-downcase <1>:                   SRFI-13 Case Mapping.
* string-downcase:                       Alphabetic Case Mapping.
* string-downcase! <1>:                  SRFI-13 Case Mapping.
* string-downcase!:                      Alphabetic Case Mapping.
* string-drop:                           SRFI-13 Selection.
* string-drop-right:                     SRFI-13 Selection.
* string-every:                          SRFI-13 Predicates.
* string-fill! <1>:                      SRFI-13 Modification.
* string-fill!:                          String Modification.
* string-filter:                         SRFI-13 Filtering/Deleting.
* string-fold:                           SRFI-13 Fold/Unfold/Map.
* string-fold-right:                     SRFI-13 Fold/Unfold/Map.
* string-for-each:                       SRFI-13 Fold/Unfold/Map.
* string-hash:                           SRFI-13 Comparison.
* string-hash-ci:                        SRFI-13 Comparison.
* string-index <1>:                      SRFI-13 Searching.
* string-index:                          String Searching.
* string-index-right:                    SRFI-13 Searching.
* string-join:                           SRFI-13 List/String Conversion.
* string-length:                         String Selection.
* string-map:                            SRFI-13 Fold/Unfold/Map.
* string-map!:                           SRFI-13 Fold/Unfold/Map.
* string-match:                          Regexp Functions.
* string-null?:                          String Predicates.
* string-pad:                            SRFI-13 Selection.
* string-pad-right:                      SRFI-13 Selection.
* string-prefix-ci?:                     SRFI-13 Prefixes/Suffixes.
* string-prefix-length:                  SRFI-13 Prefixes/Suffixes.
* string-prefix-length-ci:               SRFI-13 Prefixes/Suffixes.
* string-prefix?:                        SRFI-13 Prefixes/Suffixes.
* string-ref:                            String Selection.
* string-replace:                        SRFI-13 Miscellaneous.
* string-reverse:                        SRFI-13 Reverse/Append.
* string-reverse!:                       SRFI-13 Reverse/Append.
* string-rindex:                         String Searching.
* string-set!:                           String Modification.
* string-skip:                           SRFI-13 Searching.
* string-skip-right:                     SRFI-13 Searching.
* string-split:                          List/String Conversion.
* string-suffix-ci?:                     SRFI-13 Prefixes/Suffixes.
* string-suffix-length:                  SRFI-13 Prefixes/Suffixes.
* string-suffix-length-ci:               SRFI-13 Prefixes/Suffixes.
* string-suffix?:                        SRFI-13 Prefixes/Suffixes.
* string-tabulate:                       SRFI-13 Constructors.
* string-take:                           SRFI-13 Selection.
* string-take-right:                     SRFI-13 Selection.
* string-titlecase:                      SRFI-13 Case Mapping.
* string-titlecase!:                     SRFI-13 Case Mapping.
* string-tokenize:                       SRFI-13 Miscellaneous.
* string-trim:                           SRFI-13 Selection.
* string-trim-both:                      SRFI-13 Selection.
* string-trim-right:                     SRFI-13 Selection.
* string-unfold:                         SRFI-13 Fold/Unfold/Map.
* string-unfold-right:                   SRFI-13 Fold/Unfold/Map.
* string-upcase <1>:                     SRFI-13 Case Mapping.
* string-upcase:                         Alphabetic Case Mapping.
* string-upcase! <1>:                    SRFI-13 Case Mapping.
* string-upcase!:                        Alphabetic Case Mapping.
* string-xcopy!:                         SRFI-13 Replicate/Rotate.
* string<:                               SRFI-13 Comparison.
* string<=:                              SRFI-13 Comparison.
* string<=?:                             String Comparison.
* string<>:                              SRFI-13 Comparison.
* string<?:                              String Comparison.
* string=:                               SRFI-13 Comparison.
* string=?:                              String Comparison.
* string>:                               SRFI-13 Comparison.
* string>=:                              SRFI-13 Comparison.
* string>=?:                             String Comparison.
* string>?:                              String Comparison.
* string?:                               String Predicates.
* strptime:                              Time.
* struct-ref:                            Structure Basics.
* struct-set!:                           Structure Basics.
* struct-vtable:                         Vtables.
* struct-vtable-name:                    Vtables.
* struct-vtable-tag:                     Vtables.
* struct-vtable?:                        Vtables.
* struct?:                               Structure Basics.
* substring:                             String Selection.
* substring-fill!:                       String Modification.
* substring-move!:                       String Modification.
* substring/shared:                      SRFI-13 Selection.
* symbol->keyword:                       Keyword Procedures.
* symbol->string:                        Symbol Primitives.
* symbol-binding:                        Obarray Symbols.
* symbol-bound?:                         Obarray Symbols.
* symbol-fref:                           Symbol Props.
* symbol-fset!:                          Symbol Props.
* symbol-hash:                           Symbol Keys.
* symbol-interned?:                      Obarray Symbols.
* symbol-pref:                           Symbol Props.
* symbol-prefix-proc:                    Using Guile Modules.
* symbol-property:                       Symbol Props.
* symbol-property-remove!:               Symbol Props.
* symbol-pset!:                          Symbol Props.
* symbol-set!:                           Obarray Symbols.
* symbol?:                               Symbol Primitives.
* symlink:                               File System.
* sync:                                  File System.
* system:                                Processes.
* system-async:                          Asyncs.
* system-async-mark:                     Asyncs.
* TAGvector:                             SRFI-4 - Procedures.
* TAGvector->list:                       SRFI-4 - Procedures.
* TAGvector-length:                      SRFI-4 - Procedures.
* TAGvector-ref:                         SRFI-4 - Procedures.
* TAGvector?:                            SRFI-4 - Procedures.
* take:                                  SRFI-1 Selectors.
* take!:                                 SRFI-1 Selectors.
* take-right:                            SRFI-1 Selectors.
* take-while:                            SRFI-1 Searching.
* take-while!:                           SRFI-1 Searching.
* tan:                                   Scientific.
* tanh:                                  Scientific.
* tcgetpgrp:                             Terminals and Ptys.
* tcsetpgrp:                             Terminals and Ptys.
* tenth:                                 SRFI-1 Selectors.
* third:                                 SRFI-1 Selectors.
* throw:                                 Throw.
* thunk?:                                Procedure Properties.
* times:                                 Time.
* tmpnam:                                File System.
* trace:                                 Trace.
* transpose-array:                       Conventional Arrays.
* trap-disable <1>:                      User level options interfaces.
* trap-disable:                          Evaluator Behaviour.
* trap-enable <1>:                       User level options interfaces.
* trap-enable:                           Evaluator Behaviour.
* trap-set! <1>:                         User level options interfaces.
* trap-set!:                             Evaluator Behaviour.
* traps <1>:                             User level options interfaces.
* traps:                                 Evaluator Behaviour.
* truncate <1>:                          Random Access.
* truncate:                              Arithmetic.
* truncate-file:                         Random Access.
* try-arbiter:                           Arbiters.
* ttyname:                               Terminals and Ptys.
* tzset:                                 Time.
* uce-range->char-set!:                  SRFI-14 Creating Character Sets.
* ucs-range->char-set:                   SRFI-14 Creating Character Sets.
* umask:                                 Processes.
* uname:                                 System Identification.
* unfold:                                SRFI-1 Fold and Map.
* unfold-right:                          SRFI-1 Fold and Map.
* unhash-name:                           Garbage Collection.
* uniform-array-read!:                   Uniform Arrays.
* uniform-array-set1!:                   Conventional Arrays.
* uniform-array-write:                   Uniform Arrays.
* uniform-vector-fill!:                  Uniform Arrays.
* uniform-vector-length:                 Uniform Arrays.
* uniform-vector-read!:                  Uniform Arrays.
* uniform-vector-ref:                    Conventional Arrays.
* uniform-vector-write:                  Uniform Arrays.
* unintern-symbol:                       Obarray Symbols.
* unlink:                                File System.
* unlock-mutex:                          Low level thread primitives.
* unmask-signals:                        Asyncs.
* unmemoize:                             Decoding Memoized Source Expressions.
* unread-char <1>:                       Ports and File Descriptors.
* unread-char:                           Reading.
* unread-string <1>:                     Ports and File Descriptors.
* unread-string:                         Reading.
* untrace:                               Trace.
* unzip1:                                SRFI-1 Length Append etc.
* unzip2:                                SRFI-1 Length Append etc.
* unzip3:                                SRFI-1 Length Append etc.
* unzip4:                                SRFI-1 Length Append etc.
* unzip5:                                SRFI-1 Length Append etc.
* use-modules:                           Using Guile Modules.
* use-syntax:                            Using Guile Modules.
* usleep:                                Signals.
* utime:                                 File System.
* values:                                Multiple Values.
* variable-bound?:                       Variables.
* variable-ref:                          Variables.
* variable-set!:                         Variables.
* variable?:                             Variables.
* vector:                                Vector Creation.
* vector->list:                          Vector Creation.
* vector-fill!:                          Vector Accessors.
* vector-length:                         Vector Accessors.
* vector-move-left!:                     Vector Accessors.
* vector-move-right!:                    Vector Accessors.
* vector-ref:                            Vector Accessors.
* vector-set!:                           Vector Accessors.
* vector?:                               Vector Creation.
* version:                               Build Config.
* wait-condition-variable:               Low level thread primitives.
* waitpid:                               Processes.
* weak-key-hash-table?:                  Weak key hashes.
* weak-value-hash-table?:                Weak key hashes.
* weak-vector:                           Weak vectors.
* weak-vector?:                          Weak vectors.
* while:                                 while do.
* with-error-to-file:                    File Ports.
* with-fluids*:                          Fluids.
* with-input-from-file:                  File Ports.
* with-input-from-string:                String Ports.
* with-mutex:                            Higher level thread procedures.
* with-output-to-file:                   File Ports.
* with-output-to-string:                 String Ports.
* with-traps:                            Using Traps.
* write-char:                            Writing.
* write-line:                            Line/Delimited.
* write-string/partial:                  Block Reading and Writing.
* xcons:                                 SRFI-1 Constructors.
* xsubstring:                            SRFI-13 Replicate/Rotate.
* yield:                                 Low level thread primitives.
* zero?:                                 Comparison.
* zip:                                   SRFI-1 Length Append etc.

