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: Variable Index,  Next: Type Index,  Prev: Procedure Index,  Up: Top

Variable Index
**************

   This is an alphabetical list of all the important variables and
constants in Guile.

   When looking for a particular variable or constant, 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:

* %guile-build-info:                     Build Config.
* %load-extensions:                      Loading.
* %load-hook:                            Loading.
* %load-path:                            Build Config.
* *features*:                            Feature Tracking.
* after-gc-hook:                         GC Hooks.
* char-set:ascii:                        SRFI-14 Standard Character Sets.
* char-set:blank:                        SRFI-14 Standard Character Sets.
* char-set:digit:                        SRFI-14 Standard Character Sets.
* char-set:empty:                        SRFI-14 Standard Character Sets.
* char-set:full:                         SRFI-14 Standard Character Sets.
* char-set:graphic:                      SRFI-14 Standard Character Sets.
* char-set:hex-digit:                    SRFI-14 Standard Character Sets.
* char-set:iso-control:                  SRFI-14 Standard Character Sets.
* char-set:letter:                       SRFI-14 Standard Character Sets.
* char-set:letter+digit:                 SRFI-14 Standard Character Sets.
* char-set:lower-case:                   SRFI-14 Standard Character Sets.
* char-set:printing:                     SRFI-14 Standard Character Sets.
* char-set:punctuation:                  SRFI-14 Standard Character Sets.
* char-set:symbol:                       SRFI-14 Standard Character Sets.
* char-set:title-case:                   SRFI-14 Standard Character Sets.
* char-set:upper-case:                   SRFI-14 Standard Character Sets.
* char-set:whitespace:                   SRFI-14 Standard Character Sets.
* F_OK:                                  File System.
* INADDR_ANY:                            Network Sockets and Communication.
* INADDR_BROADCAST:                      Network Sockets and Communication.
* INADDR_LOOPBACK:                       Network Sockets and Communication.
* INADDR_NONE:                           Network Sockets and Communication.
* internal-time-units-per-second:        Time.
* O_APPEND:                              Ports and File Descriptors.
* O_CREAT:                               Ports and File Descriptors.
* O_RDONLY:                              Ports and File Descriptors.
* O_RDWR:                                Ports and File Descriptors.
* O_WRONLY:                              Ports and File Descriptors.
* R_OK:                                  File System.
* REG_EXTENDED:                          Rx Regexps.
* REG_ICASE:                             Rx Regexps.
* REG_NEWLINE:                           Rx Regexps.
* REG_NOTBOL:                            Rx Regexps.
* REG_NOTEOL:                            Rx Regexps.
* scm_after_gc_c_hook:                   GC Hooks.
* scm_after_gc_hook:                     GC Hooks.
* scm_after_sweep_c_hook:                GC Hooks.
* scm_before_gc_c_hook:                  GC Hooks.
* scm_before_mark_c_hook:                GC Hooks.
* scm_before_sweep_c_hook:               GC Hooks.
* SCM_BOOL_F:                            Data types and constants defined by gh.
* SCM_BOOL_T:                            Data types and constants defined by gh.
* SCM_C_HOOK_AND:                        C Hooks.
* SCM_C_HOOK_NORMAL:                     C Hooks.
* SCM_C_HOOK_OR:                         C Hooks.
* SCM_UNDEFINED:                         Data types and constants defined by gh.
* SCM_UNSPECIFIED:                       Data types and constants defined by gh.
* SEEK_CUR:                              Random Access.
* SEEK_END:                              Random Access.
* SEEK_SET:                              Random Access.
* SIGHUP:                                Signals.
* SIGINT:                                Signals.
* W_OK:                                  File System.
* WNOHANG:                               Processes.
* WUNTRACED:                             Processes.
* X_OK:                                  File System.


File: guile.info,  Node: Type Index,  Next: R5RS Index,  Prev: Variable Index,  Up: Top

Type Index
**********

   This is an alphabetical list of all the important data types defined
in the Guile Programmers Manual.

* Menu:

* Alist:                                 Association Lists.
* Arrays:                                Arrays.
* Association Lists:                     Association Lists.
* Booleans:                              Booleans.
* Characters:                            Characters.
* Complex numbers:                       Complex Numbers.
* Exact numbers:                         Exactness.
* Hash Tables:                           Hash Tables.
* Hooks:                                 Hooks.
* Inexact numbers:                       Exactness.
* Integer numbers:                       Integers.
* Keywords:                              Keywords.
* Lists:                                 Lists.
* Numbers:                               Numbers.
* Pairs:                                 Pairs.
* Rational numbers:                      Reals and Rationals.
* Real numbers:                          Reals and Rationals.
* Regular expressions:                   Regular Expressions.
* SCM:                                   Unpacking the SCM type.
* scm_t_bits:                            Unpacking the SCM type.
* scm_t_c_hook:                          C Hooks.
* scm_t_c_hook_function:                 C Hooks.
* scm_t_c_hook_type:                     C Hooks.
* Strings:                               Strings.
* Structures:                            Structures.
* Symbols:                               Symbols.
* Uniform Arrays:                        Uniform Arrays.
* Variables:                             Variables.
* Vectors:                               Vectors.


File: guile.info,  Node: R5RS Index,  Prev: Type Index,  Up: Top

R5RS Index
**********

* Menu:

* *:                                     Arithmetic.
* +:                                     Arithmetic.
* -:                                     Arithmetic.
* /:                                     Arithmetic.
* abs:                                   Arithmetic.
* acos:                                  Scientific.
* angle:                                 Complex.
* append:                                Append/Reverse.
* apply:                                 Fly Evaluation.
* asin:                                  Scientific.
* assoc:                                 Retrieving Alist Entries.
* assq:                                  Retrieving Alist Entries.
* assv:                                  Retrieving Alist Entries.
* atan:                                  Scientific.
* boolean?:                              Booleans.
* call-with-current-continuation:        Continuations.
* call-with-input-file:                  File Ports.
* call-with-output-file:                 File Ports.
* call-with-values:                      Multiple Values.
* car:                                   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-lower-case?:                      Characters.
* char-numeric?:                         Characters.
* char-ready?:                           Reading.
* char-upcase:                           Characters.
* char-upper-case?:                      Characters.
* char-whitespace?:                      Characters.
* char<=?:                               Characters.
* char<?:                                Characters.
* char=?:                                Characters.
* char>=?:                               Characters.
* char>?:                                Characters.
* char?:                                 Characters.
* close-input-port:                      Closing.
* close-output-port:                     Closing.
* complex?:                              Complex Numbers.
* cons:                                  Pairs.
* cos:                                   Scientific.
* current-input-port:                    Default Ports.
* current-output-port:                   Default Ports.
* display:                               Writing.
* dynamic-wind:                          Dynamic Wind.
* eof-object?:                           Reading.
* eq?:                                   Equality.
* equal?:                                Equality.
* eqv?:                                  Equality.
* eval:                                  Fly Evaluation.
* even?:                                 Integer Operations.
* exact->inexact:                        Exactness.
* exact?:                                Exactness.
* exp:                                   Scientific.
* expt:                                  Scientific.
* floor:                                 Arithmetic.
* for-each:                              List Mapping.
* force:                                 Delayed Evaluation.
* gcd:                                   Integer Operations.
* imag-part:                             Complex.
* inexact->exact:                        Exactness.
* inexact?:                              Exactness.
* input-port?:                           Ports.
* integer->char:                         Characters.
* integer?:                              Integers.
* interaction-environment:               Fly Evaluation.
* lcm:                                   Integer Operations.
* length:                                List Selection.
* list:                                  List Constructors.
* list->string:                          String Constructors.
* list->vector:                          Vector Creation.
* list-ref:                              List Selection.
* list-tail:                             List Selection.
* list?:                                 List Predicates.
* load:                                  Loading.
* log:                                   Scientific.
* magnitude:                             Complex.
* make-polar:                            Complex.
* make-rectangular:                      Complex.
* make-string:                           String Constructors.
* make-vector:                           Vector Creation.
* map:                                   List Mapping.
* max:                                   Arithmetic.
* member:                                List Searching.
* memq:                                  List Searching.
* memv:                                  List Searching.
* min:                                   Arithmetic.
* modulo:                                Integer Operations.
* negative?:                             Comparison.
* newline:                               Writing.
* not:                                   Booleans.
* null?:                                 List Predicates.
* number->string:                        Conversion.
* number?:                               Numerical Tower.
* odd?:                                  Integer Operations.
* open-input-file:                       File Ports.
* open-output-file:                      File Ports.
* output-port?:                          Ports.
* pair?:                                 Pairs.
* peek-char?:                            Reading.
* positive?:                             Comparison.
* procedure?:                            Procedure Properties.
* quotient:                              Integer Operations.
* rational?:                             Reals and Rationals.
* read:                                  Scheme Read.
* read-char?:                            Reading.
* real-part:                             Complex.
* real?:                                 Reals and Rationals.
* remainder:                             Integer Operations.
* reverse:                               Append/Reverse.
* round:                                 Arithmetic.
* set-car!:                              Pairs.
* set-cdr!:                              Pairs.
* sin:                                   Scientific.
* sqrt:                                  Scientific.
* string:                                String Constructors.
* string->list:                          List/String Conversion.
* string->number:                        Conversion.
* string->symbol:                        Symbol Primitives.
* string-append:                         Appending Strings.
* string-ci<:                            String Comparison.
* string-ci=?:                           String Comparison.
* string-ci>=?:                          String Comparison.
* string-ci>?:                           String Comparison.
* string-copy:                           String Selection.
* string-fill!:                          String Modification.
* string-length:                         String Selection.
* string-ref:                            String Selection.
* string-set!:                           String Modification.
* string<=?:                             String Comparison.
* string<?:                              String Comparison.
* string=?:                              String Comparison.
* string>=?:                             String Comparison.
* string>?:                              String Comparison.
* string?:                               String Predicates.
* substring:                             String Selection.
* symbol->string:                        Symbol Primitives.
* symbol?:                               Symbol Primitives.
* tan:                                   Scientific.
* truncate:                              Arithmetic.
* values:                                Multiple Values.
* vector:                                Vector Creation.
* vector->list:                          Vector Creation.
* vector-fill!:                          Vector Accessors.
* vector-length:                         Vector Accessors.
* vector-ref:                            Vector Accessors.
* vector-set!:                           Vector Accessors.
* vector?:                               Vector Creation.
* with-input-from-file:                  File Ports.
* with-output-to-file:                   File Ports.
* write-char:                            Writing.
* zero?:                                 Comparison.


