
(acons key value alist)
Add a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[libguile/alist.c:61]

(sloppy-assq key alist)
Behave like @code{assq} but do not do any error checking.
Recommended only for use in Guile internals.
[libguile/alist.c:84]

(sloppy-assv key alist)
Behave like @code{assv} but do not do any error checking.
Recommended only for use in Guile internals.
[libguile/alist.c:102]

(sloppy-assoc key alist)
Behave like @code{assoc} but do not do any error checking.
Recommended only for use in Guile internals.
[libguile/alist.c:120]

(assq key alist)
Fetch the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then return @code{#f}.  These functions
return the entire alist entry found (i.e. both the key and the value).
[libguile/alist.c:145]

(assv key alist)
Behave like @code{assq} but use @code{eqv?} for key comparison.
[libguile/alist.c:163]

(assoc key alist)
Behave like @code{assq} but use @code{equal?} for key comparison.
[libguile/alist.c:181]

(assq-ref alist key)
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[libguile/alist.c:208]

(assv-ref alist key)
Behave like @code{assq-ref} but use @code{eqv?} for key comparison.
[libguile/alist.c:225]

(assoc-ref alist key)
Behave like @code{assq-ref} but use @code{equal?} for key comparison.
[libguile/alist.c:242]

(assq-set! alist key val)
Reassociate @var{key} in @var{alist} with @var{value}: find any existing
@var{alist} entry for @var{key} and associate it with the new
@var{value}.  If @var{alist} does not contain an entry for @var{key},
add a new one.  Return the (possibly new) alist.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[libguile/alist.c:269]

(assv-set! alist key val)
Behave like @code{assq-set!} but use @code{eqv?} for key comparison.
[libguile/alist.c:287]

(assoc-set! alist key val)
Behave like @code{assq-set!} but use @code{equal?} for key comparison.
[libguile/alist.c:305]

(assq-remove! alist key)
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[libguile/alist.c:327]

(assv-remove! alist key)
Behave like @code{assq-remove!} but use @code{eqv?} for key comparison.
[libguile/alist.c:345]

(assoc-remove! alist key)
Behave like @code{assq-remove!} but use @code{equal?} for key comparison.
[libguile/alist.c:363]

(make-arbiter name)
Return an object of type arbiter and name @var{name}.
Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[libguile/arbiters.c:85]

(try-arbiter arb)
Lock arbiter @var{arb} and return #t if it was unlocked.
Otherwise, return #f.
[libguile/arbiters.c:95]

(release-arbiter arb)
Unlock arbiter @var{arb} and return #t if it was locked.
Otherwise, return #f.
[libguile/arbiters.c:116]

(async thunk)
Create a new async for the procedure @var{thunk}.
[libguile/async.c:305]

(system-async thunk)
Create a new async for the procedure @var{thunk}.  Also
add it to the system's list of active async objects.
[libguile/async.c:315]

(async-mark a)
Mark the async @var{a} for future execution.
[libguile/async.c:332]

(system-async-mark a)
Mark the async @var{a} for future execution.
[libguile/async.c:348]

(run-asyncs list_of_a)
Execute all thunks from the asyncs of the list @var{list_of_a}.
[libguile/async.c:368]

(noop [args ...])
Do nothing.  When called without arguments, return @code{#f},
otherwise return the first argument.
[libguile/async.c:402]

(unmask-signals)
Unmask signals. The returned value is not specified.
[libguile/async.c:484]

(mask-signals)
Mask signals. The returned value is not specified.
[libguile/async.c:495]

(display-error stack port subr message args rest)
Display an error message to the output port @var{port}.
@var{stack} is the saved stack for the error, @var{subr} is
the name of the procedure in which the error occurred and
@var{message} is the actual error message, which may contain
formatting instructions. These will format the arguments in
the list @var{args} accordingly.  @var{rest} is currently
ignored.
[libguile/backtrace.c:232]

(display-application frame [port [indent]])
Display a procedure application @var{frame} to the output port
@var{port}. @var{indent} specifies the indentation of the
output.
[libguile/backtrace.c:374]

(display-backtrace stack port [first [depth]])
Display a backtrace to the output port @var{port}. @var{stack}
is the stack to take the backtrace from, @var{first} specifies
where in the stack to start and @var{depth} how much frames
to display. Both @var{first} and @var{depth} can be @code{#f},
which means that default values will be used.
[libguile/backtrace.c:592]

(backtrace)
Display a backtrace of the stack saved by the last error
to the current output port.
[libguile/backtrace.c:615]

(not x)
Return @code{#t} iff @var{x} is @code{#f}, else return @code{#f}.
[libguile/boolean.c:57]

(boolean? obj)
Return @code{#t} iff @var{obj} is either @code{#t} or @code{#f}.
[libguile/boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[libguile/chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[libguile/chars.c:66]

(char<? x y)
Return #t iff X is less than Y
in the @acronym{ASCII} sequence, else #f.
[libguile/chars.c:79]

(char<=? x y)
Return #t iff X is less than or equal to Y
in the @acronym{ASCII} sequence, else #f.
[libguile/chars.c:91]

(char>? x y)
Return #t iff X is greater than Y
in the @acronym{ASCII} sequence, else #f.
[libguile/chars.c:103]

(char>=? x y)
Return #t iff X is greater than or equal to Y
in the @acronym{ASCII} sequence, else #f.
[libguile/chars.c:115]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[libguile/chars.c:126]

(char-ci<? x y)
Return #t iff X is less than Y in the
@acronym{ASCII} sequence ignoring case, else #f.
[libguile/chars.c:138]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the
@acronym{ASCII} sequence ignoring case, else #f.
[libguile/chars.c:150]

(char-ci>? x y)
Return #t iff X is greater than Y in the
@acronym{ASCII} sequence ignoring case, else #f.
[libguile/chars.c:162]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the
@acronym{ASCII} sequence ignoring case, else #f.
[libguile/chars.c:174]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the @code{isalpha}
C library function.
[libguile/chars.c:188]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the @code{isdigit}
C library function.
[libguile/chars.c:200]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the @code{isspace}
C library function.
[libguile/chars.c:212]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the @code{isupper}
C library function.
[libguile/chars.c:226]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the @code{islower}
C library function.
[libguile/chars.c:239]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the @code{isupper}
and @code{islower} C library functions.
[libguile/chars.c:253]

(char->integer chr)
Return the number corresponding to ordinal position
of CHR in the @acronym{ASCII} sequence.
[libguile/chars.c:267]

(integer->char n)
Return the character at position N
in the @acronym{ASCII} sequence.
[libguile/chars.c:280]

(char-upcase chr)
Return the uppercase character version of CHR.
[libguile/chars.c:291]

(char-downcase chr)
Return the lowercase character version of CHR.
[libguile/chars.c:302]

(continuation? obj)
Return @code{#t} iff @var{obj} is a continuation.
[libguile/continuations.c:178]

(debug-options-interface [setting])
Option interface for the debug options. Instead of using
this procedure directly, use the procedures @code{debug-enable},
@code{debug-disable}, @code{debug-set!} and @code{debug-options}.
[libguile/debug.c:80]

(with-traps thunk)
Call @var{thunk} with traps enabled.
[libguile/debug.c:128]

(memoized? obj)
Return @code{#t} if @var{obj} is memoized.
[libguile/debug.c:169]

(unmemoize m)
Unmemoize the memoized expression @var{m}.
[libguile/debug.c:371]

(memoized-environment m)
Return the environment of the memoized expression @var{m}.
[libguile/debug.c:381]

(procedure-name proc)
Return the name of the procedure @var{proc}
[libguile/debug.c:391]

(procedure-source proc)
Return the source of the procedure @var{proc}.
[libguile/debug.c:417]

(procedure-environment proc)
Return the environment of the procedure @var{proc}.
[libguile/debug.c:452]

(local-eval exp [env])
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[libguile/debug.c:485]

(debug-object? obj)
Return @code{#t} if @var{obj} is a debug object.
[libguile/debug.c:572]

(%%registered-modules [clear])
[libguile/dynl.c:191]

(dynamic-link name)
Open the dynamic library file @var{name} and return
its @dfn{library handle}, suitable for passing to the
following functions.
As a special case, if @var{name} is @code{#f},
the returned handle is for the Guile executable itself.
[libguile/dynl.c:365]

(dynamic-object? obj)
Return @code{#t} iff @var{obj} is a dynamic library handle.
[libguile/dynl.c:381]

(dynamic-unlink h)
Unlink the library represented by dynamic library handle
@var{h},and remove any imported symbols from the address space.
[libguile/dynl.c:394]

(dynamic-func name h)
Import the function @var{name} from @var{h}, a dynamic library
handle, and return a @dfn{dynamic function handle}.
At the moment, the dynamic function handle
is formed by casting the address of @var{name}
to C type @code{long} and converting this number to its
Scheme representation.

Regardless whether your C compiler prepends an underscore
@samp{_} to the global names in a program, you should
@strong{not} include this underscore in @var{function}.
Guile knows whether the underscore is
needed or not and will add it when necessary.
[libguile/dynl.c:426]

(dynamic-call lib-thunk h)
Call @var{lib-thunk}, a procedure of no arguments.
If @var{lib-thunk} is a string, it is assumed to be a symbol
found in the dynamic library @var{h} and is fetched
with @code{dynamic-func}.  Otherwise, it should be a function
handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
Interrupts are deferred while the C function is executing
(with @code{SCM_DEFER_INTS} and @code{SCM_ALLOW_INTS}).
[libguile/dynl.c:459]

(dynamic-args-call proc h args)
Call @var{proc}, a dynamically loaded function,
passing it @var{args} (a list of strings).
As with @code{dynamic-call}, @var{proc} should be
either a function handle or a string, in which case
it is first fetched from @var{h} with @code{dynamic-func}.

@var{proc} should return an integer, which is used as the
return value from @code{dynamic-args-call}.
[libguile/dynl.c:483]

(dynamic-wind thunk1 thunk2 thunk3)
Call @var{in-guard}, then @var{thunk}, then @var{out-guard}.
All three arguments must be 0-argument procedures.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.  If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation 
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints: 
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[libguile/dynwind.c:117]

(eq? x y)
Return #t iff @var{x} references the same object as @var{y}.
@code{eq} is similar to @code{eqv?} except that in some cases
it is capable of discerning distinctions finer than
those detectable by @code{eqv?}.
[libguile/eq.c:65]

(eqv? x y)
The @code{eqv?} procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if @var{x} and @var{y} should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[libguile/eq.c:79]

(equal? x y)
Return #t iff @var{x} and @var{y} are recursively `eqv?' equivalent.
@code{equal?} recursively compares the contents of pairs, vectors, and
strings, applying @code{eqv?} on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally @code{equal?}
if they print the same.  @code{equal?} may fail to terminate if its
arguments are circular data structures.
[libguile/eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, possibly containing @code{~S} and @code{~A}
escapes.  When an error is reported, these are replaced by formating the
corresponding members of @var{args}: @code{~A} (was @code{%s}) formats using @code{display}
and @code{~S} (was @code{%S}) formats using @code{write}.  @var{data} is a
list or @code{#f} depending on @var{key}: if @var{key} is
@code{system-error} then it should be a list
containing the Unix @code{errno} value;  If @var{key} is @code{signal} then
it should be a list containing the Unix signal number; otherwise it
will usually be @code{#f}.
[libguile/error.c:114]

(strerror err)
Return the Unix error message corresponding to @var{err}, an integer.
[libguile/error.c:131]

(apply:nconc2last lst)
Given a list (@var{arg1} @dots{} @var{args}), cons the
@var{arg1} @dots{} arguments onto the front of
@var{args}, and return the resulting list.  Note that
@var{args} is a list; thus, the argument to this function is
a list whose last element is a list.
Note: Rather than do new consing, @code{apply:nconc2last}
destroys its argument, so use with care.
[libguile/eval.c:3270]

(force x)
Compute promise @var{x} and return its value, if it has not been
computed yet.  Otherwise just return the previously computed value.
[libguile/eval.c:3786]

(promise? x)
Return true if @var{obj} is a promise, i.e. a delayed computation
(@pxref{Delayed evaluation,,,r5rs.info,The Revised^5 Report on Scheme}).
[libguile/eval.c:3809]

(cons-source xorig x y)
Create and return a new pair whose @sc{car} and @sc{cdr} are @var{x} and @var{y}.
Any source properties associated with @var{xorig} are also associated
with the new pair.
[libguile/eval.c:3821]

(copy-tree obj)
Recursively copy the data tree that is bound to @var{obj}, and return a
pointer to the new data structure.  @code{copy-tree} recurses down the
contents of both pairs and vectors (since both cons cells and vector
cells may point to arbitrary objects), and stops recursing when it hits
any other object.
[libguile/eval.c:3843]

(eval2 obj env_thunk)
Evaluate @var{exp}, a Scheme expression, in the environment designated
by @var{lookup}, a symbol-lookup function.  @code{(eval exp)} is
equivalent to @code{(eval2 exp *top-level-lookup-closure*)}.
[libguile/eval.c:3889]

(eval obj)
Evaluate @var{exp}, a list representing a Scheme expression, in the
top-level environment.
[libguile/eval.c:3899]

(eval-options-interface [setting])
Option interface for the evaluation options. Instead of using
this procedure directly, use the procedures @code{eval-enable},
@code{eval-disable}, @code{eval-set!} and @code{eval-options}.
[libguile/eval.c:1754]

(evaluator-traps-interface [setting])
Option interface for the evaluator trap options.
[libguile/eval.c:1771]

(defined? sym [env])
Return @code{#t} if @var{sym} is defined in the top-level environment.
[libguile/evalext.c:73]

(map-in-order [arg1 ...])
scm_map
[libguile/evalext.c:152]

(program-arguments)
Return a list of the command-line arguments passed to the currently
running program.  If the program invoked Guile with the @samp{-s},
@samp{-c} or @samp{--} switches, these procedures ignore everything up
to and including those switches.
[libguile/feature.c:80]

(chown object owner group)
Change the ownership and group of the file referred to by @var{object} to
the integer values @var{owner} and @var{group}.  @var{object} can be
a string containing a file name or, if the platform
supports fchown, a port or integer file descriptor
which is open on the file.  The return value
is unspecified.

If @var{object} is a symbolic link, either the
ownership of the link or the ownership of the referenced file will be
changed depending on the operating system (lchown is
unsupported at present).  If @var{owner} or @var{group} is specified
as @code{-1}, then that ID is not changed.
[libguile/filesys.c:153]

(chmod object mode)
Change the permissions of the file referred to by @var{obj}.
@var{obj} can be a string containing a file name or a port or integer file
descriptor which is open on a file (in which case @code{fchmod} is used
as the underlying system call).
@var{mode} specifies
the new permissions as a decimal number, e.g., @code{(chmod "foo" #o755)}.
The return value is unspecified.
[libguile/filesys.c:193]

(umask [mode])
If @var{mode} is omitted, return a decimal number representing the current
file creation mask.  Otherwise set the file creation mask to
@var{mode} and return the previous value.

E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.
[libguile/filesys.c:227]

(open-fdes path flags [mode])
Similar to @code{open} but return a file descriptor instead of a
port.
[libguile/filesys.c:250]

(open path flags [mode])
Open the file named by @var{path} for reading and/or writing.
@var{flags} is an integer specifying how the file should be opened.
@var{mode} is an integer specifying the permission bits of the file, if
it needs to be created, before the umask is applied.  The default is 666
(Unix itself has no default).

@var{flags} can be constructed by combining variables using @code{logior}.
Basic flags are:

@defvar O_RDONLY
Open the file read-only.
@end defvar
@defvar O_WRONLY
Open the file write-only. 
@end defvar
@defvar O_RDWR
Open the file read/write.
@end defvar
@defvar O_APPEND
Append to the file instead of truncating.
@end defvar
@defvar O_CREAT
Create the file if it does not already exist.
@end defvar

See the Unix documentation of the @code{open} system call
for additional flags.
[libguile/filesys.c:293]

(close fd_or_port)
Similar to close-port (@pxref{Closing}),
but also take file descriptors.  A side
effect of closing a file descriptor is that any ports using that file
descriptor are moved to a different file descriptor and have
their revealed counts set to zero.
[libguile/filesys.c:331]

(close-fdes fd)
Close file descriptor @var{fd}, which must be an integer.
This is a simple wrapper for the @code{close} system call.
Unlike close (@pxref{Ports and File Descriptors, close}),
the file descriptor will be closed even if a port is using it.
The return value is unspecified.
[libguile/filesys.c:359]

(stat object)
Return an object containing various information
about the file determined by @var{obj}.
@var{obj} can be a string containing a file name or a port or integer file
descriptor which is open on a file (in which case @code{fstat} is used
as the underlying system call).

The object returned by @code{stat} can be passed as a single parameter
to the following procedures, all of which return integers:

@table @code
@item stat:dev
The device containing the file.
@item stat:ino
The file serial number, which distinguishes this file from all other
files on the same device.
@item stat:mode
The mode of the file.  This includes file type information
and the file permission bits.  See @code{stat:type} and @code{stat:perms}
below.
@item stat:nlink
The number of hard links to the file.
@item stat:uid
The user ID of the file's owner.
@item stat:gid
The group ID of the file.
@item stat:rdev
Device ID; this entry is defined only for character or block
special files.
@item stat:size
The size of a regular file in bytes.
@item stat:atime
The last access time for the file.
@item stat:mtime
The last modification time for the file.
@item stat:ctime
The last modification time for the attributes of the file.
@item stat:blksize
The optimal block size for reading or writing the file, in bytes.
@item stat:blocks
The amount of disk space that the file occupies measured in units of
512 byte blocks.
@end table

In addition, the following procedures return the information
from stat:mode in a more convenient form:

@table @code
@item stat:type
A symbol representing the type of file.  Possible values are
regular, directory, symlink, block-special, char-special,
fifo, socket and unknown
@item stat:perms
An integer representing the access permission bits.
@end table
[libguile/filesys.c:529]

(link oldpath newpath)
Create a new name @var{path-to} in the file system for the file
named by @var{path-from}.  If @var{path-from} is a symbolic link, the
link may or may not be followed depending on the system.
[libguile/filesys.c:575]

(rename-file oldname newname)
Rename the file specified by @var{path-from} to @var{path-to}.
The return value is unspecified.
[libguile/filesys.c:600]

(delete-file str)
Delete (or "unlink") the file specified by @var{path}.
[libguile/filesys.c:629]

(mkdir path [mode])
Create a new directory named by @var{path}.  If @var{mode} is omitted
then the permissions of the directory file are set using the current
umask.  Otherwise they are set to the decimal value specified with
@var{mode}.  The return value is unspecified.
[libguile/filesys.c:648]

(rmdir path)
Remove the existing directory named by @var{path}.  The directory must
be empty for this to succeed.  The return value is unspecified.
[libguile/filesys.c:677]

(directory-stream? obj)
Return a boolean indicating whether @var{object} is a directory stream
as returned by @code{opendir}.
[libguile/filesys.c:701]

(opendir dirname)
Open the directory specified by @var{path} and return a directory
stream.
[libguile/filesys.c:711]

(readdir port)
Return (as a string) the next directory entry from the directory stream
@var{stream}.  If there is no remaining entry to be read then the
end of file object is returned.
[libguile/filesys.c:729]

(rewinddir port)
Reset the directory port @var{stream} so that the next call to
@code{readdir} will return the first directory entry.
[libguile/filesys.c:748]

(closedir port)
Close the directory stream @var{stream}.
The return value is unspecified.
[libguile/filesys.c:762]

(chdir str)
Change the current working directory to @var{path}.
The return value is unspecified.
[libguile/filesys.c:812]

(getcwd)
Return the name of the current working directory.
[libguile/filesys.c:829]

(select reads writes excepts [secs [usecs]])
This procedure has a variety of uses: waiting for the ability
to provide input, accept output, or the existance of
exceptional conditions on a collection of ports or file
descriptors, or waiting for a timeout to occur.
It also returns if interrupted by a signal.

@var{reads}, @var{writes} and @var{excepts} can be lists or
vectors, with each member a port or a file descriptor.
The value returned is a list of three corresponding
lists or vectors containing only the members which meet the
specified requirement.  The ability of port buffers to
provide input or accept output is taken into account.
Ordering of the input lists or vectors is not preserved.

The optional arguments @var{secs} and @var{usecs} specify the
timeout.  Either @var{secs} can be specified alone, as
either an integer or a real number, or both @var{secs} and
@var{usecs} can be specified as integers, in which case
@var{usecs} is an additional timeout expressed in
microseconds.  If @var{secs} is omitted or is @code{#f} then
select will wait for as long as it takes for one of the other
conditions to be satisfied.

The scsh version of @code{select} differs as follows:
Only vectors are accepted for the first three arguments.
The @var{usecs} argument is not supported.
Multiple values are returned instead of a list.
Duplicates in the input vectors appear only once in output.
An additional @code{select!} interface is provided.
[libguile/filesys.c:1026]

(fcntl object cmd [value])
Apply @var{command} to the specified file descriptor or the underlying
file descriptor of the specified port.  @var{value} is an optional
integer argument.

Values for @var{command} are:

@table @code
@item F_DUPFD
Duplicate a file descriptor
@item F_GETFD
Get flags associated with the file descriptor.
@item F_SETFD
Set flags associated with the file descriptor to @var{value}.
@item F_GETFL
Get flags associated with the open file.
@item F_SETFL
Set flags associated with the open file to @var{value}
@item F_GETOWN
Get the process ID of a socket's owner, for @code{SIGIO} signals.
@item F_SETOWN
Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.
@item FD_CLOEXEC
The value used to indicate the "close on exec" flag with @code{F_GETFL} or
@code{F_SETFL}.
@end table
[libguile/filesys.c:1169]

(fsync object)
Copy any unwritten data for the specified output file descriptor to disk.
If @var{port/fd} is a port, its buffer is flushed before the underlying
file descriptor is fsync'd.
The return value is unspecified.
[libguile/filesys.c:1205]

(symlink oldpath newpath)
Create a symbolic link named @var{path-to} with the value (i.e., pointing to)
@var{path-from}.  The return value is unspecified.
[libguile/filesys.c:1232]

(readlink path)
Return the value of the symbolic link named by
@var{path} (a string), i.e., the
file that the link points to.
[libguile/filesys.c:1254]

(lstat str)
Similar to @code{stat}, but does not follow symbolic links, i.e.,
it will return information about a symbolic link itself, not the 
file it points to.  @var{path} must be a string.
[libguile/filesys.c:1285]

(copy-file oldfile newfile)
Copy the file specified by @var{path-from} to @var{path-to}.
The return value is unspecified.
[libguile/filesys.c:1311]

(dirname filename)
Return the directory name component of the file name
@var{filename}. If @var{filename} does not contain a directory
component, @code{.} is returned.
[libguile/filesys.c:1360]

(basename filename [suffix])
Return the base name of the file name @var{filename}. The
base name is the file name without any directory components.
If @var{suffix} is provided, and is equal to the end of
@var{basename}, it is removed also.
[libguile/filesys.c:1389]

(make-fluid)
Return a newly created fluid.
Fluids are objects of a certain type (a smob) that can hold one SCM
value per dynamic root.  That is, modifications to this value are
only visible to code that executes within the same dynamic root as
the modifying code.  When a new dynamic root is constructed, it
inherits the values from its parent.  Because each thread executes
in its own dynamic root, you can use fluids for thread local storage.
[libguile/fluids.c:129]

(fluid? obj)
Return #t iff @var{obj} is a fluid; otherwise, return #f.
[libguile/fluids.c:142]

(fluid-ref fluid)
Return the value associated with @var{fluid} in the current dynamic root.
If @var{fluid} has not been set, then this returns #f.
[libguile/fluids.c:152]

(fluid-set! fluid value)
Set the value associated with @var{fluid} in the current dynamic root.
[libguile/fluids.c:169]

(with-fluids* fluids values thunk)
Set @var{fluids} to @var{values} temporary, and call @var{thunk}.
@var{fluids} must be a list of fluids and @var{values} must be the same
number of their values to be applied.  Each substitution is done
one after another.  @var{thunk} must be a procedure with no argument.
[libguile/fluids.c:228]

(setvbuf port mode [size])
Set the buffering mode for @var{port}.  @var{mode} can be:
@table @code
@item _IONBF
non-buffered
@item _IOLBF
line buffered
@item _IOFBF
block buffered, using a newly allocated buffer of @var{size} bytes.
If @var{size} is omitted, a default size will be used.
@end table
[libguile/fports.c:147]

(open-file filename modes)
Open the file whose name is @var{string}, and return a port
representing that file.  The attributes of the port are
determined by the @var{mode} string.  The way in 
which this is interpreted is similar to C stdio:

The first character must be one of the following:

@table @samp
@item r
Open an existing file for input.
@item w
Open a file for output, creating it if it doesn't already exist
or removing its contents if it does.
@item a
Open a file for output, creating it if it doesn't already exist.
All writes to the port will go to the end of the file.
The "append mode" can be turned off while the port is in use
@pxref{Ports and File Descriptors, fcntl}
@end table

The following additional characters can be appended:

@table @samp
@item +
Open the port for both input and output.  E.g., @code{r+}: open
an existing file for both input and output.
@item 0
Create an "unbuffered" port.  In this case input and output operations
are passed directly to the underlying port implementation without
additional buffering.  This is likely to slow down I/O operations.
The buffering mode can be changed while a port is in use
@pxref{Ports and File Descriptors, setvbuf}
@item l
Add line-buffering to the port.  The port output buffer will be
automatically flushed whenever a newline character is written.
@end table

In theory we could create read/write ports which were buffered in one
direction only.  However this isn't included in the current interfaces.

If a file cannot be opened with the access requested,
@code{open-file} throws an exception.
[libguile/fports.c:270]

(gc-stats)
Return an association list of statistics about Guile's current use of storage.
[libguile/gc.c:561]

(object-address obj)
Return an integer that for the lifetime of @var{obj} is uniquely
returned by this function for @var{obj}
[libguile/gc.c:634]

(gc)
Scan all of SCM objects and reclaims for further use those that are
no longer accessible.
[libguile/gc.c:645]

(unhash-name name)
[libguile/gc.c:2071]

(make-guardian)
Create a new guardian.
A guardian protects a set of objects from garbage collection,
allowing a program to apply cleanup or other actions.

make-guardian returns a procedure representing the guardian.
Calling the guardian procedure with an argument adds the
argument to the guardian's set of protected objects.
Calling the guardian procedure without an argument returns
one of the protected objects which are ready for garbage
collection or @code{#f} if no such object is available.
Objects which are returned in this way are removed from
the guardian.

See R. Kent Dybvig, Carl Bruggeman, and David Eby (1993)
"Guardians in a Generation-Based Garbage Collector".
ACM SIGPLAN Conference on Programming Language Design
and Implementation, June 1993.
[libguile/guardians.c:181]

(hashq key size)
Determine a hash value for @var{key} that is suitable for lookups in
a hashtable of size @var{size}, where @code{eq?} is used as the equality
predicate.  The function returns an integer in the range 0 to
@var{size} - 1.  NOTE that @code{hashq} may use internal addresses.
Thus two calls to @code{hashq} where the keys are @code{eq?} are not
guaranteed to deliver the same value if the key object gets
garbage collected in between.  This can happen, for example
with symbols: @code{(hashq 'foo n) (gc) (hashq 'foo n)} may produce two
different values, since @code{foo} will be garbage collected.
[libguile/hash.c:178]

(hashv key size)
Determine a hash value for @var{key} that is suitable for lookups in
a hashtable of size @var{size}, where @code{eqv?} is used as the equality
predicate.  The function returns an integer in the range 0 to
@var{size} - 1.  NOTE that @code{(hashv key)} may use internal addresses.
Thus two calls to @code{hashv} where the keys are @code{eqv?} are not
guaranteed to deliver the same value if the key object gets
garbage collected in between.  This can happen, for example
with symbols: @code{(hashv 'foo n) (gc) (hashv 'foo n)} may produce two
different values, since @code{foo} will be garbage collected.
[libguile/hash.c:213]

(hash key size)
Determine a hash value for @var{key} that is suitable for lookups in
a hashtable of size @var{size}, where equal? is used as the equality
predicate.  The function returns an integer in the range 0 to
@var{size} - 1.
[libguile/hash.c:236]

(hashq-get-handle table obj)
Similar to @code{hashq-ref}, but return a
@dfn{handle} from the hash table rather than the value associated with
@var{key}.  By convention, a handle in a hash table is the pair which
associates a key with a value.  Where @code{hashq-ref table key} returns
only a @code{value}, @code{hashq-get-handle table key} returns the pair
@code{(key . value)}.
[libguile/hashtab.c:176]

(hashq-create-handle! table key init)
Look up @var{key} in @var{table} and return its handle.
If @var{key} is not already present, create a new handle which
associates @var{key} with @var{init}.
[libguile/hashtab.c:188]

(hashq-ref table obj [dflt])
Look up @var{key} in the hash table @var{table}, and return the
value (if any) associated with it.  If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument is
supplied).  Use @code{eq?} for equality testing.
[libguile/hashtab.c:201]

(hashq-set! table obj val)
Find the entry in @var{table} associated with @var{key}, and store
@var{value} there.  Uses @code{eq?} for equality testing.
[libguile/hashtab.c:215]

(hashq-remove! table obj)
Remove @var{key} (and any value associated with it) from @var{table}.
Use @code{eq?} for equality tests.
[libguile/hashtab.c:227]

(hashv-get-handle table obj)
Similar to @code{hashv-ref}, but return a
@dfn{handle} from the hash table rather than the value associated with
@var{key}.  By convention, a handle in a hash table is the pair which
associates a key with a value.  Where @code{hashv-ref table key} returns
only a @code{value}, @code{hashv-get-handle table key} returns the pair
@code{(key . value)}.
[libguile/hashtab.c:244]

(hashv-create-handle! table key init)
Look up @var{key} in @var{table} and return its handle.
If @var{key} is not already present, create a new handle which
associates @var{key} with @var{init}.
[libguile/hashtab.c:256]

(hashv-ref table obj [dflt])
Look up @var{key} in the hash table @var{table}, and return the
value (if any) associated with it.  If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument is
supplied).  Use @code{eqv?} for equality testing.
[libguile/hashtab.c:269]

(hashv-set! table obj val)
Find the entry in @var{table} associated with @var{key}, and store
@var{value} there.  Use @code{eqv?} for equality testing.
[libguile/hashtab.c:283]

(hashv-remove! table obj)
Remove @var{key} (and any value associated with it) from @var{table}.
Use @code{eqv?} for equality tests.
[libguile/hashtab.c:294]

(hash-get-handle table obj)
Similar to @code{hash-ref}, but return a
@dfn{handle} from the hash table rather than the value associated with
@var{key}.  By convention, a handle in a hash table is the pair which
associates a key with a value.  Where @code{hash-ref table key} returns
only a @code{value}, @code{hash-get-handle table key} returns the pair
@code{(key . value)}.
[libguile/hashtab.c:310]

(hash-create-handle! table key init)
Look up @var{key} in @var{table} and return its handle.
If @var{key} is not already present, a new handle is created which
associates @var{key} with @var{init}.
[libguile/hashtab.c:322]

(hash-ref table obj [dflt])
Look up @var{key} in the hash table @var{table}, and return the
value (if any) associated with it.  If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument is
supplied).  Use @code{equal?} for equality testing.
[libguile/hashtab.c:335]

(hash-set! table obj val)
Find the entry in @var{table} associated with @var{key}, and store
@var{value} there.  Use @code{equal?} for equality testing.
[libguile/hashtab.c:349]

(hash-remove! table obj)
Remove @var{key} (and any value associated with it) from @var{table}.
Use @code{equal?} for equality tests.
[libguile/hashtab.c:361]

(hashx-get-handle hash assoc table obj)
Behave similar to the corresponding @code{-get-handle}
function, but use @var{hasher} as a
hash function and @var{assoc} to compare keys.  @code{hasher} must
be a function that takes two arguments, a key to be hashed and a
table size.  @code{assoc} must be an associator function, like
@code{assoc}, @code{assq} or @code{assv}.
[libguile/hashtab.c:430]

(hashx-create-handle! hash assoc table obj init)
Behave similar to the corresponding @code{-create-handle}
function, but use @var{hasher} as a
hash function and @var{assoc} to compare keys.  @code{hasher} must
be a function that takes two arguments, a key to be hashed and a
table size.  @code{assoc} must be an associator function, like
@code{assoc}, @code{assq} or @code{assv}.
[libguile/hashtab.c:448]

(hashx-ref hash assoc table obj [dflt])
Behave similar to the corresponding @code{-ref}
function, but use @var{hasher} as a
hash function and @var{assoc} to compare keys.  @code{hasher} must
be a function that takes two arguments, a key to be hashed and a
table size.  @code{assoc} must be an associator function, like
@code{assoc}, @code{assq} or @code{assv}.

By way of illustration, @code{hashq-ref table key} is equivalent
to @code{hashx-ref hashq assq table key}.
[libguile/hashtab.c:469]

(hashx-set! hash assoc table obj val)
Behave similar to the corresponding @code{-set!}
function, but use @var{hasher} as a
hash function and @var{assoc} to compare keys.  @code{hasher} must
be a function that takes two arguments, a key to be hashed and a
table size.  @code{assoc} must be an associator function, like
@code{assoc}, @code{assq} or @code{assv}.

By way of illustration, @code{hashq-set! table key} is equivalent
to @code{hashx-set! hashq assq table key}.
[libguile/hashtab.c:493]

(hash-fold proc init table)
An iterator over hash-table elements.
Accumulate and return a result by applying @var{proc} successively.
The arguments to @var{proc} are "(key value prior-result)" where key
and value are successive pairs from the hash table @var{table}, and
prior-result is either @var{init} (for the first application of @var{proc})
or the return value of the previous application of @var{proc}.
For example, @code{(hash-fold acons () tab)} will convert a hash
table into an alist of key-value pairs.
[libguile/hashtab.c:529]

(make-hook-with-name name [n_args])
[libguile/hooks.c:215]

(make-hook [n_args])
Create a hook for storing procedure of arity @var{n_args}.
@var{n_args} defaults to zero.  The returned value is a hook
object to be used with the other hook procedures.
[libguile/hooks.c:231]

(hook? x)
Return @code{#t} if @var{x} is a hook, @code{#f} otherwise.
[libguile/hooks.c:241]

(hook-empty? hook)
Return @code{#t} if @var{hook} is an empty hook, @code{#f}
otherwise.
[libguile/hooks.c:252]

(add-hook! hook proc [append_p])
Add the procedure @var{proc} to the hook @var{hook}. The
procedure is added to the end if @var{append_p} is true,
otherwise it is added to the front.  The return value of this
procedure is not specified.
[libguile/hooks.c:266]

(remove-hook! hook proc)
Remove the procedure @var{proc} from the hook @var{hook}.  The
return value of this procedure is not specified.
[libguile/hooks.c:293]

(reset-hook! hook)
Remove all procedures from the hook @var{hook}.  The return
value of this procedure is not specified.
[libguile/hooks.c:307]

(run-hook hook [args ...])
Apply all procedures from the hook @var{hook} to the arguments
@var{args}.  The order of the procedure application is first to
last.  The return value of this procedure is not specified.
[libguile/hooks.c:321]

(hook->list hook)
Convert the procedure list of @var{hook} to a list.
[libguile/hooks.c:348]

(%read-delimited! delims buf gobble [port [start [end]]])
Read characters from @var{port} into @var{buf} until one of the
characters in the @var{delims} string is encountered.  If @var{gobble?}
is true, store the delimiter character in @var{buf} as well; otherwise,
discard it.  If @var{port} is not specified, use the value of
@code{(current-input-port)}.  If @var{start} or @var{end} are specified,
store data only into the substring of @var{buf} bounded by @var{start}
and @var{end} (which default to the beginning and end of the buffer,
respectively).

Return a pair consisting of the delimiter that terminated the string and
the number of characters read.  If reading stopped at the end of file,
the delimiter returned is the @var{eof-object}; if the buffer was filled
without encountering a delimiter, this value is @var{#f}.
[libguile/ioext.c:85]

(%read-line [port])
Read a newline-terminated line from @var{port}, allocating storage as
necessary.  The newline terminator (if any) is removed from the string,
and a pair consisting of the line and its delimiter is returned.  The
delimiter may be either a newline or the @var{eof-object}; if
@code{%read-line} is called at the end of file, it returns the pair
@code{(#<eof> . #<eof>)}.
[libguile/ioext.c:250]

(write-line obj [port])
Display @var{obj} and a newline character to @var{port}.  If @var{port}
is not specified, @code{(current-output-port)} is used.  This function
is equivalent to:

@smalllisp
(display obj [port])
(newline [port])
@end smalllisp
[libguile/ioext.c:303]

(ftell object)
Return an integer representing the current position of @var{fd/port},
measured from the beginning.  Equivalent to:
@smalllisp
(seek port 0 SEEK_CUR)
@end smalllisp
[libguile/ioext.c:317]

(fseek object offset whence)
Obsolete.  Almost the same as @code{seek} but the return value is
unspecified.
[libguile/ioext.c:330]

(redirect-port old new)
Duplicate the underlying file
descriptor from @var{old-port} into @var{new-port}.  The
current file descriptor in @var{new-port} is closed.
After the redirection the two ports share a file position
and file status flags.

The return value is unspecified.

Unexpected behaviour can result if both ports are subsequently used
and the original and/or duplicate ports are buffered.

This procedure does not have any side effects on other ports or
revealed counts.
[libguile/ioext.c:352]

(dup->fdes fd_or_port [fd])
Return a new integer file descriptor referring to the open file
designated by @var{fd_or_port}, which must be either an open
file port or a file descriptor.
[libguile/ioext.c:391]

(dup2 oldfd newfd)
A simple wrapper for the @code{dup2} system call.
Copy the file descriptor @var{oldfd} to descriptor
number @var{newfd}, replacing the previous meaning
of @var{newfd}.  Both @var{oldfd} and @var{newfd} must
be integers.
Unlike for dup->fdes or primitive-move->fdes, no attempt
is made to move away ports which are using @var{newfd}.
The return value is unspecified.
[libguile/ioext.c:437]

(fileno port)
Return the integer file descriptor underlying @var{port}.
Do not change its revealed count.
[libguile/ioext.c:456]

(close-all-fdes-except [fdes_list ...])
Close all file descriptors for ports used by the interpreter
except for those supplied as arguments.  This procedure
is intended to be used before an exec(2) call.  The related
procedure @code{close-all-ports-except} is unsuitable for that
because it flushes port buffers.
[libguile/ioext.c:471]

(isatty? port)
Return @code{#t} if @var{port} is using a serial
non-file device, otherwise @code{#f}.
[libguile/ioext.c:519]

(fdopen fdes modes)
Return a new port based on the file descriptor @var{fdes}.
Modes are given by the string @var{modes}.  The revealed count of the port
is initialized to zero.  The modes string is the same as that accepted
by @ref{File Ports, open-file}.
[libguile/ioext.c:541]

(primitive-move->fdes port fd)
Move the underlying file descriptor for @var{port} to the integer
value @var{fdes} without changing the revealed count of @var{port}.
Any other ports already using this descriptor are automatically
shifted to new descriptors and their revealed counts reset to zero.
The return value is @code{#f} if the file descriptor already had the
required value or @code{#t} if it was moved.
[libguile/ioext.c:566]

(fdes->ports fd)
Return a list of existing ports which have @var{fdes} as an
underlying file descriptor, without changing their revealed counts.
[libguile/ioext.c:599]

(make-keyword-from-dash-symbol symbol)
Return a keyword object from SYMBOL that starts with `-' (a dash).
[libguile/keywords.c:73]

(keyword? obj)
Returns #t if the argument OBJ is a keyword, else #f.
[libguile/keywords.c:114]

(keyword-dash-symbol keyword)
Return KEYWORD as a dash symbol.
This is the inverse of `make-keyword-from-dash-symbol'.
[libguile/keywords.c:125]

(nil-cons x y)
Create a new cons cell with @var{x} as the car and @var{y} as
the cdr, but convert @var{y} to Scheme's end-of-list if it is
a Lisp nil.
[libguile/lang.c:71]

(nil-car x)
Return the car of @var{x}, but convert it to LISP nil if it
is Scheme's end-of-list.
[libguile/lang.c:86]

(nil-cdr x)
Return the cdr of @var{x}, but convert it to LISP nil if it
is Scheme's end-of-list.
[libguile/lang.c:99]

(null x)
Return Lisp's @code{t} if @var{x} is nil in the LISP sense,
return Lisp's nil otherwise.
[libguile/lang.c:114]

(nil-eq x y)
Compare @var{x} and @var{y} and return Lisp's t if they are
@code{eq?}, return Lisp's nil otherwise.
[libguile/lang.c:143]

(list [objs ...])
Return a list containing OBJS, the arguments to `list'.
[libguile/list.c:84]

(list* [arg1 ...])
scm_cons_star
[libguile/list.c:94]

(cons* arg [rest ...])
Like @code{list}, but the last arg provides the tail of the
constructed list, returning (cons ARG1 (cons ARG2 (cons ... ARGn))).
At least one argument must be given, in which case that argument
is returned.
This is called @code{list*} in some other Schemes and in Common LISP.
[libguile/list.c:104]

(null? x)
Return #t iff X is the empty list, else #f.
[libguile/list.c:128]

(list? x)
Return #t iff X is a proper list, else #f.
[libguile/list.c:138]

(length lst)
Return the number of elements in list LST.
[libguile/list.c:179]

(append [args ...])
Return a list consisting of the elements of the first LIST
followed by the elements of the other LISTs.

@example
(append '(x) '(y))
@result{} (x y)

(append '(a) '(b c d))
@result{} (a b c d)

(append '(a (b)) '((c)))
@result{} (a (b) (c))
@end example
The resulting list is always newly allocated, except that it shares
structure with the last LIST argument.  The last argument may
actually be any object; an improper list results if the last
argument is not a proper list.

@example
(append '(a b) '(c . d))
@result{} (a b c . d)

(append '() 'a)
@result{} a
@end example
[libguile/list.c:213]

(append! [args ...])
A destructive version of @code{append} (@pxref{Pairs and Lists,,,r4rs,
The Revised^4 Report on Scheme}).  The cdr field of each list's final
pair is changed to point to the head of the next list, so no consing is
performed.  Return a pointer to the mutated list.
[libguile/list.c:246]

(last-pair lst)
Return a pointer to the last pair in @var{lst}, signalling an error if
@var{lst} is circular.
[libguile/list.c:272]

(reverse lst)
Return a new list that contains the elements of LST but in reverse order.
[libguile/list.c:301]

(reverse! lst [new_tail])
A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r4rs,
The Revised^4 Report on Scheme}).  The cdr of each cell in @var{lst} is
modified to point to the previous list element.  Return a pointer to the
head of the reversed list.

Caveat: because the list is modified in place, the tail of the original
list now becomes its head, and the head of the original list now becomes
the tail.  Therefore, the @var{lst} symbol to which the head of the
original list was bound now points to the tail.  To ensure that the head
of the modified list is not lost, it is wise to save the return value of
@code{reverse!}
[libguile/list.c:335]

(list-ref lst k)
Return the Kth element from list LST.
[libguile/list.c:361]

(list-set! lst k val)
Set the @var{k}th element of @var{lst} to @var{val}.
[libguile/list.c:379]

(list-cdr-ref)
scm_list_tail
[libguile/list.c:397]

(list-tail lst k)
Return the "tail" of @var{lst} beginning with its @var{k}th element.
The first element of the list is considered to be element 0.

@code{list-cdr-ref} and @code{list-tail} are identical.  It may help to
think of @code{list-cdr-ref} as accessing the @var{k}th cdr of the list,
or returning the results of cdring @var{k} times down @var{lst}.
[libguile/list.c:405]

(list-cdr-set! lst k val)
Set the @var{k}th cdr of @var{lst} to @var{val}.
[libguile/list.c:421]

(list-head lst k)
Copy the first @var{k} elements from @var{lst} into a new list, and
return it.
[libguile/list.c:445]

(list-copy lst)
Return a (newly-created) copy of @var{lst}.
If @var{lst} is not @code{cons?}, simply return it.
(This is for builtin compatibility with SRFI 1.)
[libguile/list.c:471]

(sloppy-memq x lst)
Behave like @code{memq}, but do no type or error checking.
Its use is recommended only in writing Guile internals,
not for high-level Scheme programs.
[libguile/list.c:504]

(sloppy-memv x lst)
Behave like @code{memv}, but do no type or error checking.
Its use is recommended only in writing Guile internals,
not for high-level Scheme programs.
[libguile/list.c:521]

(sloppy-member x lst)
Behave like @code{member}, but do no type or error checking.
Its use is recommended only in writing Guile internals,
not for high-level Scheme programs.
[libguile/list.c:538]

(memq x lst)
Return the first sublist of LST whose car is `eq?' to X
where the sublists of LST are the non-empty lists returned
by `(list-tail LST K)' for K less than the length of LST.  If
X does not occur in LST, then `#f' (not the empty list) is
returned.
[libguile/list.c:558]

(memv x lst)
Return the first sublist of LST whose car is `eqv?' to X
where the sublists of LST are the non-empty lists returned
by `(list-tail LST K)' for K less than the length of LST.  If
X does not occur in LST, then `#f' (not the empty list) is
returned.
[libguile/list.c:576]

(member x lst)
Return the first sublist of LST whose car is `equal?' to X
where the sublists of LST are the non-empty lists returned
by `(list-tail LST K)' for K less than the length of LST.  If
X does not occur in LST, then `#f' (not the empty list) is
returned.
[libguile/list.c:593]

(delq! item lst)
These procedures are destructive versions of @code{delq}, @code{delv}
and @code{delete}: they modify the pointers in the existing @var{lst}
rather than creating a new list.  Caveat evaluator: Like other
destructive list functions, these functions cannot modify the binding of
@var{lst}, and so cannot be used to delete the first element of
@var{lst} destructively.
[libguile/list.c:614]

(delv! item lst)
Destructively remove all elements from LST that are `eqv?' to ITEM.
[libguile/list.c:637]

(delete! item lst)
Destructively remove all elements from LST that are `equal?' to ITEM.
[libguile/list.c:661]

(delq item lst)
Return a newly-created copy of @var{lst} with elements `eq?' to @var{item} removed.
This procedure mirrors @code{memq}:
@code{delq} compares elements of @var{lst} against @var{item} with
@code{eq?}.
[libguile/list.c:690]

(delv item lst)
Return a newly-created copy of @var{lst} with elements `eqv?' to @var{item} removed.
This procedure mirrors @code{memv}:
@code{delv} compares elements of @var{lst} against @var{item} with
@code{eqv?}.
[libguile/list.c:703]

(delete item lst)
Return a newly-created copy of @var{lst} with elements `equal?' to @var{item} removed.
This procedure mirrors @code{member}:
@code{delete} compares elements of @var{lst} against @var{item} with
@code{equal?}.
[libguile/list.c:716]

(delq1! item lst)
Like `delq!', but only deletes the first occurrence of ITEM from LST.
Tests for equality using `eq?'.  See also `delv1!' and `delete1!'.
[libguile/list.c:728]

(delv1! item lst)
Like `delv!', but only deletes the first occurrence of ITEM from LST.
Tests for equality using `eqv?'.  See also `delq1!' and `delete1!'.
[libguile/list.c:755]

(delete1! item lst)
Like `delete!', but only deletes the first occurrence of ITEM from LST.
Tests for equality using `equal?'.  See also `delq1!' and `delv1!'.
[libguile/list.c:782]

(primitive-load filename)
Load @var{file} and evaluate its contents in the top-level environment.
The load paths are not searched; @var{file} must either be a full
pathname or be a pathname relative to the current directory.  If the
variable @code{%load-hook} is defined, it should be bound to a procedure
that will be called before any code is loaded.  See documentation for
@code{%load-hook} later in this section.
[libguile/load.c:110]

(%package-data-dir)
Return the name of the directory where Scheme packages, modules and
libraries are kept.  On most Unix systems, this will be
@samp{/usr/local/share/guile}.
[libguile/load.c:145]

(%library-dir)
Return the directory where the Guile Scheme library files are installed.
E.g., may return "/usr/share/guile/1.3.5".
[libguile/load.c:157]

(%site-dir)
Return the directory where the Guile site files are installed.
E.g., may return "/usr/share/guile/site".
[libguile/load.c:169]

(parse-path path [tail])
Parse @var{path}, which is expected to be a colon-separated
string, into a list and return the resulting list with
@var{tail} appended. If @var{path} is @code{#f}, @var{tail}
is returned.
[libguile/load.c:221]

(search-path path filename [extensions])
Search @var{path} for a directory containing a file named
@var{filename}. The file must be readable, and not a directory.
If we find one, return its full filename; otherwise, return
@code{#f}.  If @var{filename} is absolute, return it unchanged.
If given, @var{extensions} is a list of strings; for each
directory in @var{path}, we search for @var{filename}
concatenated with each @var{extension}.
[libguile/load.c:273]

(%search-load-path filename)
Search @var{%load-path} for @var{file}, which must be readable by the
current user.  If @var{file} is found in the list of paths to search or
is an absolute pathname, return its full pathname.  Otherwise, return
@code{#f}.  Filenames may have any of the optional extensions in the
@code{%load-extensions} list; @code{%search-load-path} will try each
extension automatically.
[libguile/load.c:421]

(primitive-load-path filename)
Search @var{%load-path} for @var{file} and load it into the top-level
environment.  If @var{file} is a relative pathname and is not found in
the list of search paths, an error is signalled.
[libguile/load.c:442]

(read-and-eval! [port])
Read a form from @var{port} (standard input by default), and evaluate it
(memoizing it in the process) in the top-level environment.  If no data
is left to be read from @var{port}, an @code{end-of-file} error is
signalled.
[libguile/load.c:477]

(%%ltdl command [args ...])
Dispatch @var{command} given @var{args}, where
@var{command} is one of @code{add-search-dir!},
@code{set-search-path!}, or @code{get-search-path}
(a symbol).  This interface is highly experimental.
[libguile/lt.c:93]

(procedure->syntax code)
Return a @dfn{macro} which, when a symbol defined to this value
appears as the first symbol in an expression, returns the result
of applying @var{code} to the expression and the environment.
[libguile/macros.c:60]

(procedure->macro code)
Return a @dfn{macro} which, when a symbol defined to this value
appears as the first symbol in an expression, evaluates the result
of applying @var{code} to the expression and the environment.
The value returned from @var{code} which has been passed to
@code{procedure->memoizing-macro} replaces the form passed to
@var{code}.  For example:

@example
(define trace
  (procedure->macro
   (lambda (x env) `(set! ,(cadr x) (tracef ,(cadr x) ',(cadr x))))))

(trace @i{foo}) @equiv{} (set! @i{foo} (tracef @i{foo} '@i{foo})).
@end example
[libguile/macros.c:82]

(procedure->memoizing-macro code)
Return a @dfn{macro} which, when a symbol defined to this value
appears as the first symbol in an expression, evaluates the result
of applying @var{proc} to the expression and the environment.
The value returned from @var{proc} which has been passed to
@code{procedure->memoizing-macro} replaces the form passed to
@var{proc}.  For example:

@example
(define trace
  (procedure->macro
   (lambda (x env) `(set! ,(cadr x) (tracef ,(cadr x) ',(cadr x))))))

(trace @i{foo}) @equiv{} (set! @i{foo} (tracef @i{foo} '@i{foo})).
@end example
[libguile/macros.c:104]

(macro? obj)
Return @code{#t} if @var{obj} is a regular macro, a memoizing macro or a
syntax transformer.
[libguile/macros.c:116]

(macro-type m)
Return one of the symbols @code{syntax}, @code{macro} or @code{macro!},
depending on whether @var{obj} is a syntax tranformer, a regular macro,
or a memoizing macro, respectively.  If @var{obj} is not a macro,
@code{#f} is returned.
[libguile/macros.c:133]

(macro-name m)
Return the name of the macro @var{m}.
[libguile/macros.c:151]

(macro-transformer m)
Return the transformer of the macro @var{m}.
[libguile/macros.c:162]

(GH_UPSTREAM_MODULE_REFS4 m1 m2 m3 m4)
Expand the module handles @var{m1} through @var{m4} into a static
string array terminated by NULL, suitable for use as the fourth
argument to @code{GH_NEEDY_MODULE_LINK_FUNC}.
[libguile/modsup.h:222]

(GH_UPSTREAM_MODULE_REFS3 m1 m2 m3)
Expand the module handles @var{m1} through @var{m3} into a static
string array terminated by NULL, suitable for use as the fourth
argument to @code{GH_NEEDY_MODULE_LINK_FUNC}.
[libguile/modsup.h:212]

(GH_UPSTREAM_MODULE_REFS2 m1 m2)
Expand the module handles @var{m1} and @var{m2} into a static string
array terminated by NULL, suitable for use as the fourth argument to
@code{GH_NEEDY_MODULE_LINK_FUNC}.
[libguile/modsup.h:203]

(GH_UPSTREAM_MODULE_REFS1 m1)
Expand the module handle @var{m1} into a static string array
terminated by NULL, suitable for use as the fourth argument to
@code{GH_NEEDY_MODULE_LINK_FUNC}.
[libguile/modsup.h:195]

(GH_UPSTREAM_MODULE_REF_COMMA x)
Expand module handle @var{x} into the name of its string-holding C var
followed by a comma.  This is a convenience (or pre-processor abusive,
depending on your point of view) macro meant to be used when forming
the fourth argument to @code{GH_NEEDY_MODULE_LINK_FUNC}.  @var{x} is
the same as the first arg to @code{GH_USE_MODULE}.
[libguile/modsup.h:188]

(GH_CALLER3_FROM_VAR cvar proc_cvar)
Declare and define a procedure @var{cvar} that takes 3 (three) SCM args,
which returns the result of calling @code{gh_call3} on @var{proc_cvar}
and the args.  @var{proc_var} is the SCM object declared with
@code{GH_SELECT_MODULE_VAR}.
[libguile/modsup.h:178]

(GH_CALLER2_FROM_VAR cvar proc_cvar)
Declare and define a procedure @var{cvar} that takes 2 (two) SCM args,
which returns the result of calling @code{gh_call2} on @var{proc_cvar}
and the args.  @var{proc_var} is the SCM object declared with
@code{GH_SELECT_MODULE_VAR}.
[libguile/modsup.h:169]

(GH_CALLER1_FROM_VAR cvar proc_cvar)
Declare and define a procedure @var{cvar} that takes 1 (one) SCM arg,
which returns the result of calling @code{gh_call1} on @var{proc_cvar}
and this arg.  @var{proc_var} is the SCM object declared with
@code{GH_SELECT_MODULE_VAR}.
[libguile/modsup.h:160]

(GH_CALLER0_FROM_VAR cvar proc_cvar)
Declare and define a procedure @var{cvar} that takes 0 (zero) args,
which returns the result of calling @code{gh_call0} on @var{proc_cvar}.
@var{proc_cvar} is the SCM object declared with @code{GH_SELECT_MODULE_VAR}.
[libguile/modsup.h:151]

(GH_SELECT_MODULE_VAR cvar m_cvar s_name)
Declare and later arrange for @var{cvar} (type SCM) to have the
same value as the imported module @var{m_cvar} variable @var{s_name}.
@var{m_cvar} is the SCM object declared with @code{GH_USE_MODULE}, and
@var{s_name} is a string such as "q-empty?".
[libguile/modsup.h:135]

(GH_USE_MODULE cvar fullname)
Declare and later arrange for @var{cvar} (type SCM) to hold a resolved
module object for @var{fullname}, a C string such as "(ice-9 q)".  The
string is saved in a C variable named by prefixing "s_" to @var{cvar}.
You must use @var{cvar} as the second arg to @code{GH_SELECT_MODULE_VAR}.
[libguile/modsup.h:121]

(GH_STONED obj)
Return the @var{obj} given, but marked as "permanent".
This means that it can never be garbage collected.
[libguile/modsup.h:113]

(GH_NEEDY_MODULE_LINK_FUNC module_name fname_frag  module_init_func  up)
Define the C function to be called at link time for a needy module.

This function registers the @var{module_name} (a string) and arranges for
@var{module_init_func} to be called at the right time to actually do the
module-specific initializations.  @var{fname_frag} is the C translation of
@var{module_name} with unrepresentable characters replaced by underscore.
It should have the same length as @var{module_name}.  @var{up} is a static
array of strings (elements have type @code{char *}) that name the upstream
modules whose interfaces are required to be resolved before commencing
initialization of this one.  The last element of the array must be NULL.
[libguile/modsup.h:101]

(GH_MODULE_LINK_FUNC module_name  fname_frag  module_init_func)
Define the C function to be called at link time for a non-needy module.

This function registers the @var{module_name} (a string) and arranges for
@var{module_init_func} to be called at the right time to actually do the
module-specific initializations.  @var{fname_frag} is the C translation of
@var{module_name} with unrepresentable characters replaced by underscore.
It should have the same length as @var{module_name}.
[libguile/modsup.h:83]

(GH_DEFPROC fname  primname  req  opt  var  arglist  docstring)
Declare, define and document a C function callable from Scheme.

The C function is declared `static' and is "exported" later by the the
module initialization routine.  @var{fname} is the name of the C function
(must be a valid C identifier).  @var{primname}, a string, is the name
visible from Scheme code.  @var{req}, @var{opt} and @var{var} are each
integers quantifying the number of required, optional and rest args are in
the @var{arglist}.  Note that @var{var} can be only 0 or 1.  @var{arglist}
is the C-style argument list for the function.  The type for every element
must be @code{SCM}.  @code{docstring} is one or more strings that describe
the function.  Each string except the last must end in @code{\n}.
[libguile/modsup.h:71]

(standard-eval-closure module)
Return an eval closure for the module @var{module}.
[libguile/modules.c:271]

(inet-aton address)
Convert a string containing an Internet host address in the traditional
dotted decimal notation into an integer.

@smalllisp
(inet-aton "127.0.0.1") @result{} 2130706433

@end smalllisp
[libguile/net_db.c:96]

(inet-ntoa inetid)
Convert an integer Internet host address into a string with the
traditional dotted decimal representation.

@smalllisp
(inet-ntoa 2130706433) @result{} "127.0.0.1"
@end smalllisp
[libguile/net_db.c:117]

(inet-netof address)
Return the network number part of the given integer Internet address.

@smalllisp
(inet-netof 2130706433) @result{} 127
@end smalllisp
[libguile/net_db.c:136]

(inet-lnaof address)
Return the local-address-with-network part of the given Internet
address.

@smalllisp
(inet-lnaof 2130706433) @result{} 1
@end smalllisp
[libguile/net_db.c:153]

(inet-makeaddr net lna)
Make an Internet host address by combining the network number @var{net}
with the local-address-within-network number @var{lna}.

@smalllisp
(inet-makeaddr 127 1) @result{} 2130706433
@end smalllisp
[libguile/net_db.c:170]

(gethost [name])
Look up a host by name or address, returning a host object.  The
@code{gethost} procedure will accept either a string name or an integer
address; if given no arguments, it behaves like @code{gethostent} (see
below).  If a name or address is supplied but the address can not be
found, an error will be thrown to one of the keys:
@code{host-not-found}, @code{try-again}, @code{no-recovery} or
@code{no-data}, corresponding to the equivalent @code{h_error} values.
Unusual conditions may result in errors thrown to the
@code{system-error} or @code{misc_error} keys.
[libguile/net_db.c:253]

(getnet [name])
Look up a network by name or net number in the network database.  The
@var{net-name} argument must be a string, and the @var{net-number}
argument must be an integer.  @code{getnet} will accept either type of
argument, behaving like @code{getnetent} (see below) if no arguments are
given.
[libguile/net_db.c:332]

(getproto [name])
Look up a network protocol by name or by number.  @code{getprotobyname}
takes a string argument, and @code{getprotobynumber} takes an integer
argument.  @code{getproto} will accept either type, behaving like
@code{getprotoent} (see below) if no arguments are supplied.
[libguile/net_db.c:382]

(getserv [name [proto]])
Look up a network service by name or by service number, and return a
network service object.  The @var{protocol} argument specifies the name
of the desired protocol; if the protocol found in the network service
database does not match this name, a system error is signalled.

The @code{getserv} procedure will take either a service name or number
as its first argument; if given no arguments, it behaves like
@code{getservent} (see below).
[libguile/net_db.c:449]

(sethost [arg])
If @var{stayopen} is omitted, this is equivalent to @code{endhostent}.
Otherwise it is equivalent to @code{sethostent stayopen}.
[libguile/net_db.c:490]

(setnet [arg])
If @var{stayopen} is omitted, this is equivalent to @code{endnetent}.
Otherwise it is equivalent to @code{setnetent stayopen}.
[libguile/net_db.c:506]

(setproto [arg])
If @var{stayopen} is omitted, this is equivalent to @code{endprotoent}.
Otherwise it is equivalent to @code{setprotoent stayopen}.
[libguile/net_db.c:522]

(setserv [arg])
If @var{stayopen} is omitted, this is equivalent to @code{endservent}.
Otherwise it is equivalent to @code{setservent stayopen}.
[libguile/net_db.c:538]

(exact? x)
Return #t if X is an exact number, #f otherwise.
[libguile/numbers.c:106]

(odd? n)
Return #t if N is an odd number, #f otherwise.
[libguile/numbers.c:122]

(even? n)
Return #t if N is an even number, #f otherwise.
[libguile/numbers.c:138]

(logand n1 n2)
Return the integer which is the bitwise @sc{and}
of the two integer arguments.

Example:
@lisp
(number->string (logand #b1100 #b1010) 2)
   @result{} "1000"
@end lisp
[libguile/numbers.c:735]

(logior n1 n2)
Return the integer which is the bitwise @sc{or}
of the two integer arguments.

Example:
@lisp
(number->string (logior #b1100 #b1010) 2)
   @result{} "1110"
@end lisp
[libguile/numbers.c:822]

(logxor n1 n2)
Return the integer which is the bitwise @sc{xor}
of the two integer arguments.

Example:
@lisp
(number->string (logxor #b1100 #b1010) 2)
   @result{} "110"
@end lisp
[libguile/numbers.c:908]

(logtest n1 n2)
@example
(logtest j k) @equiv{} (not (zero? (logand j k)))

(logtest #b0100 #b1011) @result{} #f
(logtest #b0100 #b0111) @result{} #t
@end example
[libguile/numbers.c:977]

(logbit? index j)
@example
(logbit? index j) @equiv{} (logtest (integer-expt 2 index) j)

(logbit? 0 #b1101) @result{} #t
(logbit? 1 #b1101) @result{} #f
(logbit? 2 #b1101) @result{} #t
(logbit? 3 #b1101) @result{} #t
(logbit? 4 #b1101) @result{} #f
@end example
[libguile/numbers.c:1034]

(lognot n)
Return the integer which is the 2s-complement of the integer argument.

Example:
@lisp
(number->string (lognot #b10000000) 2)
   @result{} "-10000001"
(number->string (lognot #b0) 2)
   @result{} "-1"
@end lisp
[libguile/numbers.c:1083]

(integer-expt n k)
Return @var{n} raised to the non-negative integer exponent @var{k}.

Example:
@lisp
(integer-expt 2 5)
   @result{} 32
(integer-expt -3 3)
   @result{} -27
@end lisp
[libguile/numbers.c:1099]

(ash n cnt)
Perform an arithmetic shift of @var{n} left by @var{cnt} bits
(or shift right, if @var{cnt} is negative).  'Arithmetic' means, that
the function does not guarantee to keep the bit structure of N,
but rather guarantees that the result will always be rounded
towards minus infinity.  Therefore, the results of ash and a
corresponding bitwise shift will differ if N is negative.

Formally, the function returns an integer equivalent to
@code{(inexact->exact (floor (* N (expt 2 @var{cnt}))))}.@refill

Example:
@lisp
(number->string (ash #b1 3) 2)
   @result{} "1000"
(number->string (ash #b1010 -1) 2)
   @result{} "101"
@end lisp
[libguile/numbers.c:1146]

(bit-extract n start end)
Return the integer composed of the @var{start} (inclusive) through
@var{end} (exclusive) bits of @var{n}.  The @var{start}th bit becomes
the 0-th bit in the result.  For example:

@lisp
(number->string (bit-extract #b1101101010 0 4) 2)
   @result{} "1010"
(number->string (bit-extract #b1101101010 4 9) 2)
   @result{} "10110"
@end lisp

Signal out-of-range error if @var{n} is negative.
[libguile/numbers.c:1199]

(logcount n)
Return the number of bits in integer @var{n}.  If integer is positive,
the 1-bits in its binary representation are counted.  If negative, the
0-bits in its two's-complement binary representation are counted.  If 0,
0 is returned.

Example:
@lisp
(logcount #b10101010)
   @result{} 4
(logcount 0)
   @result{} 0
(logcount -2)
   @result{} 1
@end lisp
[libguile/numbers.c:1243]

(integer-length n)
Return the number of bits neccessary to represent @var{n}.

Example:
@lisp
(integer-length #b10101010)
   @result{} 8
(integer-length 0)
   @result{} 0
(integer-length #b1111)
   @result{} 4
@end lisp
[libguile/numbers.c:1294]

(number->string n [radix])
Return a string holding the external representation of the
number N in the given RADIX.  If N is inexact, a radix of 10
will be used.
[libguile/numbers.c:2264]

(string->number string [radix])
Return a number of the maximally precise representation
expressed by the given STRING. RADIX must be an exact integer,
either 2, 8, 10, or 16. If supplied, RADIX is a default radix
that may be overridden by an explicit radix prefix in STRING
(e.g. "#o177"). If RADIX is not supplied, then the default
radix is 10. If string is not a syntactically valid notation
for a number, then `string->number' returns #f.  (r5rs)
[libguile/numbers.c:2848]

(number?)
scm_number_p
[libguile/numbers.c:2915]

(complex? x)
Return #t if X is a complex number, #f else.  Note that the
sets of real, rational and integer values form subsets of the
set of complex numbers, i. e. the predicate will also be
fulfilled if X is a real, rational or integer number.
[libguile/numbers.c:2922]

(real?)
scm_real_p
[libguile/numbers.c:2930]

(rational? x)
Return #t if X is a rational number, #f else.  Note that the
set of integer values forms a subset of the set of rational
numbers, i. e. the predicate will also be fulfilled if X is an
integer number.
[libguile/numbers.c:2937]

(integer? x)
Return #t if X is an integer number, #f else.
[libguile/numbers.c:2957]

(inexact? x)
Return #t if X is an inexact number, #f else.
[libguile/numbers.c:2981]

(> x y)
Return #t if the list of parameters is monotonically
increasing.
[libguile/numbers.c:3103]

(<= x y)
Return #t if the list of parameters is monotonically
non-decreasing.
[libguile/numbers.c:3114]

(>= x y)
Return #t if the list of parameters is monotonically
non-increasing.
[libguile/numbers.c:3125]

($expt z1 z2)
[libguile/numbers.c:3956]

($atan2 z1 z2)
[libguile/numbers.c:3968]

(make-rectangular real imaginary)
Return a complex number constructed of the given REAL and
IMAGINARY parts.
[libguile/numbers.c:3981]

(make-polar z1 z2)
Return the complex number Z1 * e^(i * Z2).
[libguile/numbers.c:3994]

(inexact->exact z)
Return an exact number that is numerically closest to Z.
[libguile/numbers.c:4107]

(entity? obj)
Return @code{#t} if @var{obj} is an entity.
[libguile/objects.c:360]

(operator? obj)
Return @code{#t} if @var{obj} is an operator.
[libguile/objects.c:369]

(set-object-procedure! obj proc)
Set the object procedure of @var{obj} to @var{proc}.
@var{obj} must be either an entity or an operator.
[libguile/objects.c:381]

(make-class-object metaclass layout)
Create a new class object of class @var{metaclass}, with the
slot layout specified by @var{layout}.
[libguile/objects.c:440]

(make-subclass-object class layout)
Create a subclass object of @var{class}, with the slot layout
specified by @var{layout}.
[libguile/objects.c:455]

(object-properties obj)
Return @var{obj}'s property list.
[libguile/objprop.c:62]

(set-object-properties! obj plist)
Set @var{obj}'s property list to @var{alist}.
[libguile/objprop.c:72]

(object-property obj key)
Return the property of @var{obj} with name @var{key}.
[libguile/objprop.c:83]

(set-object-property! obj key val)
In @var{obj}'s property list, set the property named @var{key} to
@var{value}.
[libguile/objprop.c:95]

(cons x y)
Return a newly allocated pair whose car is @var{x} and whose cdr is
@var{y}.  The pair is guaranteed to be different (in the sense of
@code{eqv?}) from every previously existing object.
[libguile/pairs.c:62]

(pair? x)
Return @code{#t} if @var{x} is a pair; otherwise returns @code{#f}.
[libguile/pairs.c:94]

(set-car! pair value)
Store @var{value} in the car field of @var{pair}.  The value returned
by @code{set-car!} is unspecified.
[libguile/pairs.c:105]

(set-cdr! pair value)
Store @var{value} in the cdr field of @var{pair}.  The value returned
by @code{set-cdr!} is unspecified.
[libguile/pairs.c:118]

(char-ready? [port])
Return @code{#t} if a character is ready on input @var{port} and
@code{#f} otherwise.  If @code{char-ready?} returns @code{#t}
then the next @code{read-char} operation on @var{port} is
guaranteed not to hang.  If @var{port} is a file port at end of
file then return @code{#t}.
@footnote{@code{char-ready?} exists to make it possible for a
program to accept characters from interactive ports without getting
stuck waiting for input.  Any input editors associated with such ports
must make sure that characters whose existence has been asserted by
@code{char-ready?} cannot be rubbed out.  If @code{char-ready?} were to
return @code{#f} at end of file, a port at end of file would be
indistinguishable from an interactive port that has no ready
characters.}
[libguile/ports.c:241]

(drain-input port)
Drain @var{port}'s read buffers (including any pushed-back characters)
and return the contents as a single string.
[libguile/ports.c:276]

(current-input-port)
Return the current input port.  This is the default port used by many
input procedures.  Initially, @code{current-input-port} returns the
port associated with @dfn{stdin} (in Unix and C terminology).
[libguile/ports.c:313]

(current-output-port)
Return the current output port.  This is the default port used by many
output procedures.  Initially, @code{current-output-port} returns the
port associated with @dfn{stdout} (in Unix and C terminology).
[libguile/ports.c:324]

(current-error-port)
Return the port to which errors and warnings should be sent (the
@dfn{stderr} in Unix and C terminology).
[libguile/ports.c:334]

(current-load-port)
Return the current-load-port.
The load port is used internally by @code{primitive-load}.
[libguile/ports.c:344]

(set-current-input-port port)
Set the current default input port to @var{port}.
[libguile/ports.c:353]

(set-current-output-port port)
Set the current default output port to @var{port}.
[libguile/ports.c:366]

(set-current-error-port port)
Set the current default error port to @var{port}.
[libguile/ports.c:380]

(port-revealed port)
Return the revealed count for @var{port}.
[libguile/ports.c:519]

(set-port-revealed! port rcount)
Set the revealed count for a port to a given value.
The return value is unspecified.
[libguile/ports.c:532]

(port-mode port)
Return the port modes associated with the open port @var{port}.  These
are necessarily identical to the modes used when the port was
opened, since modes such as "append" which are used only during
port creation are not retained.
[libguile/ports.c:575]

(close-port port)
Close the specified port object.  Return @code{#t} if successful
@code{#f} if the port was already
closed.  An exception may be raised if an error occurs, for example
when flushing buffered output.
See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[libguile/ports.c:612]

(close-input-port port)
Close the specified input port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[libguile/ports.c:640]

(close-output-port port)
Close the specified output port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[libguile/ports.c:655]

(close-all-ports-except [ports ...])
Close all open file ports used by the interpreter
except for those supplied as arguments.
You probably don't want to use this procedure prior to an exec
call; see related procedure @code{close-all-fdes-except} instead.
[libguile/ports.c:670]

(input-port? x)
Return @code{#t} if @var{x} is an input port, otherwise
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[libguile/ports.c:708]

(output-port? x)
Return @code{#t} if @var{x} is an output port, otherwise
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[libguile/ports.c:721]

(port-closed? port)
Return @code{#t} if @var{port} is closed or @code{#f} if it is open.
[libguile/ports.c:734]

(eof-object? x)
Return @code{#t} if @var{x} is an end-of-file object; otherwise
@code{#f}.
[libguile/ports.c:745]

(force-output [port])
Flush the specified output port, or the current output port if @var{port}
is omitted.  The current output buffer contents are passed to the 
underlying port implementation (e.g., in the case of fports, the
data will be written to the file and the output buffer will be cleared.)
It has no effect on an unbuffered port.

The return value is unspecified.
[libguile/ports.c:759]

(flush-all-ports)
Equivalent to calling @code{force-output} on
all open output ports.  The return value is unspecified.
[libguile/ports.c:777]

(read-char [port])
Return the next character available from @var{port}, updating
@var{port} to point to the following character.  If no more
characters are available, an end-of-file object is returned.
[libguile/ports.c:795]

(peek-char [port])
Return the next character available from @var{port},
@emph{without} updating @var{port} to point to the following
character.  If no more characters are available, an end-of-file object
is returned.@footnote{The value returned by a call to @code{peek-char}
is the same as the value that would have been returned by a call to
@code{read-char} on the same port.  The only difference is that the very
next call to @code{read-char} or @code{peek-char} on that
@var{port} will return the value returned by the preceding call to
@code{peek-char}.  In particular, a call to @code{peek-char} on an
interactive port will hang waiting for input whenever a call to
@code{read-char} would have hung.}
[libguile/ports.c:1036]

(unread-char cobj port)
Place @var{char} in @var{port} so that it will be read by the
next read operation.  If called multiple times, the unread characters
will be read again in last-in first-out order.  If @var{port} is
not supplied, the current input port is used.
[libguile/ports.c:1057]

(unread-string str port)
Place the string @var{str} in @var{port} so that its characters will be
read in subsequent read operations.  If called multiple times, the
unread characters will be read again in last-in first-out order.  If
@var{port} is not supplied, the current-input-port is used.
[libguile/ports.c:1080]

(seek object offset whence)
Set the current position of @var{fd/port} to the integer @var{offset},
which is interpreted according to the value of @var{whence}.

One of the following variables should be supplied
for @var{whence}:
@defvar SEEK_SET
Seek from the beginning of the file.
@end defvar
@defvar SEEK_CUR
Seek from the current position.
@end defvar
@defvar SEEK_END
Seek from the end of the file.
@end defvar

If @var{fd/port} is a file descriptor, the underlying system call is
@code{lseek}.  @var{port} may be a string port.

The value returned is the new position in the file.  This means that
the current position of a port can be obtained using:
@smalllisp
(seek port 0 SEEK_CUR)
@end smalllisp
[libguile/ports.c:1116]

(truncate-file object [length])
Truncate the object referred to by @var{obj} to at most @var{size} bytes.
@var{obj} can be a string containing a file name or an integer file
descriptor or a port.  @var{size} may be omitted if @var{obj} is not
a file name, in which case the truncation occurs at the current port
position.

The return value is unspecified.
[libguile/ports.c:1157]

(port-line port)
Return the current line number for @var{port}.
[libguile/ports.c:1211]

(set-port-line! port line)
Set the current line number for @var{port} to @var{line}.
[libguile/ports.c:1222]

(port-column port)
Return the current column number or line number of @var{input-port},
using the current input port if none is specified.  If the number is
unknown, the result is #f.  Otherwise, the result is a 0-origin integer
- i.e. the first character of the first line is line 0, column 0.
(However, when you display a file position, for example in an error
message, we recommand you add 1 to get 1-origin integers.  This is
because lines and column numbers traditionally start with 1, and that is
what non-programmers will find most natural.)
[libguile/ports.c:1242]

(set-port-column! port column)
Set the current column or line number of @var{input-port}, using the
current input port if none is specified.
[libguile/ports.c:1254]

(port-filename port)
Return the filename associated with @var{port}.  This function returns
the strings "standard input", "standard output" and "standard error"
when called on the current input, output and error ports, respectively.
[libguile/ports.c:1269]

(set-port-filename! port filename)
Change the filename associated with @var{port}, using the current input
port if none is specified.  Note that this does not change the port's
source of data, but only the value that is returned by
@code{port-filename} and reported in diagnostic output.
[libguile/ports.c:1283]

(%make-void-port mode)
Create and return a new void port.  A void port acts like
/dev/null.  The @var{mode} argument
specifies the input/output modes for this port: see the
documentation for @code{open-file} in @ref{File Ports}.
[libguile/ports.c:1386]

(pipe)
Return a newly created pipe: a pair of ports which are linked
together on the local machine.  The @sc{car} is the input port and
the @sc{cdr} is the output port.  Data written (and flushed) to the
output port can be read from the input port.
Pipes are commonly used for communication with a newly
forked child process.  The need to flush the output port
can be avoided by making it unbuffered using @code{setvbuf}.

Writes occur atomically provided the size of the data in
bytes is not greater than the value of @code{PIPE_BUF}
Note that the output port is likely to block if too much data
(typically equal to @code{PIPE_BUF}) has been written but not
yet read from the input port
[libguile/posix.c:205]

(getgroups)
Return a vector of integers representing
the current supplementary group IDs.
[libguile/posix.c:226]

(getpw [user])
Look up an entry in the user database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getpwuid, getpwnam
or getpwent respectively.
[libguile/posix.c:270]

(setpw [arg])
If called with a true argument, initialize or reset the password data
stream.  Otherwise, close the stream.  The @code{setpwent} and
@code{endpwent} procedures are implemented on top of this.
[libguile/posix.c:324]

(getgr [name])
Look up an entry in the group database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getgrgid, getgrnam
or getgrent respectively.
[libguile/posix.c:343]

(setgr [arg])
If called with a true argument, initialize or reset the group data
stream.  Otherwise, close the stream.  The @code{setgrent} and
@code{endgrent} procedures are implemented on top of this.
[libguile/posix.c:384]

(kill pid sig)
Send a signal to the specified process or group of processes.

@var{pid} specifies the processes to which the signal is sent:

@table @r
@item @var{pid} greater than 0
The process whose identifier is @var{pid}.
@item @var{pid} equal to 0
All processes in the current process group.
@item @var{pid} less than -1
The process group whose identifier is -@var{pid}
@item @var{pid} equal to -1
If the process is privileged, all processes except for some special
system processes.  Otherwise, all processes with the current effective
user ID.
@end table

@var{sig} should be specified using a variable corresponding to
the Unix symbolic name, e.g.,

@defvar SIGHUP
Hang-up signal.
@end defvar

@defvar SIGINT
Interrupt signal.
@end defvar
[libguile/posix.c:420]

(waitpid pid [options])
Collect status information from a child process which
has terminated or (optionally) stopped.  Normally the calling
process is suspended until this can be done.  If more than one
child process is eligible then one will be chosen by the operating system.

The value of @var{pid} determines the behaviour:

@table @r
@item @var{pid} greater than 0
Request status information from the specified child process.
@item @var{pid} equal to -1 or WAIT_ANY
Request status information for any child process.
@item @var{pid} equal to 0 or WAIT_MYPGRP
Request status information for any child process in the current process
group.
@item @var{pid} less than -1
Request status information for any child process whose process group ID
is -@var{PID}.
@end table

The @var{options} argument, if supplied, should be the bitwise OR of the
values of zero or more of the following variables:

@defvar WNOHANG
Return immediately even if there are no child processes to be collected.
@end defvar

@defvar WUNTRACED
Report status information for stopped processes as well as terminated
processes.
@end defvar

The return value is a pair containing:

@enumerate
@item
The process ID of the child process, or 0 if @code{WNOHANG} was
specified and no process was collected.
@item
The integer status value.
@end enumerate
[libguile/posix.c:468]

(status:exit-val status)
Return the exit status value, as would be normally
set if a process ended normally through a
call to @code{exit} or @code{_exit}, if any, otherwise @code{#f}.
[libguile/posix.c:495]

(status:term-sig status)
Return the signal number which terminated the
process, if any, otherwise @code{#f}.
[libguile/posix.c:515]

(status:stop-sig status)
Return the signal number which stopped the
process, if any, otherwise @code{#f}.
[libguile/posix.c:533]

(getppid)
Return an integer representing the process ID of the parent process.
[libguile/posix.c:550]

(getuid)
Return an integer representing the current real user ID.
[libguile/posix.c:561]

(getgid)
Return an integer representing the current real group ID.
[libguile/posix.c:572]

(geteuid)
Return an integer representing the current effective user ID.
If the system does not support effective IDs, then the real ID
is returned.  @code{(feature? 'EIDs)} reports whether the system
supports effective IDs.
[libguile/posix.c:586]

(getegid)
Returns an integer representing the current effective group ID.
If the system does not support effective IDs, then the real ID
is returned.  @code{(feature? 'EIDs)} reports whether the system
supports effective IDs.
[libguile/posix.c:604]

(setuid id)
Set both the real and effective user IDs to the integer @var{id}, provided
the process has appropriate privileges.
The return value is unspecified.
[libguile/posix.c:620]

(setgid id)
Set both the real and effective group IDs to the integer @var{id}, provided
the process has appropriate privileges.
The return value is unspecified.
[libguile/posix.c:634]

(seteuid id)
Set the effective user ID to the integer @var{id}, provided the process
has appropriate privileges.  If effective IDs are not supported, the
real ID is set instead -- @code{(feature? 'EIDs)} reports whether the
system supports effective IDs.
The return value is unspecified.
[libguile/posix.c:650]

(setegid id)
Sets the effective group ID to the integer @var{id}, provided the process
has appropriate privileges.  If effective IDs are not supported, the
real ID is set instead -- @code{(feature? 'EIDs)} reports whether the
system supports effective IDs.
The return value is unspecified.
[libguile/posix.c:674]

(getpgrp)
Return an integer representing the current process group ID.
This is the POSIX definition, not BSD.
[libguile/posix.c:696]

(setpgid pid pgid)
Move the process @var{pid} into the process group @var{pgid}.  @var{pid} or
@var{pgid} must be integers: they can be zero to indicate the ID of the
current process.
Fail on systems that do not support job control.
The return value is unspecified.
[libguile/posix.c:712]

(setsid)
Create a new session.  The current process becomes the session leader
and is put in a new process group.  The process will be detached
from its controlling terminal if it has one.
The return value is an integer representing the new process group ID.
[libguile/posix.c:731]

(ttyname port)
Return a string with the name of the serial terminal device underlying
@var{port}.
[libguile/posix.c:745]

(ctermid)
Return a string containing the file name of the controlling terminal
for the current process.
[libguile/posix.c:768]

(tcgetpgrp port)
Return the process group ID of the foreground
process group associated with the terminal open on the file descriptor
underlying @var{port}.

If there is no foreground process group, the return value is a
number greater than 1 that does not match the process group ID
of any existing process group.  This can happen if all of the
processes in the job that was formerly the foreground job have
terminated, and no other job has yet been moved into the
foreground.
[libguile/posix.c:790]

(tcsetpgrp port pgid)
Set the foreground process group ID for the terminal used by the file
descriptor underlying @var{port} to the integer @var{pgid}.
The calling process
must be a member of the same session as @var{pgid} and must have the same
controlling terminal.  The return value is unspecified.
[libguile/posix.c:814]

(execl filename [args ...])
Execute the file named by @var{path} as a new process image.
The remaining arguments are supplied to the process; from a C program
they are accessable as the @code{argv} argument to @code{main}.
Conventionally the first @var{arg} is the same as @var{path}.
All arguments must be strings.  

If @var{arg} is missing, @var{path} is executed with a null
argument list, which may have system-dependent side-effects.

This procedure is currently implemented using the @code{execv} system
call, but we call it @code{execl} because of its Scheme calling interface.
[libguile/posix.c:901]

(execlp filename [args ...])
Similar to @code{execl}, however if
@var{filename} does not contain a slash
then the file to execute will be located by searching the
directories listed in the @code{PATH} environment variable.

This procedure is currently implemented using the @code{execvp} system
call, but we call it @code{execlp} because of its Scheme calling interface.
[libguile/posix.c:923]

(execle filename env [args ...])
Similar to @code{execl}, but the environment of the new process is
specified by @var{env}, which must be a list of strings as returned by the
@code{environ} procedure.

This procedure is currently implemented using the @code{execve} system
call, but we call it @code{execle} because of its Scheme calling interface.
[libguile/posix.c:978]

(primitive-fork)
Create a new @dfn{child} process by duplicating the current @dfn{parent} process.
In the child the return value is 0.  In the parent the return value is
the integer process ID of the child.

This procedure has been renamed from @code{fork} to avoid a naming conflict
with the scsh fork.
[libguile/posix.c:1003]

(uname)
Return an object with some information about the computer system the
program is running on.
[libguile/posix.c:1018]

(environ [env])
If @var{env} is omitted, return the current environment as a list of strings.
Otherwise set the current environment, which is also the
default environment for child processes, to the supplied list of strings.
Each member of @var{env} should be of the form
@code{NAME=VALUE} and values of @code{NAME} should not be duplicated.
If @var{env} is supplied then the return value is unspecified.
[libguile/posix.c:1047]

(tmpnam)
Return a name in the file system that does not match any
existing file.  However there is no guarantee that another
process will not create the file after @code{tmpnam} is called.
Care should be taken if opening the file, e.g., use the
@code{O_EXCL} open flag.
[libguile/posix.c:1085]

(utime pathname [actime [modtime]])
Set the access and modification times for
the file named by @var{path}.  If @var{actime} or @var{modtime}
is not supplied, then the current time is used.
@var{actime} and @var{modtime}
must be integer time values as returned by the @code{current-time}
procedure.

E.g.,

@smalllisp
(utime "foo" (- (current-time) 3600))
@end smalllisp

will set the access time to one hour in the past and the modification
time to the current time.
[libguile/posix.c:1109]

(access? path how)
Return @code{#t} if @var{path} corresponds to an existing
file and the current process
has the type of access specified by @var{how}, otherwise 
@code{#f}.
@var{how} should be specified
using the values of the variables listed below.  Multiple values can
be combined using a bitwise or, in which case @code{#t} will only
be returned if all accesses are granted.

Permissions are checked using the real id of the current process,
not the effective id, although it's the effective id which determines
whether the access would actually be granted.

@defvar R_OK
test for read permission.
@end defvar
@defvar W_OK
test for write permission.
@end defvar
@defvar X_OK
test for execute permission.
@end defvar
@defvar F_OK
test for existence of the file.
@end defvar
[libguile/posix.c:1158]

(getpid)
Return an integer representing the current process ID.
[libguile/posix.c:1174]

(putenv str)
Modify the environment of the current process, which is
also the default environment inherited by child processes.

If @var{string} is of the form @code{NAME=VALUE} then it is written
directly into the environment, replacing any existing environment string
with
name matching @code{NAME}.  If @var{string} does not contain an equal
sign, then any existing strings with name matching @var{string} are
removed.

The return value is unspecified.
[libguile/posix.c:1191]

(setlocale category [locale])
If @var{locale} is omitted, return the current value of the specified
locale category 
as a system-dependent string.
@var{category} should be specified using the values @code{LC_COLLATE},
@code{LC_ALL} etc.

Otherwise the specified locale category is set to
the string @var{locale}
and the new value is returned as a system-dependent string.  If @var{locale}
is an empty string, the locale is set using envirionment variables.
[libguile/posix.c:1222]

(mknod path type perms dev)
Create a new special file, such as a file corresponding to a device.
@var{path} specifies the name of the file.  @var{type} should
be one of the following symbols:
regular, directory, symlink, block-special, char-special,
fifo, or socket.  @var{perms} (an integer) specifies the file permissions.
@var{dev} (an integer) specifies which device the special file refers
to.  Its exact interpretation depends on the kind of special file
being created.

E.g.,
@example
(mknod "/dev/fd0" 'block-special #o660 (+ (* 2 256) 2))
@end example
The return value is unspecified.
[libguile/posix.c:1263]

(nice incr)
Increment the priority of the current process by @var{incr}.  A higher
priority value means that the process runs less often.
The return value is unspecified.
[libguile/posix.c:1308]

(sync)
Flush the operating system disk buffers.
The return value is unspecified.
[libguile/posix.c:1323]

(print-options-interface [setting])
Option interface for the print options. Instead of using
this procedure directly, use the procedures
@code{print-enable}, @code{print-disable}, @code{print-set!}
and @code{print-options}.
[libguile/print.c:140]

(simple-format destination message [args ...])
Write @var{message} to @var{destination}, defaulting to
the current output port.
@var{message} can contain @code{~A} (was @code{%s}) and
@code{~S} (was @code{%S}) escapes.  When printed,
the escapes are replaced with corresponding members of
@var{ARGS}:
@code{~A} formats using @code{display} and @code{~S} formats
using @code{write}.
If @var{destination} is @code{#t}, then use the current output
port, if @var{destination} is @code{#f}, then return a string
containing the formatted text. Does not add a trailing newline.
[libguile/print.c:961]

(newline [port])
Send a newline to PORT.
If @var{port} is omitted, send to the current output port.
[libguile/print.c:1017]

(write-char chr [port])
Send character CHR to PORT.
[libguile/print.c:1032]

(port-with-print-state port pstate)
Create a new port which behaves like @var{port}, but with an
included print state @var{pstate}.
[libguile/print.c:1086]

(get-print-state port)
Return the print state of the port @var{port}. If @var{port}
has no associated print state, @code{#f} is returned.
[libguile/print.c:1101]

(procedure-properties proc)
Return @var{obj}'s property list.
[libguile/procprop.c:169]

(set-procedure-properties! proc new_val)
Set @var{obj}'s property list to @var{alist}.
[libguile/procprop.c:182]

(procedure-property p k)
Return the property of @var{obj} with name @var{key}.
[libguile/procprop.c:195]

(set-procedure-property! p k v)
In @var{obj}'s property list, set the property named @var{key} to
@var{value}.
[libguile/procprop.c:218]

(procedure? obj)
Return @code{#t} if @var{obj} is a procedure.
[libguile/procs.c:184]

(closure? obj)
Return @code{#t} if @var{obj} is a closure.
[libguile/procs.c:210]

(thunk? obj)
Return @code{#t} if @var{obj} is a thunk.
[libguile/procs.c:219]

(procedure-documentation proc)
Return the documentation string associated with @code{proc}.  By
convention, if a procedure contains more than one expression and the
first expression is a string constant, that string is assumed to contain
documentation for that procedure.
[libguile/procs.c:270]

(procedure-with-setter? obj)
Return @code{#t} if @var{obj} is a procedure with an
associated setter procedure.
[libguile/procs.c:307]

(make-procedure-with-setter procedure setter)
Create a new procedure which behaves like @var{procedure}, but
with the associated setter @var{setter}.
[libguile/procs.c:317]

(procedure proc)
Return the procedure of @var{proc}, which must be either a
procedure with setter, or an operator struct.
[libguile/procs.c:336]

(array-fill! ra fill)
Store @var{fill} in every element of @var{array}.  The value returned
is unspecified.
[libguile/ramap.c:460]

(array-copy-in-order!)
scm_array_copy_x
[libguile/ramap.c:813]

(array-copy! src dst)
Copy every element from vector or array @var{source} to the
corresponding element of @var{destination}.  @var{destination} must have
the same rank as @var{source}, and be at least as large in each
dimension.  The order is unspecified.
[libguile/ramap.c:821]

(array-map-in-order! [arg1 ...])
scm_array_map_x
[libguile/ramap.c:1495]

(array-map! ra0 proc [lra ...])
Apply @var{proc} to
each tuple of elements of @var{array1} @dots{} and store the result
as the corresponding element in @var{array0}.
@var{array1}, @dots{} must have the same number of dimensions as
@var{array0} and have a range for each index which includes the range
for the corresponding index in @var{array0}.  The value returned is
unspecified.  The order of application is unspecified.
[libguile/ramap.c:1506]

(array-for-each proc ra0 [lra ...])
Apply @var{proc} to each tuple of elements of @var{array0} @dots{}
in row-major order.  The value returned is unspecified.
[libguile/ramap.c:1653]

(array-index-map! ra proc)
Apply @var{proc} to the indices of each element of @var{array} in
turn, storing the result in the corresponding element.  The value
returned and the order of application are unspecified.

One can implement @var{array-indexes} as
@example
(define (array-indexes array)
    (let ((ra (apply make-array #f (array-shape array))))
      (array-index-map! ra (lambda x x))
      ra))
@end example
Another example:
@example
(define (apl:index-generator n)
    (let ((v (make-uniform-vector n 1)))
      (array-index-map! v (lambda (i) i))
      v))
@end example
[libguile/ramap.c:1681]

(random n [state])
Return a number in [0,N).

Accept a positive integer or real n and return a 
number of the same type between zero (inclusive) and 
N (exclusive). The values returned have a uniform 
distribution.

The optional argument STATE must be of the type produced by
`seed->random-state'. It defaults to the value of the variable
@code{*random-state*}. This object is used to maintain the state
of the pseudo-random-number generator and is altered as a side
effect of the @code{random} operation.
[libguile/random.c:368]

(copy-random-state [state])
Return a copy of the random state STATE.
[libguile/random.c:391]

(seed->random-state seed)
Return a new random state using SEED.
[libguile/random.c:403]

(random:uniform [state])
Return a uniformly distributed inexact real random
number in [0,1).
[libguile/random.c:417]

(random:normal [state])
Return an inexact real in a normal distribution.
The distribution used has mean 0 and standard deviation 1.
For a normal distribution with mean m and standard deviation
d use @code{(+ m (* d (random:normal)))}.
[libguile/random.c:432]

(random:solid-sphere! v [state])
Fill vect with inexact real random numbers
the sum of whose squares is less than 1.0.
Thinking of vect as coordinates in space of 
dimension n = (vector-length vect), the coordinates
are uniformly distributed within the unit n-shere.
The sum of the squares of the numbers is returned.
[libguile/random.c:488]

(random:hollow-sphere! v [state])
Fill vect with inexact real random numbers
the sum of whose squares is equal to 1.0.
Thinking of vect as coordinates in space of 
dimension n = (vector-length vect), the coordinates
are uniformly distributed over the surface of the 
unit n-shere.
[libguile/random.c:511]

(random:normal-vector! v [state])
Fill vect with inexact real random numbers that are
independent and standard normally distributed
(i.e., with mean 0 and variance 1).
[libguile/random.c:529]

(random:exp [state])
Return an inexact real in an exponential distribution with
mean 1.  For an exponential distribution with mean u use
@code{(* u (random:exp))}.
[libguile/random.c:554]

(read-options-interface [setting])
Display the current settings of the read options.  If @var{setting} is
omitted, only a short form of the current read options is printed.
Otherwise, @var{setting} should be one of the following symbols:
@table @code
@item help
Display the complete option settings.
@item full
Like @code{help}, but also print programmer options.
@end table
[libguile/read.c:91]

(read [port])
Read an s-expression from the input port @var{port}, or from
the current input port if @var{port} is not specified.
Any whitespace before the next token is discarded.
[libguile/read.c:111]

(read-hash-extend chr proc)
Install the procedure @var{proc} for reading expressions
starting with the character sequence @code{#} and @var{chr}.
@var{proc} will be called with two arguments:  the character
@var{chr} and the port to read further data from. The object
returned will be the return value of @code{read}.
[libguile/read.c:732]

(regexp? x)
Return @code{#t} if @var{obj} is a compiled regular expression, or
@code{#f} otherwise.
[libguile/regex-posix.c:140]

(make-regexp pat [flags ...])
Compile the regular expression described by @var{str}, and return the
compiled regexp structure.  If @var{str} does not describe a legal
regular expression, @code{make-regexp} throws a
@code{regular-expression-syntax} error.

The @var{flag} arguments change the behavior of the compiled regexp.
The following flags may be supplied:

@table @code
@item regexp/icase
Consider uppercase and lowercase letters to be the same when matching.

@item regexp/newline
If a newline appears in the target string, then permit the @samp{^} and
@samp{$} operators to match immediately after or immediately before the
newline, respectively.  Also, the @samp{.} and @samp{[^...]} operators
will never match a newline character.  The intent of this flag is to
treat the target string as a buffer containing many lines of text, and
the regular expression as a pattern that may match a single one of those
lines.

@item regexp/basic
Compile a basic (``obsolete'') regexp instead of the extended
(``modern'') regexps that are the default.  Basic regexps do not
consider @samp{|}, @samp{+} or @samp{?} to be special characters, and
require the @samp{@{...@}} and @samp{(...)} metacharacters to be
backslash-escaped (@pxref{Backslash Escapes}).  There are several other
differences between basic and extended regular expressions, but these
are the most significant.

@item regexp/extended
Compile an extended regular expression rather than a basic regexp.  This
is the default behavior; this flag will not usually be needed.  If a
call to @code{make-regexp} includes both @code{regexp/basic} and
@code{regexp/extended} flags, the one which comes last will override
the earlier one.
@end table
[libguile/regex-posix.c:180]

(regexp-exec rx str [start [flags]])
Match the compiled regular expression @var{rx} against
@var{str}.  If the optional integer argument @var{start} is
provided, begin matching from that position in the string.
Return a match structure describing the results of the
match, or @code{#f} if no match could be found.  Optional
integer argument @var{flags} changes the behavior of the
matching, similar to @code{make-regexp}.
[libguile/regex-posix.c:230]

(call-with-dynamic-root thunk handler)
Evaluate @code{(thunk)} in a new dynamic context, returning its value.

If an error occurs during evaluation, apply @var{handler} to the
arguments to the throw, just as @code{throw} would.  If this happens,
@var{handler} is called outside the scope of the new root -- it is
called in the same dynamic context in which
@code{call-with-dynamic-root} was evaluated.

If @var{thunk} captures a continuation, the continuation is rooted at
the call to @var{thunk}.  In particular, the call to
@code{call-with-dynamic-root} is not captured.  Therefore,
@code{call-with-dynamic-root} always returns at most one time.

Before calling @var{thunk}, the dynamic-wind chain is un-wound back to
the root and a new chain started for @var{thunk}.  Therefore, this call
may not do what you expect:

@example
;; Almost certainly a bug:
(with-output-to-port
 some-port

 (lambda ()
   (call-with-dynamic-root
    (lambda ()
      (display 'fnord)
      (newline))
    (lambda (errcode) errcode))))
@end example

The problem is, on what port will @samp{fnord
} be displayed?  You
might expect that because of the @code{with-output-to-port} that
it will be displayed on the port bound to @code{some-port}.  But it
probably won't -- before evaluating the thunk, dynamic winds are
unwound, including those created by @code{with-output-to-port}.
So, the standard output port will have been re-set to its default value
before @code{display} is evaluated.

(This function was added to Guile mostly to help calls to functions in C
libraries that can not tolerate non-local exits or calls that return
multiple times.  If such functions call back to the interpreter, it should
be under a new dynamic root.)
[libguile/root.c:377]

(dynamic-root)
Return an object representing the current dynamic root.

These objects are only useful for comparison using @code{eq?}.
They are currently represented as numbers, but your code should
in no way depend on this.
[libguile/root.c:390]

(read-string!/partial str [port_or_fdes [start [end]]])
Read characters from a port or file descriptor into a
string @var{str}.  A port must have an underlying file
descriptor --- a so-called fport.  This procedure is
scsh-compatible and can efficiently read large strings.
It will:

@itemize
@item
attempt to fill the entire string, unless the @var{start}
and/or @var{end} arguments are supplied.  i.e., @var{start}
defaults to 0 and @var{end} defaults to
@code{(string-length str)}
@item
use the current input port if @var{port_or_fdes} is not
supplied.
@item
return fewer than the requested number of characters in some
cases, e.g., on end of file, if interrupted by a signal, or if
not all the characters are immediately available.
@item
wait indefinitely for some input if no characters are
currently available,
unless the port is in non-blocking mode.
@item
read characters from the port's input buffers if available,
instead from the underlying file descriptor.
@item
return @code{#f} if end-of-file is encountered before reading
any characters, otherwise return the number of characters
read.
@item
return 0 if the port is in non-blocking mode and no characters
are immediately available.
@item
return 0 if the request is for 0 bytes, with no
end-of-file check.
@end itemize
[libguile/rw.c:176]

(write-string/partial str [port_or_fdes [start [end]]])
Write characters from a string @var{str} to a port or file
descriptor.  A port must have an underlying file descriptor
--- a so-called fport.  This procedure is
scsh-compatible and can efficiently write large strings.
It will:

@itemize
@item
attempt to write the entire string, unless the @var{start}
and/or @var{end} arguments are supplied.  i.e., @var{start}
defaults to 0 and @var{end} defaults to
@code{(string-length str)}
@item
use the current output port if @var{port_of_fdes} is not
supplied.
@item
in the case of a buffered port, store the characters in the
port's output buffer, if all will fit.  If they will not fit
then any existing buffered characters will be flushed
before attempting
to write the new characters directly to the underlying file
descriptor.  If the port is in non-blocking mode and
buffered characters can not be flushed immediately, then an
@code{EAGAIN} system-error exception will be raised (Note:
scsh does not support the use of non-blocking buffered ports.)
@item
write fewer than the requested number of
characters in some cases, e.g., if interrupted by a signal or
if not all of the output can be accepted immediately.
@item
wait indefinitely for at least one character
from @var{str} to be accepted by the port, unless the port is
in non-blocking mode.
@item
return the number of characters accepted by the port.
@item
return 0 if the port is in non-blocking mode and can not accept
at least one character from @var{str} immediately
@item
return 0 immediately if the request size is 0 bytes.
@end itemize
[libguile/rw.c:270]

(sigaction signum [handler [flags]])
Install or report the signal handler for a specified signal.

@var{signum} is the signal number, which can be specified using the value
of variables such as @code{SIGINT}.

If @var{action} is omitted, @code{sigaction} returns a pair: the
CAR is the current
signal hander, which will be either an integer with the value @code{SIG_DFL}
(default action) or @code{SIG_IGN} (ignore), or the Scheme procedure which
handles the signal, or @code{#f} if a non-Scheme procedure handles the
signal.  The CDR contains the current @code{sigaction} flags for the handler.

If @var{action} is provided, it is installed as the new handler for
@var{signum}.  @var{action} can be a Scheme procedure taking one
argument, or the value of @code{SIG_DFL} (default action) or
@code{SIG_IGN} (ignore), or @code{#f} to restore whatever signal handler
was installed before @code{sigaction} was first used.  Flags can
optionally be specified for the new handler (@code{SA_RESTART} will
always be added if it's available and the system is using restartable
system calls.)  The return value is a pair with information about the
old handler as described above.

This interface does not provide access to the "signal blocking"
facility.  Maybe this is not needed, since the thread support may
provide solutions to the problem of consistent access to data
structures.
[libguile/scmsigs.c:200]

(restore-signals)
Return all signal handlers to the values they had before any call to
@code{sigaction} was made.  The return value is unspecified.
[libguile/scmsigs.c:361]

(alarm i)
Set a timer to raise a @code{SIGALRM} signal after the specified
number of seconds (an integer).  It's advisable to install a signal
handler for
@code{SIGALRM} beforehand, since the default action is to terminate
the process.

The return value indicates the time remaining for the previous alarm,
if any.  The new value replaces the previous alarm.  If there was
no previous alarm, the return value is zero.
[libguile/scmsigs.c:400]

(pause)
Pause the current process (thread?) until a signal arrives whose
action is to either terminate the current process or invoke a
handler procedure.  The return value is unspecified.
[libguile/scmsigs.c:415]

(sleep i)
Wait for the given number of seconds (an integer) or until a signal
arrives.  The return value is zero if the time elapses or the number
of seconds remaining otherwise.
[libguile/scmsigs.c:428]

(usleep i)
Sleep for I microseconds.
`usleep' is not available on all platforms.
[libguile/scmsigs.c:446]

(raise sig)

Send the specified signal @var{sig} to the current process, where
@var{sig} is as described for the kill procedure.
[libguile/scmsigs.c:476]

(system [cmd])
Execute @var{cmd} using the operating system's @dfn{command processor}.
Under Unix this is usually the default shell @code{sh}.  The value
returned is @var{cmd}'s exit status as returned by @code{waitpid}, which
can be interpreted using the functions above.

If @code{system} is called without arguments, it returns a boolean
indicating whether the command processor is available.
[libguile/simpos.c:75]

(getenv nam)
Look up the string @var{name} in the current environment.  The return
value is @code{#f} unless a string of the form @code{NAME=VALUE} is
found, in which case return the string @code{VALUE}.
[libguile/simpos.c:104]

(primitive-exit [status])
Terminate the current process without unwinding the Scheme stack.
This would typically be useful after a fork.  The exit status
is @var{status} if supplied, otherwise zero.
[libguile/simpos.c:120]

(htons in)
Return a new integer from @var{value} by converting from host to
network order. @var{value} must be within the range of a C unsigned
short integer.
[libguile/socket.c:80]

(ntohs in)
Return a new integer from @var{value} by converting from network to
host order.  @var{value} must be within the range of a C unsigned short
integer.
[libguile/socket.c:97]

(htonl in)
Return a new integer from @var{value} by converting from host to
network order. @var{value} must be within the range of a C unsigned
long integer.
[libguile/socket.c:114]

(ntohl in)
Return a new integer from @var{value} by converting from network to
host order. @var{value} must be within the range of a C unsigned
long integer.
[libguile/socket.c:126]

(socket family style proto)
Return a new socket port of the type specified by @var{family}, @var{style}
and @var{protocol}.  All three parameters are integers.  Typical values
for @var{family} are the values of @code{AF_UNIX}
and @code{AF_INET}.  Typical values for @var{style} are
the values of @code{SOCK_STREAM}, @code{SOCK_DGRAM} and @code{SOCK_RAW}.

@var{protocol} can be obtained from a protocol name using
@code{getprotobyname}.  A value of
zero specifies the default protocol, which is usually right.

A single socket port cannot by used for communication until
it has been connected to another socket.
[libguile/socket.c:160]

(socketpair family style proto)
Return a pair of connected (but unnamed) socket ports of the type specified
by @var{family}, @var{style} and @var{protocol}.
Many systems support only
socket pairs of the @code{AF_UNIX} family.  Zero is likely to be
the only meaningful value for @var{protocol}.
[libguile/socket.c:184]

(getsockopt sock level optname)
Return the value of a particular socket option for the socket
port @var{socket}.  @var{level} is an integer code for type of option
being requested, e.g., @code{SOL_SOCKET} for socket-level options.
@var{optname} is an
integer code for the option required and should be specified using one of
the symbols @code{SO_DEBUG}, @code{SO_REUSEADDR} etc.

The returned value is typically an integer but @code{SO_LINGER} returns a
pair of integers.
[libguile/socket.c:217]

(setsockopt sock level optname value)
Set the value of a particular socket option for the socket
port @var{socket}.  @var{level} is an integer code for type of option
being set, e.g., @code{SOL_SOCKET} for socket-level options.
@var{optname} is an
integer code for the option to set and should be specified using one of
the symbols @code{SO_DEBUG}, @code{SO_REUSEADDR} etc.
@var{value} is the value to which the option should be set.  For
most options this must be an integer, but for @code{SO_LINGER} it must
be a pair.

The return value is unspecified.
[libguile/socket.c:283]

(shutdown sock how)
Sockets can be closed simply by using @code{close-port}. The
@code{shutdown} procedure allows reception or tranmission on a
connection to be shut down individually, according to the parameter
@var{how}:

@table @asis
@item 0
Stop receiving data for this socket.  If further data arrives,  reject it.
@item 1
Stop trying to transmit data from this socket.  Discard any
data waiting to be sent.  Stop looking for acknowledgement of
data already sent; don't retransmit it if it is lost.
@item 2
Stop both reception and transmission.
@end table

The return value is unspecified.
[libguile/socket.c:370]

(connect sock fam address [args ...])
Initiate a connection from @var{socket} to the address
specified by @var{address} and possibly @var{arg @dots{}}.  The format
required for @var{address}
and @var{arg} @dots{} depends on the family of the socket.

For a socket of family @code{AF_UNIX},
only @code{address} is specified and must be a string with the
filename where the socket is to be created.

For a socket of family @code{AF_INET},
@code{address} must be an integer Internet host address and @var{arg} @dots{}
must be a single integer port number.

The return value is unspecified.
[libguile/socket.c:456]

(bind sock fam address [args ...])
Assign an address to the socket port @var{socket}.
Generally this only needs to be done for server sockets,
so they know where to look for incoming connections.  A socket
without an address will be assigned one automatically when it
starts communicating.

The format of @var{address} and @var{ARG} @dots{} depends on the family
of the socket.

For a socket of family @code{AF_UNIX}, only @var{address}
is specified and must 
be a string with the filename where the socket is to be created.

For a socket of family @code{AF_INET}, @var{address} must be an integer
Internet host address and @var{arg} @dots{} must be a single integer
port number.

The values of the following variables can also be used for @var{address}:

@defvar INADDR_ANY
Allow connections from any address.
@end defvar

@defvar INADDR_LOOPBACK
The address of the local host using the loopback device.
@end defvar

@defvar INADDR_BROADCAST
The broadcast address on the local network.
@end defvar

@defvar INADDR_NONE
No address.
@end defvar

The return value is unspecified.
[libguile/socket.c:504]

(listen sock backlog)
Enable @var{socket} to accept connection
requests.  @var{backlog} is an integer specifying
the maximum length of the queue for pending connections.
If the queue fills, new clients will fail to connect until the
server calls @code{accept} to accept a connection from the queue.

The return value is unspecified.
[libguile/socket.c:532]

(accept sock)
Accept a connection on a bound, listening socket @var{socket}.  If there
are no pending connections in the queue, wait until
one is available unless the non-blocking option has been set on the
socket.

The return value is a
pair in which the CAR is a new socket port for the connection and
the CDR is an object with address information about the client which
initiated the connection.

If the address is not available then the CDR will be an empty vector.

@var{socket} does not become part of the
connection and will continue to accept new requests.
[libguile/socket.c:619]

(getsockname sock)
Return the address of @var{socket}, in the same form as the object
returned by @code{accept}.  On many systems the address of a socket
in the @code{AF_FILE} namespace cannot be read.
[libguile/socket.c:642]

(getpeername sock)
Return the address of the socket that the socket @var{socket} is connected to,
in the same form as the object
returned by @code{accept}.  On many systems the address of a socket
in the @code{AF_FILE} namespace cannot be read.
[libguile/socket.c:662]

(recv! sock buf [flags])
Receive data from the socket port @var{socket}.  @var{socket} must already
be bound to the address from which data is to be received.
@var{buf} is a string into which
the data will be written.  The size of @var{buf} limits the amount of
data which can be received: in the case of packet
protocols, if a packet larger than this limit is encountered then some data
will be irrevocably lost.

The optional @var{flags} argument is a value or
bitwise OR of MSG_OOB, MSG_PEEK, MSG_DONTROUTE etc.

The value returned is the number of bytes read from the socket.

Note that the data is read directly from the socket file descriptor:any unread buffered port data is ignored.
[libguile/socket.c:689]

(send sock message [flags])
Transmit the string @var{message} on the socket port @var{socket}. 
@var{socket} must already be bound to a destination address.  The
value returned is the number of bytes transmitted -- it's possible for
this to be less than the length of @var{message} if the socket is
set to be non-blocking.  The optional @var{flags} argument is a value or
bitwise OR of MSG_OOB, MSG_PEEK, MSG_DONTROUTE etc.

Note that the data is written directly to the socket file descriptor:
any unflushed buffered port data is ignored.
[libguile/socket.c:718]

(recvfrom! sock buf [flags [start [end]]])
Return data from the socket port @var{socket} and also information about
where the data was received from.  @var{socket} must already
be bound to the address from which data is to be received.
@code{buf}, is a string into which
the data will be written.  The size of @var{buf} limits the amount of
data which can be received: in the case of packet
protocols, if a packet larger than this limit is encountered then some data
will be irrevocably lost.

The optional @var{flags} argument is a value or
bitwise OR of MSG_OOB, MSG_PEEK, MSG_DONTROUTE etc.

The value returned is a pair: the CAR is the number of bytes read from
the socket and the CDR an address object in the same form as returned by
@code{accept}.

The @var{start} and @var{end} arguments specify a substring of @var{buf}
to which the data should be written.

Note that the data is read directly from the socket file descriptor:
any unread buffered port data is ignored.
[libguile/socket.c:756]

(sendto sock message fam address [args_and_flags ...])
Transmit the string @var{message} on the socket port @var{socket}.  The
destination address is specified using the @var{family}, @var{address} and
@var{arg} arguments, in a similar way to the @code{connect}
procedure.  The
value returned is the number of bytes transmitted -- it's possible for
this to be less than the length of @var{message} if the socket is
set to be non-blocking.  The optional @var{flags} argument is a value or
bitwise OR of MSG_OOB, MSG_PEEK, MSG_DONTROUTE etc.

Note that the data is written directly to the socket file descriptor:
any unflushed buffered port data is ignored.
[libguile/socket.c:817]

(restricted-vector-sort! vec less startpos endpos)
Sort the vector @var{vec}, using @var{less} for comparing
the vector elements.  @var{startpos} and @var{endpos} delimit
the range of the vector which gets sorted.  The return value
is not specified.
[libguile/sort.c:447]

(sorted? items less)
Return @code{#t} iff @var{items} is a list or a vector such that
for all 1 <= i <= m, the predicate @var{less} returns true when
applied to all elements i - 1 and i
[libguile/sort.c:490]

(merge alist blist less)
Merge two already sorted lists into one.
Given two lists @var{alist} and @var{blist}, such that
@code{(sorted? alist less?)} and @code{(sorted? blist less?)},
return a new list in which the elements of @var{alist} and
@var{blist} have been stably interleaved so that
@code{(sorted? (merge alist blist less?) less?)}.
Note:  this does _not_ accept vectors.
[libguile/sort.c:576]

(merge! alist blist less)
Take two lists @var{alist} and @var{blist} such that
@code{(sorted? alist less?)} and @code{(sorted? blist less?)} and
return a new list in which the elements of @var{alist} and
@var{blist} have been stably interleaved so that
@code{(sorted? (merge alist blist less?) less?)}.
This is the destructive variant of @code{merge}
Note:  this does _not_ accept vectors.
[libguile/sort.c:689]

(sort! items less)
Sort the sequence @var{items}, which may be a list or a
vector.  @var{less} is used for comparing the sequence
elements.  The sorting is destructive, that means that the
input sequence is modified to produce the sorted result.
This is not a stable sort.
[libguile/sort.c:765]

(sort items less)
Sort the sequence @var{items}, which may be a list or a
vector.  @var{less} is used for comparing the sequence
elements.  This is not a stable sort.
[libguile/sort.c:799]

(stable-sort! items less)
Sort the sequence @var{items}, which may be a list or a
vector. @var{less} is used for comparing the sequence elements.
The sorting is destructive, that means that the input sequence
is modified to produce the sorted result.
This is a stable sort.
[libguile/sort.c:894]

(stable-sort items less)
Sort the sequence @var{items}, which may be a list or a
vector. @var{less} is used for comparing the sequence elements.
This is a stable sort.
[libguile/sort.c:934]

(sort-list! items less)
Sort the list @var{items}, using @var{less} for comparing the
list elements. The sorting is destructive, that means that the
input list is modified to produce the sorted result.
This is a stable sort.
[libguile/sort.c:980]

(sort-list items less)
Sort the list @var{items}, using @var{less} for comparing the
list elements. This is a stable sort.
[libguile/sort.c:994]

(source-properties obj)
Return the source property association list of @var{obj}.
[libguile/srcprop.c:169]

(set-source-properties! obj plist)
Install the association list @var{plist} as the source property
list for @var{obj}.
[libguile/srcprop.c:190]

(source-property obj key)
Return the source property specified by @var{key} from
@var{obj}'s source property list.
[libguile/srcprop.c:210]

(set-source-property! obj key datum)
Set the source property of object @var{obj}, which is specified by
@var{key} to @var{datum}.  Normally, the key will be a symbol.
[libguile/srcprop.c:243]

(stack? obj)
Return @code{#t} if @var{obj} is a calling stack.
[libguile/stacks.c:408]

(make-stack obj [args ...])
Create a new stack. If @var{obj} is @code{#t}, the current
evaluation stack is used for creating the stack frames,
otherwise the frames are taken from @var{obj} (which must be
either a debug object or a continuation).

@var{args} should be a list containing any combination of
integer, procedure and @code{#t} values.

These values specify various ways of cutting away uninteresting
stack frames from the top and bottom of the stack that
@code{make-stack} returns.  They come in pairs like this:
@code{(@var{inner_cut_1} @var{outer_cut_1} @var{inner_cut_2}
@var{outer_cut_2} @dots{})}.

Each @var{inner_cut_N} can be @code{#t}, an integer, or a
procedure.  @code{#t} means to cut away all frames up to but
excluding the first user module frame.  An integer means to cut
away exactly that number of frames.  A procedure means to cut
away all frames up to but excluding the application frame whose
procedure matches the specified one.

Each @var{outer_cut_N} can be an integer or a procedure.  An
integer means to cut away that number of frames.  A procedure
means to cut away frames down to but excluding the application
frame whose procedure matches the specified one.

If the @var{outer_cut_N} of the last pair is missing, it is
taken as 0.
[libguile/stacks.c:440]

(stack-id stack)
Return the identifier given to @var{stack} by @code{start-stack}.
[libguile/stacks.c:531]

(stack-ref stack i)
Return the @var{index}'th frame from @var{stack}.
[libguile/stacks.c:567]

(stack-length stack)
Return the length of @var{stack}.
[libguile/stacks.c:581]

(frame? obj)
Return @code{#t} if @var{obj} is a stack frame.
[libguile/stacks.c:594]

(last-stack-frame obj)
Return a stack which consists of a single frame, which is the
last stack frame for @var{obj}. @var{obj} must be either a
debug object or a continuation.
[libguile/stacks.c:605]

(frame-number frame)
Return the frame number of @var{frame}.
[libguile/stacks.c:646]

(frame-source frame)
Return the source of @var{frame}.
[libguile/stacks.c:656]

(frame-procedure frame)
Return the procedure for @var{frame}, or @code{#f} if no
procedure is associated with @var{frame}.
[libguile/stacks.c:667]

(frame-arguments frame)
Return the arguments of @var{frame}.
[libguile/stacks.c:679]

(frame-previous frame)
Return the previous frame of @var{frame}, or @code{#f} if
@var{frame} is the first frame in its stack.
[libguile/stacks.c:690]

(frame-next frame)
Return the next frame of @var{frame}, or @code{#f} if
@var{frame} is the last frame in its stack.
[libguile/stacks.c:706]

(frame-real? frame)
Return @code{#t} if @var{frame} is a real frame.
[libguile/stacks.c:721]

(frame-procedure? frame)
Return @code{#t} if a procedure is associated with @var{frame}.
[libguile/stacks.c:731]

(frame-evaluating-args? frame)
Return @code{#t} if @var{frame} contains evaluated arguments.
[libguile/stacks.c:741]

(frame-overflow? frame)
Return @code{#t} if @var{frame} is an overflow frame.
[libguile/stacks.c:751]

(get-internal-real-time)
Return the number of time units since the interpreter was started.
[libguile/stime.c:140]

(times)
Return an object with information about real and processor time.
The following procedures accept such an object as an argument and
return a selected component:

@table @code
@item tms:clock
The current real time, expressed as time units relative to an
arbitrary base.
@item tms:utime
The CPU time units used by the calling process.
@item tms:stime
The CPU time units used by the system on behalf of the calling process.
@item tms:cutime
The CPU time units used by terminated child processes of the calling
process, whose status has been collected (e.g., using @code{waitpid}).
@item tms:cstime
Similarly, the CPU times units used by the system on behalf of 
terminated child processes.
@end table
[libguile/stime.c:182]

(get-internal-run-time)
Return the number of time units of processor time used by the interpreter.
Both "system" and "user" time are included but subprocesses are not.
[libguile/stime.c:207]

(current-time)
Return the number of seconds since 1970-01-01 00:00:00 UTC, excluding
leap seconds.
[libguile/stime.c:217]

(gettimeofday)
Return a pair containing the number of seconds and microseconds since
1970-01-01 00:00:00 UTC, excluding leap seconds.  Note: whether true
microsecond resolution is available depends on the operating system.
[libguile/stime.c:234]

(localtime time [zone])
Return an object representing the broken down components of @var{time},
an integer like the one returned by @code{current-time}.  The time zone
for the calculation is optionally specified by @var{zone} (a string),
otherwise the @code{TZ} environment variable or the system default is
used.
[libguile/stime.c:335]

(gmtime time)
Return an object representing the broken down components of @var{time},
an integer like the one returned by @code{current-time}.  The values
are calculated for UTC.
[libguile/stime.c:409]

(mktime sbd_time [zone])
@var{bd-time} is an object representing broken down time and @code{zone}
is an optional time zone specifier (otherwise the TZ environment variable
or the system default is used).

Return a pair: the @sc{car} is a corresponding
integer time value like that returned
by @code{current-time}; the @sc{cdr} is a broken down time object,
similar to @var{bd-time} but with normalized values.
[libguile/stime.c:471]

(tzset)
Initialize the timezone from the TZ environment variable
or the system default.  It's not usually necessary to call this procedure
since it's done automatically by other procedures that depend on the
timezone.
[libguile/stime.c:546]

(strftime format stime)
Format a time specification @var{time} using @var{template}.  @var{time}
is an object with time components in the form returned by @code{localtime}
or @code{gmtime}.  @var{template} is a string which can include formatting
specifications introduced by a @code{%} character.  The formatting of
month and day names is dependent on the current locale.  The value returned
is the formatted string.
@xref{Formatting Date and Time, , , libc, The GNU C Library Reference Manual}.)
[libguile/stime.c:563]

(strptime format string)
Perform the reverse action to @code{strftime}, parsing @var{string}
according to the specification supplied in @var{template}.  The
interpretation of month and day names is dependent on the current
locale.  The
value returned is a pair.  The CAR has an object with time components 
in the form returned by @code{localtime} or @code{gmtime},
but the time zone components
are not usefully set.
The CDR reports the number of characters from @var{string} which
were used for the conversion.
[libguile/stime.c:651]

(string? obj)
Return #t iff OBJ is a string, else returns #f.
[libguile/strings.c:62]

(read-only-string? x)
Return true if OBJ can be read as a string,

This illustrates the difference between @code{string?} and
@code{read-only-string?}:

@example
(string? "a string") @result{} #t
(string? 'a-symbol) @result{} #f

(read-only-string? "a string") @result{} #t
(read-only-string? 'a-symbol) @result{} #t
@end example
[libguile/strings.c:79]

(list->string)
scm_string
[libguile/strings.c:86]

(string [chrs ...])
Return a newly allocated string composed of the arguments, CHRS.
[libguile/strings.c:90]

(make-string k [chr])
Return a newly allocated string of
length K.  If CHR is given, then all elements of the string
are initialized to CHR, otherwise the contents of the
STRING are unspecified.
[libguile/strings.c:220]

(string-length string)
Return the number of characters in STRING
[libguile/strings.c:243]

(string-ref str k)
Return character K of STR using zero-origin indexing.
K must be a valid index of STR.
[libguile/strings.c:254]

(string-set! str k chr)
Store CHR in element K of STRING and returns an unspecified value.
K must be a valid index of STR.
[libguile/strings.c:269]

(substring str start [end])
Return a newly allocated string formed from the characters
of STR beginning with index START (inclusive) and ending with
index END (exclusive).
STR must be a string, START and END must be exact integers satisfying:

0 <= START <= END <= (string-length STR).
[libguile/strings.c:288]

(string-append [args ...])
Return a newly allocated string whose characters form the
concatenation of the given strings, ARGS.
[libguile/strings.c:306]

(make-shared-substring str [frm [to]])
Return a shared substring of @var{str}.  The semantics are the same as
for the @code{substring} function: the shared substring returned
includes all of the text from @var{str} between indexes @var{start}
(inclusive) and @var{end} (exclusive).  If @var{end} is omitted, it
defaults to the end of @var{str}.  The shared substring returned by
@code{make-shared-substring} occupies the same storage space as
@var{str}.
[libguile/strings.c:338]

(string-index str chr [frm [to]])
Return the index of the first occurrence of @var{chr} in @var{str}.  The
optional integer arguments @var{frm} and @var{to} limit the search to
a portion of the string.  This procedure essentially implements the
@code{index} or @code{strchr} functions from the C library.

@example
(string-index "weiner" #e)
@result{} 1

(string-index "weiner" #e 2)
@result{} 4

(string-index "weiner" #e 2 4)
@result{} #f
@end example
[libguile/strop.c:139]

(string-rindex str chr [frm [to]])
Like @code{string-index}, but search from the right of the string rather
than from the left.  This procedure essentially implements the
@code{rindex} or @code{strrchr} functions from the C library.

@example
(string-rindex "weiner" #e)
@result{} 4

(string-rindex "weiner" #e 2 4)
@result{} #f

(string-rindex "weiner" #e 2 5)
@result{} 4
@end example
[libguile/strop.c:167]

(substring-move-left!)
scm_substring_move_x
[libguile/strop.c:184]

(substring-move-right!)
scm_substring_move_x
[libguile/strop.c:185]

(substring-move! str1 start1 end1 str2 start2)
Copy the substring of @var{str1} bounded by @var{start1} and @var{end1}
into @var{str2} beginning at position @var{end2}.
@code{substring-move-right!} begins copying from the rightmost character
and moves left, and @code{substring-move-left!} copies from the leftmost
character moving right.

It is useful to have two functions that copy in different directions so
that substrings can be copied back and forth within a single string.  If
you wish to copy text from the left-hand side of a string to the
right-hand side of the same string, and the source and destination
overlap, you must be careful to copy the rightmost characters of the
text first, to avoid clobbering your data.  Hence, when @var{str1} and
@var{str2} are the same string, you should use
@code{substring-move-right!} when moving text from left to right, and
@code{substring-move-left!}  otherwise.  If @code{str1} and @samp{str2}
are different strings, it does not matter which function you use.
[libguile/strop.c:257]

(substring-fill! str start end fill)
Change every character in @var{str} between @var{start} and @var{end} to
@var{fill} char.

@example
(define y "abcdefg")
(substring-fill! y 1 3 #\r)
y
@result{} "arrdefg"
@end example
[libguile/strop.c:292]

(string-null? str)
Return @code{#t} if @var{str}'s length is nonzero, and @code{#f}
otherwise.

@example
(string-null? "")
@result{} #t

(string-null? y)
@result{} #f
@end example
[libguile/strop.c:318]

(string->list str)
Return a newly allocated list of the
characters that make up the given string.  Note that @samp{list->string}
returns a newly allocated string formed from the characters in the list
@var{list}, which must be a list of characters. Thus, @samp{string->list}
and @samp{list->string} are
inverses so far as @samp{equal?} is concerned.
[libguile/strop.c:334]

(string-copy str)
Return a newly allocated copy of the given @var{string}.
[libguile/strop.c:351]

(string-fill! str chr)
Store @var{char} in every element of the given @var{string}.
The return value is unspecified.
[libguile/strop.c:363]

(string-upcase! v)
Destructively upcase every character in @code{str}.

@example
(string-upcase! y)
@result{} "ARRDEFG"

y
@result{} "ARRDEFG"
@end example
[libguile/strop.c:383]

(string-upcase str)
Upcase every character in @code{str}.
[libguile/strop.c:407]

(string-downcase! v)
Destructively downcase every character in @code{str}.

@example
y
@result{} "ARRDEFG"

(string-downcase! y)
@result{} "arrdefg"

y
@result{} "arrdefg"
@end example
[libguile/strop.c:424]

(string-downcase str)
Downcase every character in @code{str}.
[libguile/strop.c:447]

(string-capitalize! str)
Destructively capitalize every character in @code{str}.
[libguile/strop.c:457]

(string-capitalize str)
Capitalize every character in @code{str}.
[libguile/strop.c:482]

(string-ci->symbol str)
Return the symbol whose name is @var{str}.  @var{str} is
converted to lowercase before the conversion is done, if Guile
is currently reading symbols case-insensitively.
[libguile/strop.c:494]

(string=? s1 s2)
Lexicographic equality predicate; 
Return @t{#t} if the two strings are the same length and contain the same
characters in the same positions, otherwise returns @t{#f}. (r5rs)

@samp{String-ci=?} treats
upper and lower case letters as though they were the same character, but
@samp{string=?} treats upper and lower case as distinct characters.
[libguile/strorder.c:61]

(string-ci=? s1 s2)
Case-insensitive string equality predicate; return @t{#t} if
the two strings are the same length and their component characters
match (ignoring case) at each position; otherwise returns @t{#f}. (r5rs)
[libguile/strorder.c:87]

(string<? s1 s2)
Lexicographic ordering predicate; return @t{#t} if @var{s1}
is lexicographically less than @var{s2}.  (r5rs)
[libguile/strorder.c:112]

(string<=? s1 s2)
Lexicographic ordering predicate; return @t{#t} if @var{s1}
is lexicographically less than or equal to @var{s2}.  (r5rs)
[libguile/strorder.c:145]

(string>? s1 s2)
Lexicographic ordering predicate; return @t{#t} if @var{s1}
is lexicographically greater than @var{s2}.  (r5rs)
[libguile/strorder.c:155]

(string>=? s1 s2)
Lexicographic ordering predicate; return @t{#t} if @var{s1}
is lexicographically greater than or equal to @var{s2}.  (r5rs)
[libguile/strorder.c:165]

(string-ci<? s1 s2)
Case insensitive lexicographic ordering predicate; 
return @t{#t} if @var{s1} is lexicographically less than
@var{s2} regardless of case.  (r5rs)
[libguile/strorder.c:176]

(string-ci<=? s1 s2)
Case insensitive lexicographic ordering predicate; 
return @t{#t} if @var{s1} is lexicographically less than
or equal to @var{s2} regardless of case.  (r5rs)
[libguile/strorder.c:202]

(string-ci>? s1 s2)
Case insensitive lexicographic ordering predicate; 
return @t{#t} if @var{s1} is lexicographically greater than
@var{s2} regardless of case.  (r5rs)
[libguile/strorder.c:213]

(string-ci>=? s1 s2)
Case insensitive lexicographic ordering predicate; 
return @t{#t} if @var{s1} is lexicographically greater than
or equal to @var{s2} regardless of case.  (r5rs)
[libguile/strorder.c:224]

(call-with-output-string proc)
Call the one-argument procedure @var{proc} with a newly created output
port.  When the function returns, the string composed of the characters
written into the port is returned.
[libguile/strports.c:321]

(call-with-input-string str proc)
Call the one-argument procedure @var{proc} with a newly created input
port from which @var{string}'s contents may be read.  The value yielded
by the @var{proc} is returned.
[libguile/strports.c:363]

(open-input-string str)
Take a string and return an input port that delivers characters
from the string. The port can be closed by
@code{close-input-port}, though its storage will be reclaimed
by the garbage collector if it becomes inaccessible.
[libguile/strports.c:376]

(open-output-string)
Return an output port that will accumulate characters for
retrieval by @code{get-output-string}. The port can be closed
by the procedure @code{close-output-port}, though its storage
will be reclaimed by the garbage collector if it becomes
inaccessible.
[libguile/strports.c:390]

(get-output-string port)
Given an output port created by @code{open-output-string},
return a string consisting of the characters that have been
output to the port so far.
[libguile/strports.c:407]

(eval-string string)
Evaluate @var{string} as the text representation of a Scheme form
or forms, and return whatever value they produce.
[libguile/strports.c:446]

(make-struct-layout fields)
Return a new structure layout object.

@var{fields} must be a read-only string made up of pairs of
characters strung together.  The first character of each pair
describes a field type, the second a field protection.  Allowed
types are 'p' for GC-protected Scheme data, 'u' for unprotected
binary data, and 's' for fields that should point to the
structure itself.    Allowed protections are 'w' for mutable
fields, 'r' for read-only fields, and 'o' for opaque fields.
The last field protection specification may be capitalized to
indicate that the field is a tail-array.
[libguile/struct.c:94]

(struct? x)
Return #t iff @var{obj} is a structure object, else #f.
[libguile/struct.c:261]

(struct-vtable? x)
Return #t iff obj is a vtable structure.
[libguile/struct.c:270]

(make-struct vtable tail_array_size [init ...])
Create a new structure.

@var{vtable} must be a vtable structure (@pxref{Vtables}).

@var{tail_array_size} must be a non-negative integer.
If the layout
specification indicated by @var{vtable} includes a tail-array,
this is the number of elements allocated to that array.

The @var{init}@dots{} are optional arguments describing how
successive fields of the structure should be initialized.
Only fields with protection 'r' or 'w' can be initialized
 -- fields of protection 's' are automatically
initialized to point to the new structure itself; fields of
protection 'o' can not be initialized by Scheme programs.
[libguile/struct.c:393]

(make-vtable-vtable extra_fields tail_array_size [init ...])
Return a new, self-describing vtable structure.

@var{new-fields} is a layout specification describing fields
of the resulting structure beginning at the position bound to
@code{vtable-offset-user}.

@var{tail-size} specifies the size of the tail-array (if any)
of this vtable.

@var{inits} initializes the fields of the vtable.  Minimally,
one initializer must be provided: the layout specification for
instances of the type this vtable will describe.  If a second
initializer is provided, it will be interpreted as a print
call-back function.
[libguile/struct.c:446]

(struct-ref handle pos)
Access the @var{n}th field of @var{struct}.
[libguile/struct.c:485]

(struct-set! handle pos val)
Modify the @var{n}th field of @var{struct}.

If the field is of type 'p', then it can be set to an
arbitrary value.

If the field is of type 'u', then it can only be set to a
non-negative integer value small enough to fit in one machine
word.
[libguile/struct.c:569]

(struct-vtable handle)
Return the vtable structure that describes the
type of @var{struct}.
[libguile/struct.c:646]

(struct-vtable-tag handle)
Return the tag of @var{handle}, a struct vtable.
The tag is a number.
[libguile/struct.c:658]

(struct-vtable-name vtable)
Return the name of @var{vtable}.
[libguile/struct.c:697]

(set-struct-vtable-name! vtable name)
Associate with vtable @var{vtable} the symbol @var{name}.
[libguile/struct.c:707]

(symbol? obj)
Returns @t{#t} if @var{obj} is a symbol, otherwise returns @t{#f}. (r5rs)
[libguile/symbols.c:432]

(symbol->string s)
Return the name of @var{symbol} as a string.  If the symbol was part of
an object returned as the value of a literal expression
(section @pxref{Literal expressions,,,r5rs, The Revised^5 Report on
Scheme}) or by a call to the @samp{read} procedure,
and its name contains alphabetic characters, then the string returned
will contain characters in the implementation's preferred standard
case---some implementations will prefer upper case, others lower case.
If the symbol was returned by @samp{string->symbol}, the case of
characters in the string returned will be the same as the case in the
string that was passed to @samp{string->symbol}.  It is an error
to apply mutation procedures like @code{string-set!} to strings returned
by this procedure. (r5rs)

The following examples assume that the implementation's standard case is
lower case:

@example
(symbol->string 'flying-fish)
@result{} "flying-fish"
(symbol->string 'Martin)
@result{} "martin"
(symbol->string (string->symbol "Malvina"))
@result{} "Malvina"
@end example
[libguile/symbols.c:463]

(string->symbol s)
Return the symbol whose name is @var{string}.  This procedure can
create symbols with names containing special characters or letters in
the non-standard case, but it is usually a bad idea to create such
symbols because in some implementations of Scheme they cannot be read as
themselves.  See @samp{symbol->string}.

The following examples assume that the implementation's standard case is
lower case:

@example
(eq? 'mISSISSIppi 'mississippi)
@result{} #t
(string->symbol "mISSISSIppi")
@result{} mISSISSIppi
(eq? 'bitBlt (string->symbol "bitBlt"))
@result{} #f
(eq? 'JollyWog
     (string->symbol
       (symbol->string 'JollyWog)))
@result{} #t
(string=? "K. Harper, M.D."
          (symbol->string
            (string->symbol "K. Harper, M.D.")))
@result{} #t
@end example
[libguile/symbols.c:496]

(string->obarray-symbol o s [softp])
Intern a new symbol in @var{obarray}, a symbol table, with name
@var{string}.

If @var{obarray} is @code{#f}, use the default system symbol table.  If
@var{obarray} is @code{#t}, the symbol should not be interned in any
symbol table; merely return the pair (@var{symbol}
. @var{#<undefined>}).

The @var{soft?} argument determines whether new symbol table entries
should be created when the specified symbol is not already present in
@var{obarray}.  If @var{soft?} is specified and is a true value, then
new entries should not be added for symbols not already present in the
table; instead, simply return @code{#f}.
[libguile/symbols.c:522]

(intern-symbol o s)
Add a new symbol to @var{obarray} with name @var{string}, bound to an
unspecified initial value.  The symbol table is not modified if a symbol
with this name is already present.
[libguile/symbols.c:554]

(unintern-symbol o s)
Remove the symbol with name @var{string} from @var{obarray}.  This
function returns @code{#t} if the symbol was present and @code{#f}
otherwise.
[libguile/symbols.c:591]

(symbol-binding o s)
Look up in @var{obarray} the symbol whose name is @var{string}, and
return the value to which it is bound.  If @var{obarray} is @code{#f},
use the global symbol table.  If @var{string} is not interned in
@var{obarray}, an error is signalled.
[libguile/symbols.c:632]

(symbol-interned? o s)
Return @var{#t} if @var{obarray} contains a symbol with name
@var{string}, and @var{#f} otherwise.
[libguile/symbols.c:649]

(symbol-bound? o s)
Return @var{#t} if @var{obarray} contains a symbol with name
@var{string} bound to a defined value.  This differs from
@var{symbol-bound?} in that the mere mention of a symbol usually causes
it to be interned; @code{symbol-bound?} determines whether a symbol has
been given any meaningful value.
[libguile/symbols.c:673]

(symbol-set! o s v)
Find the symbol in @var{obarray} whose name is @var{string}, and rebind
it to @var{value}.  An error is signalled if @var{string} is not present
in @var{obarray}.
[libguile/symbols.c:691]

(symbol-fref s)
Return the contents of @var{symbol}'s @dfn{function slot}.
[libguile/symbols.c:724]

(symbol-pref s)
Return the @dfn{property list} currently associated with @var{symbol}.
[libguile/symbols.c:739]

(symbol-fset! s val)
Change the binding of @var{symbol}'s function slot.
[libguile/symbols.c:754]

(symbol-pset! s val)
Change the binding of @var{symbol}'s property slot.
[libguile/symbols.c:770]

(symbol-hash s)
Return the hash value derived from @var{symbol}'s name, i.e. the integer
index into @var{symbol}'s obarray at which it is stored.
[libguile/symbols.c:787]

(builtin-bindings)
Create and return a copy of the global symbol table, removing all
unbound symbols.
[libguile/symbols.c:826]

(builtin-weak-bindings)
[libguile/symbols.c:839]

(gensym [name [obarray]])
Create a new, unique symbol in @var{obarray}, using the global
symbol table by default.  If @var{name} is specified, it
is used as a prefix for the new symbol's name.  The default
prefix is @code{%%gensym}.  @var{name} may be either a string
or a symbol.
[libguile/symbols.c:859]

(tag x)
Return an integer corresponding to the type of @var{x}.
[libguile/tag.c:96]

(call-with-new-thread [argl ...])
Evaluate @code{(thunk)} in a new thread, and new dynamic context,
returning a new thread object representing the thread.

If an error occurs during evaluation, call error-thunk, passing
it an error code describing the condition.  [Error codes are
currently meaningless integers.  In the future, real values
will be specified.]
If this happens, the error-thunk is called outside the scope
of the new root -- it is called in the same dynamic context in
which with-new-thread was evaluated, but not in the callers
thread.

All the evaluation rules for dynamic roots apply to threads.
[libguile/threads.c:490]

(join-thread thread)
Suspend execution of the calling thread until the
target @var{thread} terminates, unless the target
@var{thread} has already terminated.
[libguile/threads.c:515]

(yield)
If one or more threads are waiting to execute, calling
yield forces an immediate context switch to one of them.
Otherwise, yield has no effect.
[libguile/threads.c:527]

(single-active-thread?)
Return #t iff there is only one thread presently in the
@dfn{run queue}.  This procedure is only available if Guile
configuration includes USE_COOP_THREADS (@pxref{Install
Config}).
[libguile/threads.c:541]

(make-mutex)
Create a new mutex object.
[libguile/threads.c:552]

(lock-mutex mutex)
Lock @var{mutex}. If the mutex is already locked,
the calling thread blocks until the mutex becomes available.
The function returns when the calling thread owns the lock
on @var{mutex}.
[libguile/threads.c:565]

(unlock-mutex mutex)
Unlock @var{mutex} if the calling thread owns the lock on it.
Calling @code{unlock-mutex} on a mutex not owned by the current
thread results in undefined behaviour.  Once a mutex has been
unlocked, one thread blocked on @var{mutex} is awakened and
grabs the mutex lock.
[libguile/threads.c:579]

(make-condition-variable)
Return a new condition variable.
[libguile/threads.c:589]

(wait-condition-variable c m)
Wait for condition variable @var{c}, locking mutex @var{m} when
it becomes available.  Caller needs to unlock @var{m} afterwards.
[libguile/threads.c:600]

(signal-condition-variable c)
Signal condition variable @var{c}.  If more than one thread
is waiting for @var{c} (with @code{wait-condition-variable}),
only one of them receives the signal.
[libguile/threads.c:612]

(catch tag thunk handler)
Invoke @var{thunk} in the dynamic context of @var{handler} for
exceptions matching @var{key}.  If thunk throws to the symbol @var{key},
then @var{handler} is invoked this way:

@example
(handler key args ...)
@end example

@var{key} is a symbol or #t.

@var{thunk} takes no arguments.  If @var{thunk} returns normally, that
is the return value of @code{catch}.

Handler is invoked outside the scope of its own @code{catch}.  If
@var{handler} again throws to the same key, a new handler from further
up the call chain is invoked.

If the key is @code{#t}, then a throw to @emph{any} symbol will match
this call to @code{catch}.
[libguile/throw.c:532]

(lazy-catch tag thunk handler)
Behave like @code{catch}, except that the stack is
not unwound before invoking @var{handler}.
The @var{handler} procedure is not allowed to return:
it must throw to another catch, or otherwise exit non-locally.
[libguile/throw.c:560]

(throw key [args ...])
Invoke the catch form matching @var{key}, passing @var{args} to the
@var{handler}.  

@var{key} is a symbol.  It will match catches of the same symbol or of
#t.

If there is no handler at all, an error is signaled.
[libguile/throw.c:593]

(uniform-vector-length v)
Return the number of elements in @var{uve}.
[libguile/unif.c:237]

(array? v [prot])
Return @code{#t} if the @var{obj} is an array, and @code{#f} if not.

The @var{prototype} argument is used with uniform arrays and is described
elsewhere.
[libguile/unif.c:268]

(array-rank ra)
Return the number of dimensions of @var{obj}.  If @var{obj} is not an
array, @code{0} is returned.
[libguile/unif.c:339]

(array-dimensions ra)
@code{Array-dimensions} is similar to @code{array-shape} but replaces
elements with a @code{0} minimum with one greater than the maximum. So:
@example
(array-dimensions (make-array 'foo '(-1 3) 5))
@result{} ((-1 3) 5)
@end example
[libguile/unif.c:378]

(shared-array-root ra)
Return the root vector of a shared array.
[libguile/unif.c:425]

(shared-array-offset ra)
Return the root vector index of the first element in the array.
[libguile/unif.c:436]

(shared-array-increments ra)
For each dimension, return the distance between elements in the root vector.
[libguile/unif.c:447]

(dimensions->uniform-array dims prot [fill])
Create and return a uniform array or vector of type
corresponding to prototype @var{prot} with dimensions
@var{dims}, either an integer, in which case it is
interpreted as the vector length; or a list, in which
case each element is either an integer or a sublist
of the form @code{(lower upper)}.
If @var{fill} is supplied, use it to fill the array,
otherwise use @var{prot}.
[libguile/unif.c:562]

(make-shared-array oldra mapfunc [dims ...])
@code{make-shared-array} can be used to create shared subarrays of other
arrays.  The @var{mapper} is a function that translates coordinates in
the new array into coordinates in the old array.  A @var{mapper} must be
linear, and its range must stay within the bounds of the old array, but
it can be otherwise arbitrary.  A simple example:
@example
(define fred (make-array #f 8 8))
(define freds-diagonal
  (make-shared-array fred (lambda (i) (list i i)) 8))
(array-set! freds-diagonal 'foo 3)

(array-ref fred 3 3)
@result{} foo

(define freds-center
  (make-shared-array fred (lambda (i j)
                            (list (+ 3 i) (+ 3 j))) 2 2))

(array-ref freds-center 0 0)
@result{} foo
@end example
[libguile/unif.c:684]

(transpose-array ra [args ...])
Return an array sharing contents with @var{array}, but with dimensions
arranged in a different order.  There must be one @var{dim} argument for
each dimension of @var{array}.  @var{dim0}, @var{dim1}, @dots{} should
be integers between 0 and the rank of the array to be returned.  Each
integer in that range must appear at least once in the argument list.

The values of @var{dim0}, @var{dim1}, @dots{} correspond to dimensions
in the array to be returned, their positions in the argument list to
dimensions of @var{array}.  Several @var{dim}s may have the same value,
in which case the returned array will have smaller rank than
@var{array}.

Examples:
@example
(transpose-array '#2((a b) (c d)) 1 0)
@result{} #2((a c) (b d))

(transpose-array '#2((a b) (c d)) 0 0)
@result{} #1(a d)

(transpose-array '#3(((a b c) (d e f)) ((1 2 3) (4 5 6))) 1 1 0)
@result{} #2((a 4) (b 5) (c 6))
@end example
[libguile/unif.c:811]

(enclose-array ra [axes ...])
@var{dim0}, @var{dim1} @dots{} should be nonnegative integers less than
the rank of @var{array}.  @var{enclose-array} returns an array
resembling an array of shared arrays.  The dimensions of each shared
array are the same as the @var{dim}th dimensions of the original array,
the dimensions of the outer array are the same as those of the original
array that did not match a @var{dim}.

An enclosed array is not a general Scheme array.  Its elements may not
be set using @code{array-set!}.  Two references to the same element of
an enclosed array will be @code{equal?} but will not in general be
@code{eq?}.  The value returned by @var{array-prototype} when given an
enclosed array is unspecified.

Examples:
@example
(enclose-array '#3(((a b c) (d e f)) ((1 2 3) (4 5 6))) 1)
@result{} #<enclosed-array (#1(a d) #1(b e) #1(c f)) (#1(1 4) #1(2 5) #1(3 6))>

(enclose-array '#3(((a b c) (d e f)) ((1 2 3) (4 5 6))) 1 0)
@result{} #<enclosed-array #2((a 1) (d 4)) #2((b 2) (e 5)) #2((c 3) (f 6))>
@end example
[libguile/unif.c:919]

(array-in-bounds? v [args ...])
Return @code{#t} if its arguments would be acceptable to array-ref.
[libguile/unif.c:998]

(array-ref [arg1 ...])
scm_uniform_vector_ref
[libguile/unif.c:1071]

(uniform-vector-ref v args)
Return the element at the @code{(index1, index2)} element in @var{array}.
[libguile/unif.c:1076]

(uniform-array-set1!)
scm_array_set_x
[libguile/unif.c:1240]

(array-set! v obj [args ...])
Set the element at the @code{(index1, index2)} element in @var{array} to
@var{new-value}.  The value returned by array-set! is unspecified.
[libguile/unif.c:1248]

(array-contents ra [strict])
If @var{array} may be @dfn{unrolled} into a one dimensional shared array
without changing their order (last subscript changing fastest), then
@code{array-contents} returns that shared array, otherwise it returns
@code{#f}.  All arrays made by @var{make-array} and
@var{make-uniform-array} may be unrolled, some arrays made by
@var{make-shared-array} may not be.

If the optional argument @var{strict} is provided, a shared array will
be returned only if its elements are stored internally contiguous in
memory.
[libguile/unif.c:1361]

(uniform-array-read! ra [port_or_fd [start [end]]])
Attempt to read all elements of @var{ura}, in lexicographic order, as
binary objects from @var{port-or-fdes}.
If an end of file is encountered during
uniform-array-read! the objects up to that point only are put into @var{ura}
(starting at the beginning) and the remainder of the array is
unchanged.

The optional arguments @var{start} and @var{end} allow
a specified region of a vector (or linearized array) to be read,
leaving the remainder of the vector unchanged.

@code{uniform-array-read!} returns the number of objects read.
@var{port-or-fdes} may be omitted, in which case it defaults to the value
returned by @code{(current-input-port)}.
[libguile/unif.c:1468]

(uniform-array-write v [port_or_fd [start [end]]])
Write all elements of @var{ura} as binary objects to
@var{port-or-fdes}.

The optional arguments @var{start}
and @var{end} allow
a specified region of a vector (or linearized array) to be written.

The number of objects actually written is returned. 
@var{port-or-fdes} may be
omitted, in which case it defaults to the value returned by
@code{(current-output-port)}.
[libguile/unif.c:1614]

(bit-count b bitvector)
Return the number of occurrences of the boolean B in BITVECTOR.
[libguile/unif.c:1724]

(bit-position item v k)
Return the minimum index of an occurrence of @var{bool} in @var{bv}
which is at least @var{k}.  If no @var{bool} occurs within the specified
range @code{#f} is returned.
[libguile/unif.c:1766]

(bit-set*! v kv obj)
If uve is a bit-vector @var{bv} and uve must be of the same length.  If
@var{bool} is @code{#t}, uve is OR'ed into @var{bv}; If @var{bool} is @code{#f}, the
inversion of uve is AND'ed into @var{bv}.

If uve is a unsigned integer vector all the elements of uve must be
between 0 and the @code{LENGTH} of @var{bv}.  The bits of @var{bv}
corresponding to the indexes in uve are set to @var{bool}.

The return value is unspecified.
[libguile/unif.c:1838]

(bit-count* v kv obj)
Return count of @var{kv} values in bit-vector @var{obj}.
@var{kv} can either be #t or #f.

@example
(bit-count (bit-set*! (if bool bv (bit-invert! bv)) uve #t) #t).
@end example
@var{bv} is not modified.
[libguile/unif.c:1897]

(bit-invert! v)
Modify @var{bv} by replacing each element with its negation.
[libguile/unif.c:1966]

(array->list v)
Return a list consisting of all the elements, in order, of @var{array}.
[libguile/unif.c:2048]

(list->uniform-array ndim prot lst)
Return a uniform array with @var{ndim} dimensions, of the
type indicated by prototype @var{prot},
and with elements the same as those of @var{lst}.
Elements must be of the
appropriate type, no coercions are done.
[libguile/unif.c:2145]

(array-prototype ra)
Return an object that would produce an array of the same type as
@var{array}, if used as the @var{prototype} for
@code{make-uniform-array}.
[libguile/unif.c:2493]

(make-variable init [name_hint])
Return a variable object initialized to value INIT.
If given, uses NAME-HINT as its internal (debugging)
name, otherwise just treat it as an anonymous variable.
Remember, of course, that multiple bindings to the same
variable may exist, so NAME-HINT is just that---a hint.
[libguile/variable.c:109]

(make-undefined-variable [name_hint])
Return a variable object initialized to an undefined value.
If given, uses NAME-HINT as its internal (debugging)
name, otherwise just treat it as an anonymous variable.
Remember, of course, that multiple bindings to the same
variable may exist, so NAME-HINT is just that---a hint.
[libguile/variable.c:133]

(variable? obj)
Return #t iff OBJ is a variable object, else return #f
[libguile/variable.c:153]

(variable-ref var)
Dereference VAR and return its value.
VAR must be a variable object;  see `make-variable' and
`make-undefined-variable'
[libguile/variable.c:165]

(variable-set! var val)
Set the value of the variable VAR to VAL.
VAR must be a variable object, VAL can be any value.
Returns an unspecified value.
[libguile/variable.c:179]

(builtin-variable name)
Return the built-in variable with the name NAME.
NAME must be a symbol (not a string).
Then use `variable-ref' to access its value.
[libguile/variable.c:193]

(variable-bound? var)
Return #t iff VAR is bound to a value.
Throws an error if VAR is not a variable object.
[libguile/variable.c:221]

(vector? obj)
Return @t{#t} if @var{obj} is a vector, otherwise returns @t{#f}. (r5rs)
[libguile/vectors.c:129]

(list->vector)
scm_vector
[libguile/vectors.c:148]

(vector [l ...])
Return a newly allocated vector whose elements contain the given
arguments.  Analogous to @samp{list}. (r5rs)

@example
(vector 'a 'b 'c)
@result{} #(a b c)
@end example
[libguile/vectors.c:167]

(make-vector k [fill])
Return a newly allocated vector of @var{k} elements.  If a second
argument is given, then each element is initialized to @var{fill}.
Otherwise the initial contents of each element is unspecified. (r5rs)
[libguile/vectors.c:255]

(vector->list v)
Return a newly allocated list of the objects contained
in the elements of @var{vector}.  (r5rs)

@example
(vector->list '#(dah dah didah))
@result{} (dah dah didah)
(list->vector '(dididit dah))
@result{} #(dididit dah)
@end example
[libguile/vectors.c:290]

(vector-fill! v fill_x)
Store @var{fill} in every element of @var{vector}.
The value returned by @samp{vector-fill!} is unspecified. (r5rs)
[libguile/vectors.c:307]

(vector-move-left! vec1 start1 end1 vec2 start2)
Vector version of @code{substring-move-left!}.
[libguile/vectors.c:334]

(vector-move-right! vec1 start1 end1 vec2 start2)
Vector version of @code{substring-move-right!}.
[libguile/vectors.c:357]

(major-version)
Return a string containing Guile's major version number.
E.g., "1".
[libguile/version.c:59]

(minor-version)
Return a string containing Guile's minor version number.
E.g., "3.5".
[libguile/version.c:71]

(version)
Return a string describing Guile's version number, or its major or minor
version numbers, respectively.

@example
(version) @result{} "1.3a"
(major-version) @result{} "1"
(minor-version) @result{} "3a"
@end example
[libguile/version.c:88]

(make-soft-port vector modes)
Return a port capable of receiving or delivering characters as
specified by the @var{modes} string (@pxref{File Ports,
open-file}).  @var{vector} must be a vector of length five.
Its components are as follows:

@enumerate 0
@item
procedure accepting one character for output
@item
procedure accepting a string for output
@item
thunk for flushing output
@item
thunk for getting one character
@item
thunk for closing port (not by garbage collection)
@end enumerate

For an output-only port only elements 0, 1, 2, and 4 need be
procedures.  For an input-only port only elements 3 and 4 need be
procedures.  Thunks 2 and 4 can instead be @code{#f} if there is no useful
operation for them to perform.

If thunk 3 returns @code{#f} or an @code{eof-object} (@pxref{Input,
eof-object?, ,r4rs, The Revised^4 Report on Scheme}) it indicates that
the port has reached end-of-file.  For example:

@example
(define stdout (current-output-port))
(define p (make-soft-port
           (vector
            (lambda (c) (write c stdout))
            (lambda (s) (display s stdout))
            (lambda () (display "." stdout))
            (lambda () (char-upcase (read-char)))
            (lambda () (display "@@" stdout)))
           "rw"))

(write p p)
@result{} #<input-output: soft 45d10>
@end example
[libguile/vports.c:181]

(make-weak-vector k [fill])
Return a weak vector with @var{k} elements, each the empty list.
Optional argument @var{fill} specifies a value to use
instead of the empty list.
[libguile/weaks.c:63]

(list->weak-vector)
scm_weak_vector
[libguile/weaks.c:79]

(weak-vector [l ...])
Construct a weak vector from a list: @code{weak-vector}
uses the list of its arguments while @code{list->weak-vector}
uses its only argument @var{l} (a list) to construct a weak
vector the same way @code{vector->list} would.
[libguile/weaks.c:86]

(weak-vector? obj)
Return @var{#t} iff @var{obj} is a weak vector.
Note that all weak hashes are also weak vectors.
[libguile/weaks.c:109]

(make-weak-key-hash-table k)
Return a hash table with weak keys with @var{k} buckets.
[libguile/weaks.c:124]

(make-weak-value-hash-table k)
Return a hash table with weak values with @var{k} buckets.
[libguile/weaks.c:140]

(make-doubly-weak-hash-table k)
Return a hash table with weak keys and values with
@var{k} buckets.
[libguile/weaks.c:157]

(weak-key-hash-table? obj)
Return @code{#t} iff @var{obj} is a weak key hash table.
[libguile/weaks.c:173]

(weak-value-hash-table? obj)
Return @code{#t} iff @var{obj} is a weak value hash table.
[libguile/weaks.c:183]

(doubly-weak-hash-table? obj)
Return @code{#t} iff @var{obj} is a doubly weak hash table.
Note that a doubly weak hash table is neither a weak key nor a
weak value hash table.
[libguile/weaks.c:195]

(base64-encode out-port input [line-break [crlf?]])
Write to @var{out-port} the result of base64-encoding @var{input} and
return the number of bytes written.  If @var{out-port} is #t, send to
the current output port.  If @var{out-port} is #f, return the
result as a string, instead.  @var{input} may be a string or a port.

Optional third arg @var{line-break} specifies the maximum number of columns
to appear in the result before a line break.  Actual number of columns is a
rounded-down multiple of four, but not less than four.  The result never
ends with a line break.  #f means omit line breaks entirely.

Optional fourth arg @var{crlf?} non-#f means use @sc{crlf} for line breaks
instead of simply @sc{lf}.
[ice-9/base64.scm:228]

(base64-decode out-port input)
Write to @var{out-port} the result of base64-decoding @var{input} and
return the number of bytes written.  If @var{out-port} is #t, send to
the current output port.  If @var{out-port} is #f, return the
result as a string, instead.  @var{input} may be a string or a port.
[ice-9/base64.scm:292]

(save-bindings-excursion vars [body...])
Expand to a form that saves the values for each binding named in
@var{vars}, a list of unevaluated symbols naming bindings in the
@code{save-bindings-excursion} caller, evaluates the @var{body} forms,
then restores the values.  These operations form the three branches of a
@code{dynamic-wind}.  Here is an example:

@example
(define a 42)
(define c 99)
(define (chk!) (write-line (list #:a a #:c c)))

(save-bindings-excursion (a c)
  (chk!)
  (set! a 0)
  (set! c -1)
  (chk!))
@end example
[ice-9/calling.scm:73]

(with-excursion-function vars collect)
Expand to an application of @var{collect} to an excursion proc @var{ex}.
@var{ex} takes one argument, a thunk, which forms the middle branch of a
@code{dynamic-wind}.  In the first branch, @var{ex} saves the values of
@var{vars}, a list of unevaluated symbols naming bindings in the
@code{with-excursion-function} caller.  In the third branch, @var{ex}
restores these values.  Here is an example that shows how to use this
macro:

@example
(with-excursion-function
  (a c) (lambda (ex)
          (ex (lambda ()
                (chk!)
                (set! a 0)
                (set! c -1)
                (chk!)))))
@end example

In this example, @var{collect} is an anonymous procedure, and the
excursion proc is named @code{ex}.  Note that this is functionally
equivalent to the one for @code{save-bindings-excursion} (with setup
definitions elided).
[ice-9/calling.scm:101]

(with-getter-and-setter vars collect)
Expand to an application of @var{collect} to @var{getter} and @var{setter}
procs for @var{vars}, an unevaluated list of symbols naming bindings in
the caller of @code{with-getter-and-setter}.  The call looks like:

@example
(collect getter setter)
@end example

@var{getter} and @var{setter} are procedures used to access or modify
@var{vars}.  @var{setter}, called with keywords arguments, modifies the
named values.  For example, if @code{foo} and @code{bar} are among
@var{vars}, then:

@example
(setter #:foo 1 #:bar 2)
===
(begin (set! foo 1) (set! bar 2))
@end example

@var{getter}, called with just keywords, returns a list of the
corresponding values.  To continue the above example:

@example
(getter #:foo #:bar)
@result{} (1 2)
@end example

@var{getter}, called with no arguments, returns a list of all accepted
keywords and the corresponding values.  To continue the above example,
with the additional stipulation that @code{foo} and @code{bar} are
the @emph{only} names in @var{vars}:

@example
(getter)
@result{} (#:foo 1 #:bar 2)
@end example

These calling sequences supports two handy idioms:

@example
(apply setter (getter))              ;; save and restore

(apply-to-args (getter #:foo #:bar)  ;; fetch and bind
  (lambda (foo bar) ....))
@end example
[ice-9/calling.scm:151]

(with-getter vars collect)
Like @code{with-getter-and-setter} but collect only @var{getter}.
[ice-9/calling.scm:157]

(with-delegating-getter-and-setter vars sub-g sub-s collect)
Expand to an application of @var{collect} to @var{getter} and @var{setter}
procs for @var{vars}, an unevaluated list of symbols naming bindings in
the caller of @code{with-delegating-getter-and-setter}.  The call looks
like:

@example
(collect getter setter)
@end example

If given a name not in @var{vars}, @var{getter} and @var{setter} call
@var{sub-g} and @var{sub-s}, respectively.
[ice-9/calling.scm:173]

(with-excursion-getter-and-setter vars collect)
Expand to an application of @var{collect} to excursion proc @var{ex},
@var{getter} and @var{setter} procs for @var{vars}, an unevaluated list of
symbols naming bindings in the caller of
@code{with-excursion-getter-and-setter}.  The call looks like:

@example
(collect excursion getter setter)
@end example

See @code{with-excursion-function} and @code{with-getter-and-setter}.
[ice-9/calling.scm:188]

(with-configuration-getter-and-setter vars-etc collect)
Expand to an application of @var{collect} to @var{getter} and @var{setter}
procs for @var{vars-etc}, a list of binding specifiers for bindings
visible in the caller of @code{with-configuration-getter-and-setter}.  The
call looks like:

@example
(collect getter setter)
@end example

@var{getter} and @var{setter} can trigger arbitrary computation, according
to the binding specifier, which has the form:

@example
(name [getter-hook [setter-hook]])
@end example

Both hook elements are evaluated; @var{name} is not.
Either hook may be #f or a procedure.

@var{getter-hook} is a thunk that returns a value for the corresponding
name.  If omitted (or #f is passed), use the normal value of @code{name}.

@var{setter-hook} is a procedure of one argument that accepts a new value
for @var{name}.  If omitted, @var{name} is simply updated with @code{set!}.
[ice-9/calling.scm:333]

(with-delegating-configuration-getter-and-setter vars-etc sub-g sub-s collect)
Like @code{with-delegating-getter-and-setter} but using @var{vars-etc}
as with @code{with-configuration-getter-and-setter}.
[ice-9/calling.scm:361]

(let-with-configuration-getter-and-setter vars-etc collect)
Like @code{with-configuration-getter-and-setter}
except that each element of @var{vars-etc} is:

@example
(name initial-value getter-hook setter-hook)
@end example

Also, this macro introduces an additional lexical binding for each
of the names in @code{vars-etc}.  It is short-hand for:

@example
(let ((<var1> initial-value-1)
      (<var2> initial-value-2)
       ...)
 (with-configuration-getter-and-setter
    ((<var1> v1-get v1-set)
     (<var2> v2-get v2-set)
     ...)
   collect))
@end example
[ice-9/calling.scm:408]

(adjoin e l)
Return list L, possibly with element E added if it is not already in L.
[ice-9/common-list.scm:102]

(union l1 l2)
Return a new list that is the union of L1 and L2.
Elements that occur in both lists occur only once in
the result list.
[ice-9/common-list.scm:107]

(intersection l1 l2)
Return a new list that is the intersection of L1 and L2.
Only elements that occur in both lists occur in the result list.
[ice-9/common-list.scm:116]

(set-difference l1 l2)
Return elements from list L1 that are not in list L2.
[ice-9/common-list.scm:126]

(reduce-init p init l)
Same as `reduce' except it implicitly inserts INIT at the start of L.
[ice-9/common-list.scm:134]

(reduce p l)
Combine all the elements of sequence L using a binary operation P.
The combination is left-associative.  For example, using +, one can
add up all the elements.  `reduce' allows you to apply a function which
accepts only two arguments to more than 2 objects.  Functional
programmers usually refer to this as foldl.
[ice-9/common-list.scm:141]

(some pred l [rest...])
PRED is a boolean function of as many arguments as there are list
arguments to `some', i.e., L plus any optional arguments.  PRED is
applied to successive elements of the list arguments in order.  As soon
as one of these applications returns a true value, return that value.
If no application returns a true value, return #f.
All the lists should have the same length.
[ice-9/common-list.scm:152]

(every pred l [rest...])
Return #t iff every application of PRED to L, etc., returns #t.
Analogous to `some' except it returns #t if every application of
PRED is #t and #f otherwise.
[ice-9/common-list.scm:169]

(notany pred [ls...])
Return #t iff every application of PRED to L, etc., returns #f.
Analogous to some but returns #t if no application of PRED returns a
true value or #f as soon as any one does.
[ice-9/common-list.scm:183]

(notevery pred [ls...])
Return #t iff there is an application of PRED to L, etc., that returns #f.
Analogous to some but returns #t as soon as an application of PRED returns #f,
or #f otherwise.
[ice-9/common-list.scm:190]

(count-if pred l)
Return the number of elements in L for which (PRED element) returns true.
[ice-9/common-list.scm:197]

(find-if pred l)
Search for the first element in L for which (PRED element) returns true.
If found, return that element, otherwise return #f.
[ice-9/common-list.scm:205]

(member-if pred l)
Return the first sublist of L for whose car PRED is true.
[ice-9/common-list.scm:213]

(remove-if pred l)
Remove all elements from L where (PRED element) is true.
Return everything that's left.
[ice-9/common-list.scm:220]

(remove-if-not pred l)
Remove all elements from L where (PRED element) is #f.
Return everything that's left.
[ice-9/common-list.scm:229]

(delete-if! pred l)
Destructive version of `remove-if'.
[ice-9/common-list.scm:238]

(delete-if-not! pred l)
Destructive version of `remove-if-not'.
[ice-9/common-list.scm:248]

(butlast lst n)
Return all but the last N elements of LST.
[ice-9/common-list.scm:258]

(and? [args...])
Return #t iff all of ARGS are true.
[ice-9/common-list.scm:271]

(or? [args...])
Return #t iff any of ARGS is true.
[ice-9/common-list.scm:278]

(has-duplicates? lst)
Return #t iff 2 members of LST are equal?, else #f.
[ice-9/common-list.scm:285]

(pick p l)
Apply P to each element of L, returning a list of elts
for which P returns a non-#f value.
[ice-9/common-list.scm:292]

(pick-mappings p l)
Apply P to each element of L, returning a list of the
non-#f return values of P.
[ice-9/common-list.scm:303]

(uniq l)
Return a list containing elements of L, with duplicates removed.
[ice-9/common-list.scm:314]

(frame-number->index n [stack...])
{Misc}
[ice-9/debug.scm:58]

(trace [procedure ...])
Enable debug tracing on @var{procedure}.  While a program is being run,
Guile will print a brief report at each call to a traced procedure,
advising the user which procedure was called and the arguments that were
passed to it.  If called with no args, return a list of the names of
currently traced procedures.
[ice-9/debug.scm:85]

(untrace [procedure ...])
Disable debug tracing for @code{procedure}.  If called with no args,
disable tracing for all currently traced procedures.
[ice-9/debug.scm:109]

(file-commentary filename [start [stop [scrub]]])
Return the commentary extracted from @var{filename}, or an empty string.
Normally, a file's commentary has the form:

@example
;;; Commentary:

;; This text, sans leading semicolons,
;; is what is normally extracted.

;;; Code:
@end example

Optional second arg @var{start} is a regexp that overrides the default
@code{"^;;; Commentary:"}.  Optional third arg @var{stop} is a regexp that
overrides the default @code{"^;;; Code:"}.  These args may also be a
compiled regexp, as returned by @code{make-regexp}, or #t to mean to use
the default.  Lines matched by @var{start} and @var{stop} are excluded from
the return value.

Optional fourth arg @var{scrub} is a procedure that takes a single line and
returns a new "clean" line.  These lines are concatenated in order to form
the return value.  The default scrub procedure simply eliminates leading
semicolons (optionally) followed by a single space char from its input line.
[ice-9/documentation.scm:123]

(module-commentary module-name)
Return the commentary associated with module @var{module-name} (a list of
symbols), or the empty string.
[ice-9/documentation.scm:154]

(search-documentation-files name [files...])
Return documentation for @var{name} (a symbol) if found in @var{files}.
If @var{files} is not specified, use @code{documentation-files}.
[ice-9/documentation.scm:213]

(object-documentation object)
Return the docstring for @var{object}.
[ice-9/documentation.scm:230]

(editing-buffer buffer [body...])
Consider @var{buffer} the current buffer and execute @var{body}.
In @var{body}, applications of one of the following procs are
handled specially.

@example
(toggle-read-only [arg])
(search-forward string [bound [noerror [repeat]]])
(match-end [n])
(match-data)
(set-match-data m)
(buffer-substring beg end)
(search-backward string [bound [noerror [repeat]]])
(match-string n)
(forward-char n)
(backward-char n)
(forward-line [n])
(beginning-of-line [n])
(end-of-line [n])
(re-search-forward regexp [bound [noerror [repeat]]])
(match-beginning [n])
(match-end [n])
(delete-region beg end)
(buffer-port)
(replace-match newtext)
(insert obj)                 ; gb/char/string/symbol/number/sexp
(looking-at regexp)
(delete-char n)
(erase-buffer)
(goto-char pos)
(buffer-string)
(point-min)
(point-max)
(point)
(bolp)                       ; beginning/end of line/buffer
(eolp)
(bobp)
(eobp)
(write-to-port port [beg [end]])
@end example

These calls are all translated by @code{editing-buffer} to procedures that
take gap-buffer @var{buffer} as initial argument (so that the "first" arg
above would actually be passed as the second arg, and so on).

If @var{buffer} is #t, create and use a new (empty) gap-buffer.
If @var{buffer} is not a gap-buffer object and not #t, it is passed to
@code{make-gap-buffer} and the result used for editing.

The value is that of the last form in @var{body}, or the gap-buffer
object if there are no @var{body} forms.
[ice-9/editing-buffer.scm:331]

(get-frame-source frame)
*fixme* Not necessary to use flags no-stack and no-source
[ice-9/emacs.scm:232]

(expect [clauses...])
expect: each test is a procedure which is applied to the accumulating
string.
[ice-9/expect.scm:84]

(expect-strings [clauses...])
the regexec front-end to expect:
each test must evaluate to a regular expression.
[ice-9/expect.scm:158]

(expect-select port timeout)
simplified select: return #t if input is waiting or #f if timed out or
select was interrupted by a signal.
timeout is an absolute time in floating point seconds.
[ice-9/expect.scm:182]

(expect-regexec rx s eof?)
match a string against a regexp, returning a list of strings (required
by the => syntax) or #f.  called once each time a character is added
to s (eof? will be #f), and once when eof is reached (with eof? #t).
[ice-9/expect.scm:196]

(ftw filename proc [options...])
Do a filesystem tree walk starting at @var{filename} using @var{proc}.

The @code{ftw} function calls the callback function given in the parameter
@var{proc} for every item which is found in the directory specified by
@var{filename} and all directories below.  The function follows symbolic links
if necessary but does not process an item twice.  If @var{filename} names no
directory this item is the only object reported by calling the callback
function.

The filename given to the callback function is constructed by taking the
@var{filename} parameter and appending the names of all passed directories and
then the local file name.  So the callback function can use this parameter to
access the file.  Before the callback function is called @code{ftw} calls
@code{stat} for this file and passes the information up to the callback
function.  If this @code{stat} call was not successful the failure is
indicated by setting the flag argument of the callback function to
@code{invalid-stat}.  Otherwise the flag is set according to the description
given in the description of @code{ftw-callback} above.

The callback function is expected to return non-#f to indicate that no error
occurred and the processing should be continued.  If an error occurred in the
callback function or the call to @code{ftw} shall return immediately the
callback function can return #f.  This is the only correct way to stop the
function.

@c The program must not use @code{throw} or similar techniques to
@c continue the program in another place.  [Can we relax this? --ttn]

The return value of the @code{ftw} function is #t if all callback function
calls returned #t and all actions performed by the @code{ftw} succeeded.  If
some function call failed (other than calling @code{stat} on an item) the
function returns #f.  If a callback function returns a value other than #t
this value is returned as the return value of @code{ftw}.
[ice-9/ftw.scm:254]

(nftw filename proc [control-flags...])
Do a new-style filesystem tree walk starting at @var{filename} using
@var{proc}.  Various optional @var{control-flags} alter the default behavior.

The @code{nftw} functions works like the @code{ftw} functions.  It calls
the callback function @var{proc} for all items it finds in the directory
@var{filename} and below.

The differences are that for one the callback function is of a different type.
It takes also @code{base} and @code{level} parameters as described above.

The second difference is that @code{nftw} takes additional optional arguments
which are zero or more of the following symbols:

@table @code
@item physical
While traversing the directory symbolic links are not followed.  I.e., if this
flag is given symbolic links are reported using the @code{symlink} value for
the type parameter to the callback function.  Please note that if this flag is
used the appearance of @code{symlink} in a callback function does not mean the
referenced file does not exist.  To indicate this the extra value
@code{stale-symlink} exists.

@item mount
The callback function is only called for items which are on the same mounted
filesystem as the directory given as the @var{filename} parameter to
@code{nftw}.

@item chdir
If this flag is given the current working directory is changed to the
directory containing the reported object before the callback function is
called.

@item depth
If this option is given the function visits first all files and subdirectories
before the callback function is called for the directory itself (depth-first
processing).  This also means the type flag given to the callback function is
@code{directory-processed} and not @code{directory}.
@end table

The return value is computed in the same way as for @code{ftw}.  @code{nftw}
returns #t if no failure occurred in @code{nftw} and all callback function
call return values are also #t.  For internal errors such as memory problems
the error @code{ftw-error} is thrown.  If the return value of a callback
invocation is not #t this very same value is returned.
[ice-9/ftw.scm:322]

(gb? object)
Return #t iff @var{object} is a gap buffer object.
[ice-9/gap-buffer.scm:151]

(make-gap-buffer [init])
Return a new gap buffer.  Optional arg @var{init} is either a port
to read from, or a string, used to initialize the buffer contents.
Point is left at the maximum position.
[ice-9/gap-buffer.scm:210]

(gb-toggle-read-only gb [arg])
Change whether @var{gb} is read-only.
With arg, set read-only iff arg is positive.
[ice-9/gap-buffer.scm:236]

(gb-point gb)
Return the position of point in @var{gb}.
This is an integer starting with 1 (one).
[ice-9/gap-buffer.scm:262]

(gb-point-min gb)
Return the minimum position possible for point in @var{gb}.
At this time, this value is always 1 (one).
[ice-9/gap-buffer.scm:269]

(gb-point-max gb)
Return the maximum position possible for point in @var{gb}.
This value can be changed by inserting text into the buffer,
and is limited by Guile's string implementation.
[ice-9/gap-buffer.scm:276]

(gb-bolp gb)
Return #t if point in @var{gb} is at the beginning of a line.
[ice-9/gap-buffer.scm:286]

(gb-eolp gb)
Return #t if point in @var{gb} is at the end of a line.
[ice-9/gap-buffer.scm:293]

(gb-bobp gb)
Return #t if point is at the beginning of @var{gb}.
[ice-9/gap-buffer.scm:300]

(gb-eobp gb)
Return #t if point is at the end of @var{gb}.
[ice-9/gap-buffer.scm:306]

(gb-insert-string! gb string)
Insert into @var{gb} a @var{string}, moving point forward as well as
increasing the value that would be returned by @code{gb-point-max}.
[ice-9/gap-buffer.scm:322]

(gb-insert-char! gb char)
Insert into @var{gb} a single @var{char}, moving point forward as well as
increasing the value that would be returned by @code{gb-point-max}.
[ice-9/gap-buffer.scm:333]

(gb-insert gb [args...])
Insert the arguments at point.
If an arg is a gap-buffer, insert its contents.
If an arg is a pair, insert a string made by applying @code{write} to it.
If an arg is a number, insert the result of @code{number->string}.
Other types accepted: char, string, symbol.
Point moves forward to end up after the inserted text.
[ice-9/gap-buffer.scm:347]

(gb-delete-char! gb count)
In @var{gb}, delete @var{count} characters from point, forward if
@var{count} is positive, backward if @var{count} is negative.  (If
@var{count} is zero, do nothing.)  Deleting backwards moves point
backwards.  Deleting forwards or backwards decreases the value that would
be returned by @code{gb-point-max}.
[ice-9/gap-buffer.scm:367]

(gb-delete-region gb beg end)
Delete text between @var{beg} and @var{end}.
[ice-9/gap-buffer.scm:379]

(gb-erase! gb)
Completely erase @var{gb}.  Point is left at the minimum position possible
(which happens to be also the maximum position possible since the buffer
is empty).
[ice-9/gap-buffer.scm:391]

(gb-goto-char gb new-point)
In @var{gb}, move point to @var{new-point} and return it.  If
@var{new-point} is outside the minimum and maximum positions possible, it
is adjusted to the the nearest boundary (however, the return value is
@var{new-point} unchanged).
[ice-9/gap-buffer.scm:414]

(gb-forward-char gb n)
In gap-buffer @var{gb}, move point forward @var{n} characters.
[ice-9/gap-buffer.scm:429]

(gb-backward-char gb n)
In gap-buffer @var{gb}, move point backward @var{n} characters.
[ice-9/gap-buffer.scm:437]

(gb-forward-line gb [n...])
In gap-buffer @var{gb}, move point @var{n} lines forward (backward if
@var{n} is negative).  Precisely, if point is on line @code{I}, move to the
start of line @code{I + N}.  If there isn't room, go as far as possible (no
error).  Return the count of lines left to move.  If moving forward, that
is @var{n} - number of lines moved; if backward, @var{n} + number moved.
With positive @var{n}, a non-empty line at the end counts as one line
successfully moved (for the return value).
[ice-9/gap-buffer.scm:484]

(gb-beginning-of-line gb [n...])
In gap-buffer @var{gb}, move point to beginning of current line.
With argument @var{n} not #f or 1, move forward @var{n} - 1 lines first.
If point reaches the beginning or end of buffer, it stops there.
[ice-9/gap-buffer.scm:492]

(gb-end-of-line gb [n...])
In gap-buffer @var{gb}, move point to end of current line.
With argument @var{n} not #f or 1, move forward @var{n} - 1 lines first.
If point reaches the beginning or end of buffer, it stops there.
[ice-9/gap-buffer.scm:501]

(gb-match-string gb n)
Return string of text matched by last search.
@var{n} specifies which parenthesized expression in the last regexp.
Value is #f if @var{n}th pair didn't match, or there were less than
@var{n} pairs.  Zero means the entire text matched by the whole regexp
or whole string.
[ice-9/gap-buffer.scm:554]

(gb-looking-at gb re-str)
Return #t if text after point matches regular expression @var{re-str}.
This function modifies the match data that @code{gb-match-beginning},
@code{gb-match-end} and @code{gb-match-data} access; save and restore
the match data if you want to preserve them.
[ice-9/gap-buffer.scm:566]

(gb-match-beginning [n])
Return position of start of text matched by last search.
@var{subexp}, a number, specifies which parenthesized expression
in the last regexp.  Value is #f if @var{subexp}th pair didn't match,
or there were less than @var{subexp} pairs.  Zero means the entire text
matched by the whole regexp.
[ice-9/gap-buffer.scm:586]

(gb-match-end [n])
Return position of end of text matched by last search.
@var{subexp}, a number, specifies which parenthesized expression in the
last regexp.  Value is nil if @var{subexp}th pair didn't match, or there
were less than @var{subexp} pairs.  Zero means the entire text matched by
the whole regexp.
[ice-9/gap-buffer.scm:598]

(gb-search-forward string [bound [noerror [count]]])
Search forward from point for @var{string}.
Set point to the end of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.  #f is equivalent
  to (point-max).
Optional third argument, if #t, means if fail just return #f (no error).
  If not #f and not #t, move to limit of search and return #f.
Optional fourth argument is repeat count--search for successive occurrences.
[ice-9/gap-buffer.scm:629]

(gb-search-backward string [bound [noerror [repeat]]])
Search backward from point for @var{string}.
Set point to the beginning of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
 If not nil and not t, position at limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
[ice-9/gap-buffer.scm:675]

(gb-re-search-forward regexp [bound [noerror [repeat]]])
Search forward from point for regular expression @var{regexp}.
Set point to the end of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if #t, means if fail just return #f (no error).
  If not #f and not #t, move to limit of search and return #f.
Optional fourth argument is repeat count--search for successive occurrences.

@var{regexp} may be a string, or compiled regular expression made with
@code{make-regexp}, in which case, it is the caller's decision whether or
not to include the flag @code{regexp/newline} (normally used when
@var{regexp} is a string to compile it internally).
[ice-9/gap-buffer.scm:726]

(gb-replace-match newtext [IGNORED [literal]])
Replace text matched by last search with @var{newtext}.
The second arg is optional and ignored (for now -- in the
future it may specify case handling a la Emacs).

If third arg @var{literal} is non-#f, insert @var{newtext} literally.
Otherwise treat @code{\} as special:
@example
  `\&' in NEWTEXT means substitute original matched text.
  `\N' means substitute what matched the Nth `(...)'.
       If Nth parens didn't match, substitute nothing.
  `\\' means insert one `\'.
@end example

Leave point at end of replacement text.
[ice-9/gap-buffer.scm:795]

(gb->port! gb port [beg [end]])
Send the contents of @var{gb} to the output @var{port}.
Optional args @var{beg} and @var{end} specify a region to send.
Point does not move.
[ice-9/gap-buffer.scm:815]

(gb->string gb)
Return a new string representing the text of @var{gb}.
Point does not move.
[ice-9/gap-buffer.scm:847]

(gb->substring gb start end)
Return the region of @var{gb} from @var{start} to @var{end} as a string.
[ice-9/gap-buffer.scm:872]

(gb-filter! gb string-proc)
Pass the string representing the text of @var{gb} to @var{string-proc} and
use its return value to completely replace the contents of @var{gb}.
Point is left at the maximum position.
[ice-9/gap-buffer.scm:888]

(gb->lines gb)
Return a list of strings representing the lines of text of @var{gb}.
Newlines are automatically removed.  A buffer with N newlines results
in a list of length N+1.  Point does not move.
[ice-9/gap-buffer.scm:899]

(gb-filter-lines! gb lines-proc)
Pass the list of strings representing the lines of text of @var{gb} to
@var{lines-proc} and use its return value (another list of strings) to
completely replace the contents of @var{gb}.  Newlines are automatically
removed and added back.  Point is left at the maximum position.
[ice-9/gap-buffer.scm:934]

(make-gap-buffer-port gb)
Return a "soft port" on @var{gb} that supports the write-character,
write-string and read-character operations (flush-output and close-port
are not supported).  All operations move point forward.  Additionally,
writing operations increase the value that would be returned by
@code{gb-point-max}.
[ice-9/gap-buffer.scm:964]

(getopt-long args grammar)
Parse the command line given in @var{args} (which must be a list of
strings) according to the option specification @var{grammar}.

The @var{grammar} argument is expected to be a list of this form:

@code{((@var{option} (@var{property} @var{value}) @dots{}) @dots{})}

where each @var{option} is a symbol denoting the long option, but
without the two leading dashes (e.g. @code{version} if the option is
called @code{--version}).

For each option, there may be list of arbitrarily many property/value
pairs.  The order of the pairs is not important, but every property may
only appear once in the property list.  The following table lists the
possible properties:

@table @asis
@item @code{(single-char @var{char})}
Accept @code{-@var{char}} as a single-character equivalent to
@code{--@var{option}}.  This is how to specify traditional Unix-style
flags.

@item @code{(required? @var{bool})}
If @var{bool} is true, the option is required.  @code{getopt-long} will
raise an error if it is not found in @var{args}.

@item @code{(value @var{bool})}
If @var{bool} is @code{#t}, the option accepts a value; if it is
@code{#f}, it does not; and if it is the symbol @code{optional}, the
option may appear in @var{args} with or without a value.

@item @code{(merge-multiple? @var{bool})}
If @var{bool} is @code{#t} and the @code{value} property is not
@code{#f}, all (one or multiple) occurrances are merged into a list
with order retained.  If @code{#f}, each instance of the option results
in a separate entry in the resulting alist.

@item @code{(predicate @var{func})}
If the option accepts a value (i.e. you specified @code{(value #t)} for
this option), then @code{getopt-long} will apply @var{func} to the
value, and throw an exception if it returns @code{#f}.  @var{func}
should be a procedure which accepts a string and returns a boolean
value; you may need to use quasiquotes to get it into @var{grammar}.
@end table
[ice-9/getopt-long.scm:433]

(option-ref options key default)
Search @var{options} for a command line option named @var{key} and
return its value, if found.  If the option has no value, but was given,
return @code{#t}.  If the option was not given, return @var{default}.
@var{options} must be the result of a call to @code{getopt-long}.
[ice-9/getopt-long.scm:471]

(fob-info object [aspects...])
Return #f if @var{object} is not a fob.
Otherwise, return info on the fob depending on @var{aspects}.
If @var{aspects} is not specified, return #t.
If @var{aspects} is a single keyword, return the information
associated with that keyword.  Otherwise, return a vector
composed of the information associated with each specified keyword
in @code{aspects}, in order.

Recognized keywords and their associated information:

@table @code
@item #:name
The name, a list of symbols, for example @code{(ice-9 q)}.

@item #:kind
A symbol, one of: @code{directory}, @code{interface}, @code{autoload}.

@item #:uses
A possibly-empty list of other fobs that this @var{object} uses.

@item #:obarray
The hash table mapping symbols to @dfn{variables}.
The name ``obarray'' is a historical artifact.

@item #:eval-closure
The eval-closure procedure.

@item #:public-interface
Another fob that describes the exported (also called @dfn{public})
bindings available of @var{object}, or #f if that does not make
sense (for example, in the case where @var{object} is already an
interface fob).
@end table
[ice-9/gumm.scm:109]

(current-module)
Return the environment that represents the "module in focus".
This is suitable for passing to @code{eval-in-module}, for example.
[ice-9/gumm.scm:166]

(eval-in-module exp module)
Evaluate expression @var{exp} in the environment @var{module}.
You can obtain such an environment by evaluating a combination of
@code{define-module} and @code{current-module} forms, for example.
[ice-9/gumm.scm:173]

(disable-module-catalogs!)
Turn off module catalogs support for this Guile session.
This action is not reversible.
[ice-9/gumm.scm:186]

(eval-in-current-module-proc)
Capture the environment of the current module.

Return a procedure that takes an expression @var{exp} and evaluates it in
the captured environment.  During evaluation the current module is set to
the one corresponding to the captured environment.

NOTE: This procedure is EXPERIMENTAL.  It is likely the module system will
provide direct support for this functionality via a @code{define-module}
clause prior to Guile 1.4.2 release.
[ice-9/gumm.scm:200]

(hashq-cons-hash pair n)
Return the hash of @var{pair} modulo @var{n}.
Use an @code{eq?} hash of the @sc{car} and
@sc{cdr} of @var{pair} for the computation.
[ice-9/hcons.scm:70]

(hashq-cons-assoc key alist)
Return the first element in @var{alist} whose @sc{car} and @sc{cdr} are
@code{eq?} to that of the pair @var{key}.  Return #f if no match exists.
[ice-9/hcons.scm:81]

(hashq-cons-get-handle table key)
Return the handle from hash @var{table} whose @sc{car} and @sc{cdr}
are @code{eq?} to that of the pair @var{key}.
[ice-9/hcons.scm:95]

(hashq-cons-create-handle! table key init)
Create a handle in hash @var{table} for pair @var{key} and
store the initial value @var{init} there.  Return the handle.
[ice-9/hcons.scm:102]

(hashq-cons-ref table key)
Return the value associated with pair @var{key} in hash @var{table},
or #f if @var{key} is not to be found.
[ice-9/hcons.scm:109]

(hashq-cons-set! table key val)
In hash @var{table}, associate with pair @var{key} the value @var{val}.
[ice-9/hcons.scm:115]

(hashq-cons table a d)
Add to hash @var{table} an entry for the double-key @var{a} and
@var{d}.  The associated value is #f.  Return the combined key (pair).
[ice-9/hcons.scm:122]

(hashq-conser hash-tab-or-size)
Return a procedure that does @code{hashq-cons} on @var{hash-tab-or-size}.
If @var{hash-tab-or-size} is a number, allocate and a hash table of that
size and use it.  The procedure takes two args, @var{a} and @var{d}, the
same as the latter two args of @code{hashq-cons}.
[ice-9/hcons.scm:131]

(make-gc-buffer n)
Construct a private ring (circular list) of @var{n} elements and return a
procedure @var{proc} that updates it.  @var{proc} takes one argument,
@var{next}, which is added to the ring and also returned.  An element added
in this way remains referenced for the next @code{@var{n} @minus{} 1}
invocations of @var{proc}.  To ``clear'' the ring, consecutively call
@var{proc} with arg #f at least @var{n} times.
[ice-9/hcons.scm:145]

(make-read-tokenizer port)
Return a thunk reads from @var{port} and returns a token
to be used by the rest of the infix machinery.
[ice-9/infix.scm:135]

(helper-nth object n)
Return the zero-based @var{n}th item from @var{object}.
@var{object} may be a vector, pair or a string.
[ice-9/infix.scm:177]

(add-infix-operator name priority #:key (right #f) (func #f)
Add @var{name} (a symbol) to the internal table of infix operators.
@var{priority} is an integer.  Optional keys: #:right (boolean) means the
operator is right-associative, and #:func (symbol) names a Scheme procedure
to call to actually do the operation.  (For example, we specify
@code{modulo} for @code{%}.)
[ice-9/infix.scm:201]

(add-prefix-operator name priority #:key (func #f)
Add @var{name} (a symbol) to the internal table of prefix operators.
@var{priority} is an integer.  Optional key #:func (symbol) names a Scheme
procedure to call to actually do the operation.
[ice-9/infix.scm:216]

(read-infix-expr get-token end? allow-commas)
Call thunk @var{get-token} repeatedly until a well-formed Scheme expression
can be constructed from the tokens.  Return the expression.  @var{end?} is
a procedure called on a token; it returns non-#f to break the reading loop.
@var{allow-commas}, if non-#f, means to process commas without error.
[ice-9/infix.scm:262]

(infix-string->expr s)
Parse string @var{s} as an infix expression and return the corresponding
Scheme expression.
[ice-9/infix.scm:330]

(activate-infix)
Modify Guile's @code{read} mechanisms to recognize @code{#[ expr ]} as
an infix expression.
[ice-9/infix.scm:341]

(unread-string str line-buffering-input-port)
Return string @var{str} to @var{line-buffering-input-port}.
A subsequent call to @code{read-string} or @code{read-char} from
this port will retrieve this string or its first character, respectively,
before consulting the underlying port.
[ice-9/lineio.scm:65]

(read-string line-buffering-input-port)
Read a line from @var{line-buffering-input-port}.
Return it as a string, ending with newline.
[ice-9/lineio.scm:74]

(lineio-port? port)
Return #t iff @var{port} is a port capable of handling
@code{read-string} and @code{unread-string}.
[ice-9/lineio.scm:82]

(make-line-buffering-input-port underlying-port)
Return a wrapper port for @var{underlying-port}.

The wrapper port buffers characters read from @var{underlying-port}
internally, and parcels them out via calls to @code{read-char},
@code{read-string} and @code{unread-string}.
[ice-9/lineio.scm:92]

(local-definitions-in root names)
Return a list of names defined locally in the named subdirectory of
@var{root}.
[ice-9/ls.scm:61]

(definitions-in root names)
Return a list of all names defined in the named subdirectory of
@var{root}.  The list includes all locally defined names as well as
all names inherited from a member of a use-list.
[ice-9/ls.scm:76]

(ls [various-refs...])
With no arguments, return a list of definitions in the current module.

With just one argument, interpret that argument as the name of a
subdirectory of the current module and return a list of names defined
there.

With more than one argument, still compute subdirectory lists, but
return a list:

@smalllisp
((<subdir-name> . <names-defined-there>)
 (<subdir-name> . <names-defined-there>)
 ...)
@end smalllisp
[ice-9/ls.scm:102]

(lls [various-refs...])
Analogous to @code{ls}, but with local definitions only.
[ice-9/ls.scm:114]

(recursive-local-define name value)
Define @var{name} to have value @var{value}.
@var{name} is a list of symbols, the last one being the
binding name and the all previous ones being elements of the
module name.
[ice-9/ls.scm:129]

(hash-table-mapping [options...])
Return a mapping object, configured by @var{options}.

@var{options} are alternating keywords and values, passed to
@code{make-hash-table}.  Two keywords are handled specially:

@table @code
@item #:hash2 @var{hash2}
@var{hash2} is a procedure that takes two arguments, a key and an integer
@var{n}.  It should return an integer modulo @var{n}.  If unspecified, the
default is @code{hash}.

@item #:equal @var{equal}
@var{equal} is a procedure that takes two arguments and returns non-#f
if they are considered to represent the same key.  If unspecified, the
default is @code{equal?}.
@end table

The mapping object prints using hash notation:

@example
(hash-table-mapping #:size 3 #:equal string-ci=?)
@result{} #<mapping hash/string-ci=? 3 4022fcf8>
@end example
[ice-9/mapping.scm:139]

(mapping-get-handle map key)
Return the handle from mapping @var{map} for @var{key}, or #f
if @var{key} is not in @var{map}.
[ice-9/mapping.scm:159]

(mapping-create-handle! map key [default])
Return the handle from mapping @var{map} for @var{key}, or if
@var{key} is not in @var{map}, create a new handle with value
@var{default} and return the new handle.
[ice-9/mapping.scm:169]

(mapping-remove! map key)
Remove @var{key} and its associated value from mappping @var{map}.
Return the handle.
[ice-9/mapping.scm:176]

(mapping-ref map key [default])
Return the value associated with @var{key} in mapping @var{map},
or @var{default} if there is no such association.
[ice-9/mapping.scm:191]

(mapping-set! map key val)
Associate @var{key} with @var{val} in mapping @var{map}.
Return @var{val}.
[ice-9/mapping.scm:201]

(activate-global-module-system-bindings! [sel...])
Make global bindings for the selected symbols @var{sel},
which must be from the following list:

@example
the-root-module
the-scm-module
module-ref
resolve-module
current-module
eval-in-module
module-public-interface
set-module-public-interface!
@end example

Throw error if a specified symbol is not in the list.
If @var{sel} is null, make bindings for the entire list of symbols.
This proc only works on its first call.  Subsequent calls do nothing.
[ice-9/module-system-compat.scm:86]

(define*-guts DT ARGLIST BODY)
The guts of define* and define*-public.
[ice-9/optargs-kw.scm:449]

(defmacro*-guts DT NAME ARGLIST BODY)
The guts of defmacro* and defmacro*-public
[ice-9/optargs-kw.scm:486]

(define*-guts DT ARGLIST BODY)
The guts of define* and define*-public.
[ice-9/optargs.scm:471]

(defmacro*-guts DT NAME ARGLIST BODY)
The guts of defmacro* and defmacro*-public
[ice-9/optargs.scm:508]

(pure-funcq base)
Return a procedure @var{pf} that wraps procedure @var{base}, associating
the arg list of each call to @var{pf} to its return value in a globally
shared (but bounded nonetheless) table.
[ice-9/poe.scm:112]

(perfect-funcq size base)
Return a procedure @var{pf} that wraps procedure @var{base}, associating
the arg list of each call to @var{pf} to its return value in a private
table of roughly @var{size} elements.  Thus: ``A pure funq may sometimes
forget its past but a perfect funcq never does.''
[ice-9/poe.scm:121]

(open-pipe command mode)
Execute the shell command @var{command} (a string) in a subprocess.
A pipe to the process is created and returned.  @var{modes} specifies
whether an input or output pipe to the process is created: it should
be the value of @code{OPEN_READ} or @code{OPEN_WRITE}.
[ice-9/popen.scm:143]

(close-pipe p)
Close the pipe created by @code{open-pipe}, then waits for the process
to terminate and returns its status value, @xref{Processes, waitpid}, for
information on how to interpret this value.
[ice-9/popen.scm:187]

(open-input-pipe command)
Equivalent to @code{open-pipe} with mode @code{OPEN_READ}.
[ice-9/popen.scm:216]

(open-output-pipe command)
Equivalent to @code{open-pipe} with mode @code{OPEN_WRITE}.
[ice-9/popen.scm:221]

(pretty-print obj [port [keywords ...]])
Pretty-print @var{obj} to current output port.  Optional second arg
@var{port} specifies another port to use.  Alternatively, you can also use
@code{#:port} to specify the port.

Formatting can be controlled by a number of additional keyword arguments:
Each line in the output is preceded by the string @code{#:per-line-prefix},
which is empty by default.  The output lines will be at most @code{#:width}
characters wide; the default is 79.  If @code{#:display?} is true, display
rather than write representation will be used.  If @code{#:escape-strings?}
is true (and @code{#:display?} is not true), replace tabs, newlines,
formfeeds and carriage returns in strings with the character sequences
@code{\t}, @code{\n}, @code{\f} and @code{\r}, respectively.
[ice-9/pretty-print.scm:371]

(sync-q! q)
Recompute and reset the last-pair component of queue @var{q}.
[ice-9/q.scm:89]

(make-q)
Return a new queue.
[ice-9/q.scm:97]

(q? obj)
Return #t iff @var{obj} is a queue.
An object is a queue if it is equal? to @code{(() . #f)}
or if it is a pair whose @sc{car} is a list and whose
@sc{cdr} is a @code{eq?} to the @sc{car}'s last pair.
[ice-9/q.scm:105]

(q-empty? q)
Return #t iff queue @var{q} contains no elements.
[ice-9/q.scm:115]

(q-empty-check q)
Check queue @var{q} and throw an exception if it contains no elements.
The key for the @code{throw} is @code{q-empty} and the value @var{q}.
[ice-9/q.scm:121]

(q-front q)
Return the first element of queue @var{q}.
[ice-9/q.scm:126]

(q-rear q)
Return the last element of queue @var{q}.
[ice-9/q.scm:131]

(q-remove! q obj)
Remove all occurences of @var{obj} from queue @var{q}.
[ice-9/q.scm:136]

(q-push! q obj)
Add @var{obj} to the front of queue @var{q}.
[ice-9/q.scm:143]

(enq! q obj)
Add @var{obj} to the rear of queue @var{q}.
[ice-9/q.scm:152]

(q-pop! q)
Take the front of queue @var{q} and return it.
[ice-9/q.scm:163]

(q-length q)
Return the number of enqueued elements in queue @var{q}.
[ice-9/q.scm:178]

(read-line! buf [port])
Read a line of text into the supplied string @var{buf} and return the
number of characters added to @var{buf}.  If @var{buf} is filled, then
@code{#f} is returned.
Read from @var{port} if
specified, otherwise from the value returned by @code{(current-input-port)}.
[ice-9/rdelim.scm:72]

(read-delimited! delims buf [port [handle-delim [start [end]]]])
Read text into the supplied string @var{buf} and return the number of
characters added to @var{buf} (subject to @var{handle-delim}, which takes
the same values specified for @code{read-line}.  If @var{buf} is filled,
@code{#f} is returned for both the number of characters read and the
delimiter.  Also terminates if one of the characters in the string
@var{delims} is found
or end-of-file is reached.  Read from @var{port} if supplied, otherwise
from the value returned by @code{(current-input-port)}.
[ice-9/rdelim.scm:100]

(read-delimited delims [port [handle-delim]])
Read text until one of the characters in the string @var{delims} is found
or end-of-file is reached.  Read from @var{port} if supplied, otherwise
from the value returned by @code{(current-input-port)}.
@var{handle-delim} takes the same values as described for @code{read-line}.
[ice-9/rdelim.scm:148]

(read-line [port [handle-delim]])
Return a line of text from @var{port} if specified, otherwise from the
value returned by @code{(current-input-port)}.  Under Unix, a line of text
is terminated by the first end-of-line character or by end-of-file.

If @var{handle-delim} is specified, it should be one of the following
symbols:
@table @code
@item trim
Discard the terminating delimiter.  This is the default, but it will
be impossible to tell whether the read terminated with a delimiter or
end-of-file.
@item concat
Append the terminating delimiter (if any) to the returned string.
@item peek
Push the terminating delimiter (if any) back on to the port.
@item split
Return a pair containing the string read from the port and the
terminating delimiter or end-of-file object.
@end table
[ice-9/rdelim.scm:223]

(match:count match)
Return the number of parenthesized subexpressions from @var{match}.
Note that the entire regular expression match itself counts as a
subexpression, and failed submatches are included in the count.
[ice-9/regex.scm:61]

(match:string match)
Return the original @var{target} string.
[ice-9/regex.scm:66]

(match:prefix match)
Return the unmatched portion of @var{target} preceding the regexp match.
[ice-9/regex.scm:71]

(match:suffix match)
Return the unmatched portion of @var{target} following the regexp match.
[ice-9/regex.scm:78]

(regexp-match? match)
Return @code{#t} if @var{obj} is a match structure returned by a
previous call to @code{regexp-exec}, or @code{#f} otherwise.
[ice-9/regex.scm:88]

(regexp-quote regexp)
Quote each special character found in @var{str} with a backslash, and
return the resulting string.
[ice-9/regex.scm:102]

(match:start match [n])
Return the starting position of submatch number @var{n}.
[ice-9/regex.scm:117]

(match:end match [n])
Return the ending position of submatch number @var{n}.
[ice-9/regex.scm:127]

(match:substring match [n])
Return the portion of @var{target} matched by subexpression number
@var{n}.  Submatch 0 (the default) represents the entire regexp match.
If the regular expression as a whole matched, but the subexpression
number @var{n} did not match, return @code{#f}.
[ice-9/regex.scm:142]

(string-match pattern str [start])
Compile the string @var{pattern} into a regular expression and compare
it with @var{str}.  The optional numeric argument @var{start} specifies
the position of @var{str} at which to begin matching.

@code{string-match} returns a @dfn{match structure} which
describes what, if anything, was matched by the regular
expression.  @xref{Match Structures}.  If @var{str} does not match
@var{pattern} at all, @code{string-match} returns @code{#f}.
[ice-9/regex.scm:164]

(regexp-substitute port match [items...])
Write to the output port @var{port} selected contents of the match
structure @var{match}.  Each @var{item} specifies what should be
written, and may be one of the following arguments:

@itemize @bullet
@item
A string.  String arguments are written out verbatim.

@item
An integer.  The submatch with that number is written.

@item
The symbol @samp{pre}.  The portion of the matched string preceding
the regexp match is written.

@item
The symbol @samp{post}.  The portion of the matched string following
the regexp match is written.
@end itemize

@var{port} may be @code{#f}, in which case nothing is written; instead,
@code{regexp-substitute} constructs a string from the specified
@var{item}s and returns that.
[ice-9/regex.scm:193]

(regexp-substitute/global port regexp string [items...])
Similar to @code{regexp-substitute}, but can be used to perform global
substitutions on @var{str}.  Instead of taking a match structure as an
argument, @code{regexp-substitute/global} takes two string arguments: a
@var{regexp} string describing a regular expression, and a @var{target}
string which should be matched against this regular expression.

Each @var{item} behaves as in @code{regexp-substitute}, with the
following exceptions:

@itemize @bullet
@item
A function may be supplied.  When this function is called, it will be
passed one argument: a match structure for a given regular expression
match.  It should return a string to be written out to @var{port}.

@item
The @samp{post} symbol causes @code{regexp-substitute/global} to recurse
on the unmatched portion of @var{str}.  This @emph{must} be supplied in
order to perform global search-and-replace on @var{str}; if it is not
present among the @var{item}s, then @code{regexp-substitute/global} will
return after processing a single match.
@end itemize
[ice-9/regex.scm:274]

(runq-control q msg [args...])
For runq @var{q}, process in the default way the control
message @var{msg} (a symbol) and its @var{args}.  These
messages are recognized:

@table @code
@item add!
@itemx enqueue!
Enqueue @var{args} as strips.

@item push!
Add @var{args} as strips to the front of the queue.

@item empty?
Return #t iff the runq is empty.

@item length
Return the number of strips in the runq.

@item kill!
Empty the runq.
@end table

Signal error for any other message, with key @code{not-understood}
and two arguments @var{msg} and @var{args}.
[ice-9/runq.scm:105]

(make-void-runq)
Return a runq that discards all messages except @code{length},
for which it returns 0.
[ice-9/runq.scm:123]

(make-fair-runq)
Return a runq procedure.
Called with no arguments, the procedure processes one strip from the queue.
Called with arguments, it uses @code{runq-control}.

In a fair runq, if a strip returns a new strip @code{X}, that is added
to the end of the queue, meaning it will be the last to execute
of all the remaining strips.
[ice-9/runq.scm:141]

(make-exclusive-runq)
Return a runq procedure.
Called with no arguments, the procedure processes one strip from the queue.
Called with arguments, it uses @code{runq-control}.

In an exclusive runq, if a strip @code{W} returns a new strip @code{X},
@code{X} is added to the front of the queue, meaning it will be the next to
execute of all the remaining procedures.

An exception to this occurs if @code{W} was the @sc{car} of a list of
strips.  In that case, after @code{X} is pushed onto the front of the
queue, the @sc{cdr} of the list of strips is pushed in front of that (if
the @sc{cdr} is not empty).  This way, the rest of the thunks in the list
that contained @code{W} have priority over @code{X}.
[ice-9/runq.scm:176]

(make-subordinate-runq-to superior basic-inferior)
Return a runq proxy for the runq @var{basic-inferior}.

The proxy watches for operations on @var{basic-inferior} that cause
a transition from a queue length of 0 to a non-zero length and
vice versa.   While @var{basic-inferior} is not empty,
the proxy installs a task on the @var{superior} runq.  Each strip
of that task processes @code{N} strips from @var{basic-inferior} where
@code{N} is the length of @var{basic-inferior} when the proxy
strip is entered.  [Countless scheduling variations are possible.]
[ice-9/runq.scm:209]

(fork-strips [args...])
Return a strip that starts several strips in
parallel.   If this strip is enqueued on a fair
runq, strips of the parallel subtasks will run
round-robin style.
[ice-9/runq.scm:242]

(strip-sequence [strips...])
Return a new strip which is the concatenation of @var{strips}.
[ice-9/runq.scm:247]

(fair-strip-subtask [initial-strips...])
Return a new strip which is the synchronous, fair,
parallel execution of the @var{initial-strips}.
[ice-9/runq.scm:260]

(add-to-load-path! directory [append?])
Add @var{directory} to @code{%load-path}, if it is not already there.
Add at the beginning, unless optional arg @var{append?} is non-#f.
[ice-9/session.scm:67]

(apropos rgx [options...])
Search for bindings matching @var{rgx}, a regular expression string.
@var{options} are symbols: @code{full}, @code{shadow}, @code{value}.
[ice-9/session.scm:277]

(apropos-internal rgx)
Return a list of accessible variable names for @var{rgx}.
[ice-9/session.scm:323]

(apropos-fold proc init rgx folder)
Fold PROCEDURE over bindings matching third arg REGEXP.

Result is

@example
  (PROCEDURE MODULE1 NAME1 VALUE1
    (PROCEDURE MODULE2 NAME2 VALUE2
      ...
      (PROCEDURE MODULEn NAMEn VALUEn INIT)))
@end example

where INIT is the second arg to `apropos-fold'.

Fourth arg FOLDER is one of

@example
  (apropos-fold-accessible MODULE) ;fold over bindings accessible in MODULE
  apropos-fold-exported		   ;fold over all exported bindings
  apropos-fold-all		   ;fold over all bindings
@end example
[ice-9/session.scm:332]

(make-fold-modules init-thunk traverse extract)
Return procedure capable of traversing a forest of modules.
The forest traversed is the image of the forest generated by root
modules returned by INIT-THUNK and the generator TRAVERSE.
It is an image under the mapping EXTRACT.
[ice-9/session.scm:381]

(apropos-fold-accessible module)
FIXME: Docs incomplete.
[ice-9/session.scm:403]

(source obj)
Return the source code for @var{obj}, a procedure or macro.
The source code is an acyclic structured expression (tree of symbols, etc).
If @var{obj} does not have source code associated with it, return #f.
[ice-9/session.scm:435]

(arity proc)
Display the arity of procedure @var{proc}.
[ice-9/session.scm:444]

(make-random-state [args...])
{Random numbers}
[ice-9/slib.scm:250]

(hack!)
Hack to make syncase macros work in the slib module
[ice-9/slib.scm:281]

(software-type)
Return a symbol describing the current platform's operating system.
This may be one of AIX, VMS, UNIX, COHERENT, WINDOWS, MS-DOS, OS/2,
THINKC, AMIGA, ATARIST, MACH, or ACORN.

Note that most varieties of Unix are considered to be simply "UNIX".
That is because when a program depends on features that are not present
on every operating system, it is usually better to test for the presence
or absence of that specific feature.  The return value of
@code{software-type} should only be used for this purpose when there is
no other easy or unambiguous way of detecting such features.
[ice-9/slib.scm:290]

(stack-catch key thunk handler)
Like @code{catch}, invoke @var{thunk} in the dynamic context of
@var{handler} for exceptions matching @var{key}, but also save the
current stack state in the @var{the-last-stack} fluid, for the purpose
of debugging or re-throwing of an error.  If thunk throws to the
symbol @var{key}, then @var{handler} is invoked this way:

@example
(handler key args ...)
@end example

@var{key} is a symbol or #t.

@var{thunk} takes no arguments.  If @var{thunk} returns normally, that
is the return value of @code{catch}.

Handler is invoked outside the scope of its own @code{catch}.  If
@var{handler} again throws to the same key, a new handler from further
up the call chain is invoked.

If the key is @code{#t}, then a throw to @emph{any} symbol will match
this call to @code{catch}."
[ice-9/stack-catch.scm:71]

(make-stream producer initial-state)
Return a stream object controlled by @var{producer} and @var{initial-state}.
@var{producer} is a procedure of one argument, the current state.
It should return either a pair or an atom (i.e. anything that
is not a pair).  If @var{producer} returns a pair, then the @sc{car} of the
pair is the stream's head value, and the @sc{cdr} is the state to be fed
to @var{producer} later.  If @var{producer} returns a non-pair, then the
stream is considered depleted.
[ice-9/streams.scm:74]

(stream-car stream)
Return the first element in @var{stream}.
This is analogous to @code{(car list)}.
[ice-9/streams.scm:86]

(stream-cdr stream)
Return the first tail of @var{stream}.
This is analogous to @code{(cdr list)}.
[ice-9/streams.scm:93]

(stream-null? stream)
Return #t if @var{stream} is the end-of-stream marker; otherwise
return #f.  This is analogous to @code{(null? list)}, but should
be used whenever testing for the end of a stream.
[ice-9/streams.scm:101]

(list->stream list)
Return a new stream whose elements are the elements of @var{list}.
[ice-9/streams.scm:109]

(vector->stream vector)
Return a new stream whose elements are the elements of @var{vector}.
[ice-9/streams.scm:119]

(stream->reversed-list&length stream)
Return two values: a new list whose elements are the elements of
@var{stream} in reversed order, and the length of the list.
[ice-9/streams.scm:131]

(stream->reversed-list stream)
Return a new list whose elements are the elements of @var{stream},
in reversed order.
[ice-9/streams.scm:141]

(stream->list&length stream)
Return two values: a new list whose elements are the elements of
@var{stream}, and the length of the list.
[ice-9/streams.scm:150]

(stream->list stream)
Return a new list whose elements are the elements of @var{stream}.
[ice-9/streams.scm:158]

(stream->vector stream)
Return a vector whose elements are the elements of @var{stream}.
[ice-9/streams.scm:164]

(stream-fold proc init stream0 [stream1...])
Apply @var{proc} to successive elements of the given @var{streams}
and to the value of the previous invocation (@var{init} on the first
invocation).  Return the last result from @var{proc}.

@var{proc} must take one more than the number of @var{streams}, like this:

@example
(proc car0 ... init)
@end example

NOTE: The @var{init} argument is last, not first.  (This was chosen
to be consistent the fold procedures from @ref{SRFI-1}.)
[ice-9/streams.scm:192]

(stream-for-each proc stream0 [stream1...])
Apply @var{proc} to each car of @var{streams}.
The return value is unspecified.
[ice-9/streams.scm:222]

(stream-map proc stream0 [stream1...])
Return a newly allocated stream, each element being the result of
applying @var{proc} to the corresponding elements of the @var{streams}
as its arguments.
[ice-9/streams.scm:248]

(port->stream port read)
Return a new stream whose elements are obtained by @var{read}ing
from @var{port}.
[ice-9/streams.scm:264]

(hack!)
Hack to make syncase macros work in the slib module
[ice-9/syncase.scm:229]

(run-test name expect-pass thunk)
Run test @var{name} (a string or other printable object), with expected
passing value @var{expect-pass} (#t or #f) by calling @var{thunk} (a
procedure with no arguments).
[ice-9/testing-lib.scm:319]

(pass-if name [body...])
Do @code{run-test} on @var{name} with thunkified forms in @var{body}.
Expect thunk to return #t.
[ice-9/testing-lib.scm:353]

(expect-fail name [body...])
Do @code{run-test} on @var{name} with thunkified forms in @var{body}.
Expect thunk to return #f.
[ice-9/testing-lib.scm:363]

(pass-if-exception name exception [body...])
Run a test @var{name}, expecting @var{exception} with thunkified forms
in @var{body}.  @var{exception} is an exception object described above.
The test passes only if the exception is actually thrown.
[ice-9/testing-lib.scm:398]

(expect-fail-exception name exception [body...])
Run a test @var{name}, expecting @var{exception} with thunkified forms
in @var{body}.  @var{exception} is an exception object described above.
The test passes only if the exception is NOT thrown.
[ice-9/testing-lib.scm:409]

(skip-file! reason)
Throw @code{skip-file} with @var{reason}, a string.
Note that @code{(ice-9 testing-lib)} makes no provision for catching this
tag; that responsibility is left to client code.
[ice-9/testing-lib.scm:420]

(format-test-name name)
Given a test @var{name}, return a nice human-readable string.
[ice-9/testing-lib.scm:430]

(current-test-prefix)
Return the current test prefix, a (possibly empty) list.
[ice-9/testing-lib.scm:457]

(with-test-prefix* prefix thunk)
Postpend @var{prefix} to the current name prefix while evaluting @var{thunk}.
The name prefix is only changed within the dynamic scope of the
call to @code{with-test-prefix*}.  Return the value returned by @var{thunk}.
[ice-9/testing-lib.scm:465]

(with-test-prefix prefix [body...])
Postpend @var{prefix} to the current name prefix while evaluating @var{body}
forms.  The name prefix is only changed within the dynamic scope of the
@code{with-test-prefix} expression.  Return the value returned by the last
@var{body} expression.
[ice-9/testing-lib.scm:476]

(register-reporter reporter)
Add the procedure @var{reporter} to the current set of reporter functions.
Signal an error if that reporter procedure object is already registered.
[ice-9/testing-lib.scm:498]

(unregister-reporter reporter)
Remove the procedure @var{reporter} from the current set of reporter
functions.  Signal an error if @var{reporter} is not currently registered.
[ice-9/testing-lib.scm:507]

(reporter-registered? reporter)
Return true iff @var{reporter} is in the current set of reporter functions.
[ice-9/testing-lib.scm:515]

(make-count-reporter)
Return a list of the form @code{(COUNTER RESULTS)}, where:

@itemize
@item @code{COUNTER} is a reporter procedure, and
@item @code{RESULTS} is a procedure taking no arguments which returns the
  the results seen so far by @code{COUNTER}.  The return value is an alist
  mapping outcome symbols (`pass', `fail', etc.) onto counts.
@end itemize
[ice-9/testing-lib.scm:582]

(print-counts results [port])
Print a count reporter's results nicely.  Pass this function the value
returned by a count reporter's @var{results} procedure.  Optional arg
@var{port} specifies a port to write to instead of the current output
port.
[ice-9/testing-lib.scm:602]

(make-log-reporter file)
Return a reporter procedure which prints all results to the file
@var{file}, in human-readable form.  @var{file} may be a filename,
or a port.
[ice-9/testing-lib.scm:623]

(full-reporter [args...])
Report all @var{args} (results) to the user.
[ice-9/testing-lib.scm:633]

(user-reporter result name [args...])
Check each @var{result} and report those @var{name} and additional
@var{args} that are "interesting", that is those that are one of:
@code{fail}, @code{upass}, @code{unresolved} or @code{error}.
[ice-9/testing-lib.scm:641]

(%thread-handler tag [args...])
This procedure is specified as the standard error-handler for
@code{make-thread} and @code{begin-thread}.  If the number of @var{args}
is three or more, use @code{display-error}, otherwise display a message
"uncaught throw to @var{tag}".  All output is sent to the port specified
by @code{current-error-port}.

Before display, global var @code{the-last-stack} is set to @code{#f}
and signals are unmasked with @code{unmask-signals}.

[FIXME: Why distinguish based on number of args?!  Cue voodoo music here.]
[ice-9/threads.scm:77]

(make-thread proc [args...])
Apply @var{proc} to @var{args} in a new thread formed by
@code{call-with-new-thread} using @code{%thread-handler} as the error
handler.
[ice-9/threads.scm:107]

(begin-thread first [rest...])
Evaluate forms @var{first} and @var{rest} in a new thread formed by
@code{call-with-new-thread} using @code{%thread-handler} as the error
handler.
[ice-9/threads.scm:118]

(with-mutex m [body...])
Lock mutex @var{m}, evaluate @var{body}, and then unlock @var{m}.
These sub-operations form the branches of a @code{dynamic-wind}.
[ice-9/threads.scm:129]

(monitor first [rest...])
Evaluate forms @var{first} and @var{rest} under a newly created
anonymous mutex, using @code{with-mutex}.

[FIXME: Is there any way to access the mutex?]
[ice-9/threads.scm:141]

(object->string obj [printer])
Return a Scheme string obtained by printing @var{obj}.
Printing function can be specified by the optional second
argument @var{printer} (default: @code{write}).
[ice-9/boot-9/alias-format.scm:53]

(apply-to-args args proc)
Apply @var{proc} to @var{args}, a list.
[ice-9/boot-9/apply-to-args.scm:57]

(uniform-vector? obj)
Return #t if @var{obj} is a uniform vector.
[ice-9/boot-9/arrays.scm:45]

(make-uniform-vector length prototype [fill...])
Create and return a uniform vector of type corresponding to
@var{prototype} with length @var{length}.  If optional arg @var{fill}
is given, fill the array with it, otherwise fill with @var{prototype}.
[ice-9/boot-9/arrays.scm:52]

(uniform-vector-set! uve i obj)
In uniform vector @var{uve}, set element @var{i} to @var{obj}.
[ice-9/boot-9/arrays.scm:61]

(uniform-vector-fill! uve fill)
Store @var{fill} in every element of @var{uve}.
The return value is unspecified.
[ice-9/boot-9/arrays.scm:68]

(make-array fill [bound ...])
Return a newly created array with elements initialized to @var{fill}.
The array dimensions are equal to the number of @var{bound} arguments
(which may be zero).  Each @var{bound} is either a positive non-zero
integer @code{N}, in which case the index for that dimension ranges
from 0 through @code{N-1}; or an explicit index range specifier in the
form @code{(LOWER UPPER)}, where both @code{LOWER} and @code{UPPER}
are integers, possibly negative, and possibly the same number (however,
@code{LOWER} must be less than @code{UPPER}).
[ice-9/boot-9/arrays.scm:88]

(make-uniform-array prototype [bound ...])
Create and return a uniform array of type corresponding to
@var{prototype} that has as many dimensions as there are @var{bound}s
and fill it with @var{prototype}.
[ice-9/boot-9/arrays.scm:98]

(list->array ndim lst)
Equivalent to @code{(list->uniform-array ndim '() lst)}.
[ice-9/boot-9/arrays.scm:104]

(list->uniform-vector prot lst)
Equivalent to @code{(list->uniform-array 1 prot lst)}.
[ice-9/boot-9/arrays.scm:110]

(array-shape a)
Return a list of inclusive bounds of integers for array @var{a}.

@example
(array-shape (make-array 'foo '(-1 3) 5))
@result{} ((-1 3) (0 4))
@end example
[ice-9/boot-9/arrays.scm:121]

(and-map proc lst)
Apply @var{proc} to successive elements of @var{lst} until exhaustion
or @var{proc} returns #f.  If returning early, return #f.  Otherwise,
return the last value returned by @var{proc}.  If @var{proc} has never
been called because @var{lst} is empty, return #t.
[ice-9/boot-9/boolean-map.scm:55]

(or-map proc lst)
Apply @var{proc} to successive elements of @var{lst} until exhaustion
or while @var{proc} returns #f.  If returning early, return the return
value of @var{proc}.
[ice-9/boot-9/boolean-map.scm:68]

(->bool obj)
If @var{obj} is #f, return it.  Otherwise, return #t.
[ice-9/boot-9/booleans.scm:48]

(collect [forms...])
Return a list of the results of all constituent @var{forms}.  Contrast this
with @code{begin}, which returns the result of the last form, only.
[ice-9/boot-9/collect.scm:46]

(cond-expand-provide module features)
Add one or more features to the `cond-expand' feature list of the
module `module'.  If `module' is #t, that means the current module.
[ice-9/boot-9/cond-expand.scm:87]

(bad-throw key [args...])
bad-throw is the hook that is called upon a throw to a an unhandled
key (unless the throw has four arguments, in which case
it's usually interpreted as an error throw.)
If the key has a default handler (a throw-handler-default property),
it is applied to the throw.
[ice-9/boot-9/error-handling.scm:64]

(false-if-exception expr)
Evaluate @var{expr}, catching any errors.
If there are no errors, return the value of @var{expr}.
Otherwise, return @code{#f}.
[ice-9/boot-9/false-if-exception.scm:47]

(port? obj)
Return a boolean indicating whether @var{obj} is a port.
[ice-9/boot-9/fdes.scm:44]

(move->fdes fd/port fd)
Move the underlying file descriptor for @var{port} to the integer
value @var{fdes} and sets its revealed count to one.  Any other ports
already using this descriptor will be automatically shifted to new
descriptors and their revealed counts reset to zero.
The return value is unspecified.
[ice-9/boot-9/fdes.scm:59]

(release-port-handle port)
Decrement the revealed count for a port.
[ice-9/boot-9/fdes.scm:71]

(dup->port port/fd mode [maybe-fd...])
Return a new port using the new file descriptor.  @var{mode} supplies a
mode string for the port (@pxref{File Ports, open-file}).
[ice-9/boot-9/fdes.scm:79]

(dup->inport port/fd [maybe-fd...])
Return a new input port using the new file descriptor.
[ice-9/boot-9/fdes.scm:88]

(dup->outport port/fd [maybe-fd...])
Return a new output port using the new file descriptor.
[ice-9/boot-9/fdes.scm:93]

(dup port/fd [maybe-fd...])
Return a new port if @var{port/fd} is a port, with the same mode as the
supplied port, otherwise returns an integer file descriptor.
[ice-9/boot-9/fdes.scm:99]

(duplicate-port port modes)
Return a new port which is opened on a duplicate of the file
descriptor underlying @var{port}, with mode string @var{modes}
as for @ref{File Ports, open-file}.  The two ports share a file
position and file status flags.

Unexpected behaviour can result if both ports are subsequently used
and the original and/or duplicate ports are buffered.  The mode string
can include @code{0} to obtain an unbuffered duplicate port.

This procedure is equivalent to @code{(dup->port @var{port} @var{modes})}.
[ice-9/boot-9/fdes.scm:115]

(fdes->inport fdes)
Return an existing input port which has @var{fdes} as its underlying file
descriptor, if one exists, and increments its revealed count.
Otherwise, returns a new input port with a revealed count of 1.
[ice-9/boot-9/fdes.scm:122]

(fdes->outport fdes)
Return an existing output port which has @var{fdes} as its underlying file
descriptor, if one exists, and increments its revealed count.
Otherwise, returns a new output port with a revealed count of 1.
[ice-9/boot-9/fdes.scm:139]

(port->fdes port)
Return the integer file descriptor underlying @var{port}.  As a
side effect the revealed count of @var{port} is incremented.
[ice-9/boot-9/fdes.scm:155]

(provide sym)
Add @var{sym} to the list of available features in this Guile
process.
[ice-9/boot-9/features.scm:48]

(provided? feature)
Return #t iff FEATURE is available to this Guile interpreter.
In SLIB, provided? also checks to see if the module is available.
We should do that too, but don't.
[ice-9/boot-9/features.scm:56]

(in-vicinity vicinity file)
Return a filename composed of @var{vicinity} and @var{file}.
@var{vicinity} need not end with trailing slash.
[ice-9/boot-9/file-utils.scm:83]

(hash-table? obj)
Return #t iff @var{obj} is a hash table.
[ice-9/boot-9/hash.scm:51]

(make-hash-table [args...])
Create a new hash table, configured by keywords in @var{args}.
The following keywords are recognized:

@table @code
@item #:size N
Use @var{n} slots.  Note that this does not limit the number of
elements able to be hashed in the table.  @var{n} should be similar
to the expected number of elements which will be added to the table,
but they need not match.  For good performance, use a prime number
for @var{n}.  As a special case, if @var{args} begins with @var{number},
that is equivalent to @code{#:size NUMBER}.  If @code{#:size} is not
specified, the default is 61.

@item #:weakness WEAK
@var{weak} must be one of #f, #t, @code{#:key}, @code{#:value},
or @code{#:key-and-value}.  If @var{weak} is not #f, the table
returned is a weak table.  Key/value pairs are removed from a weak
hash table when there are no non-weak references pointing to their
key, value, or both key and value, depending on @var{weak}.
@var{weak} #t is equivalent to @code{#:key-and-value}.
Default value of @var{weak} is #f.
@end table
[ice-9/boot-9/hash.scm:88]

(hash-for-each proc table)
Apply @var{proc} successively on all hash @var{table} items.
The arguments to @var{proc} are @code{(key value)} where @var{key}
and @var{value} are successive pairs from the hash table.
[ice-9/boot-9/hash.scm:136]

(symbol->keyword symbol)
Return a keyword with the same characters as in @var{sym}.
[ice-9/boot-9/keywords.scm:47]

(keyword->symbol kw)
Return a symbol with the same characters as in @var{kw}.
[ice-9/boot-9/keywords.scm:52]

(kw-arg-ref args kw)
Return the element of list @var{args} immediately following
@var{kw}, if available.  Otherwise return @code{#f}.
[ice-9/boot-9/keywords.scm:59]

(list-index l k)
Scan list @var{l} for element @var{k} and return its zero-based position,
or #f if @var{k} is not found.  Compare using @code{eq?}.
[ice-9/boot-9/lists.scm:49]

(make-list n [init])
Return a new list of @var{n} elements, where each element is
initialized to @var{init}.  @var{init} defaults to the empty list
@code{()} if not given.
[ice-9/boot-9/lists.scm:64]

(load-from-path name)
Load a Scheme source file named NAME, searching for it in the
directories listed in @code{%load-path}, and applying each of the file
name extensions listed in @code{%load-extensions}.
[ice-9/boot-9/load-from-path.scm:49]

(define-module module-name [options ...])
Associate forms following the @code{define-module} with
@var{module-name}, a list of symbols.  @xref{Finding Guile Modules}.
The @var{options} are zero or more keywords and argument(s) which specify
more about the defined module.  The recognized options and their meanings
are shown in the following table.

@table @code

@item #:use-module @var{interface-specification}
Equivalent to a @code{(use-modules @var{interface-specification})}
(@pxref{Using Guile Modules}).

@item #:use-syntax @var{sup-name}
Use supporting module @var{sup-name} when loading the currently defined
module, and install it as the syntax transformer.  @var{sup-name} is a list
of symbols.

@item #:autoload @var{sup-name} @var{list}
Load module @var{sup-name} whenever one of the symbols in @var{list} is
first accessed.  This loading is done without selection or renaming.
@var{sup-name} is a list of symbols.

@item #:export @var{list}
Export all identifiers in @var{list}, which must be a list of symbols.
This is equivalent to @code{(export @var{list})} in the module body.

@item #:no-backtrace
Tell Guile not to record information for procedure backtraces when
executing the procedures in this module.

@c + @item #:pure
@c + Create a @dfn{pure} module, that is a module which does not contain any
@c + of the standard procedure bindings except for the syntax forms.  This is
@c + useful if you want to create @dfn{safe} modules, that is modules which
@c + do not know anything about dangerous procedures.

@end table
[ice-9/boot-9/module-system-macros.scm:86]

(use-modules spec ...)
Resolve each interface specification @var{spec} into an interface and
arrange for these to be accessible by the current module.  The return
value is unspecified.

@var{spec} can be a list of symbols, in which case it names a module
whose public interface is found and used.

@var{spec} can also be of the form:

@smalllisp
(MODULE-NAME [KEYWORD VALUE ...])
@end smalllisp

in which case a custom interface for @var{module-name} (a list of
symbols, as above) is newly created and used, as specified by the
keywords and their values.  Supported keywords:

@table @code
@item #:select (selection-spec ...)
Each @var{selection-spec} is either a symbol naming the variable
directly, or a pair of symbols @code{(ORIG . SEEN)}, where @var{orig}
is the name in the used module and @var{seen} is the name in the
using module.  Note that @var{seen} is also passed through
@var{renamer}, described immediately below.

@item #:renamer renamer
@var{renamer} is a procedure that takes a symbol and returns another
one --- its new name.

@item #:prefix symbol
This is a common case of renaming whereby each name is prefixed with
@var{symbol}.  If both @code{#:renamer} and @code{#:prefix} are
specified, @code{#:renamer} takes precedence.
@end table

Both steps in specifying a custom interface, selection and renaming,
are optional.  If both are omitted, the returned interface has no
bindings.  If selection is omitted, renaming operates on the used
module's public interface.

Signal error if module name is not resolvable.
[ice-9/boot-9/module-system-macros.scm:140]

(use-syntax module-name)
Load the module @code{module-name} and use its system
transformer as the system transformer for the currently defined module,
as well as installing it as the current system transformer.  [REFFIXME]
[ice-9/boot-9/module-system-macros.scm:152]

(define-public foo ...)
Equivalent to @code{(begin (define foo ...) (export foo))}.
[ice-9/boot-9/module-system-macros.scm:170]

(export [names...])
Add all @var{names} (which must be symbols) to the list of exported
bindings of the current module.
[ice-9/boot-9/module-system-macros.scm:240]

(load filename)
Load @var{filename} and evaluate its contents in the top-level
environment.  The load paths are not searched.  If the variable
@code{%load-hook} is defined, it should be bound to a procedure that
will be called before any code is loaded.  See documentation for
@code{%load-hook} later in this section.
[ice-9/boot-9/module-system-macros.scm:262]

(symbol-prefix-proc prefix [cut])
Return a procedure that prefixes its arg (a symbol) with
@var{prefix} (also a symbol).  Optional arg @var{cut} specifies
the number of characters to remove from the head of the original symbol
before prefixing (useful for substitution).
[ice-9/boot-9/module-system.scm:1562]

(sethostent [stayopen...])
Initialize an internal stream from which host objects may be read.  This
procedure must be called before any calls to @code{gethostent}, and may
also be called afterward to reset the host entry stream.  If
@var{stayopen} is supplied and is not @code{#f}, the database is not
closed by subsequent @code{gethostbyname} or @code{gethostbyaddr} calls,
possibly giving an efficiency gain.
[ice-9/boot-9/networking.scm:69]

(setnetent [stayopen...])
Initialize an internal stream from which network objects may be read.  This
procedure must be called before any calls to @code{getnetent}, and may
also be called afterward to reset the net entry stream.  If
@var{stayopen} is supplied and is not @code{#f}, the database is not
closed by subsequent @code{getnetbyname} or @code{getnetbyaddr} calls,
possibly giving an efficiency gain.
[ice-9/boot-9/networking.scm:80]

(setprotoent [stayopen...])
Initialize an internal stream from which protocol objects may be read.  This
procedure must be called before any calls to @code{getprotoent}, and may
also be called afterward to reset the protocol entry stream.  If
@var{stayopen} is supplied and is not @code{#f}, the database is not
closed by subsequent @code{getprotobyname} or @code{getprotobynumber} calls,
possibly giving an efficiency gain.
[ice-9/boot-9/networking.scm:91]

(setservent [stayopen...])
Initialize an internal stream from which service objects may be read.  This
procedure must be called before any calls to @code{getservent}, and may
also be called afterward to reset the service entry stream.  If
@var{stayopen} is supplied and is not @code{#f}, the database is not
closed by subsequent @code{getservbyname} or @code{getservbyport} calls,
possibly giving an efficiency gain.
[ice-9/boot-9/networking.scm:102]

(gethostent)
Return the next host object from the host database, or @code{#f} if
there are no more hosts to be found (or an error has been encountered).
This procedure may not be used before @code{sethostent} has been called.
[ice-9/boot-9/networking.scm:111]

(getnetent)
Return the next entry from the network database.
[ice-9/boot-9/networking.scm:114]

(getprotoent)
Return the next entry from the protocol database.
[ice-9/boot-9/networking.scm:117]

(getservent)
Return the next entry from the services database.
[ice-9/boot-9/networking.scm:120]

(endhostent)
Close the stream used by @code{gethostent}.  The return value is unspecified.
[ice-9/boot-9/networking.scm:124]

(endnetent)
Close the stream used by @code{getnetent}.  The return value is unspecified.
[ice-9/boot-9/networking.scm:127]

(endprotoent)
Close the stream used by @code{getprotoent}.  The return value is unspecified.
[ice-9/boot-9/networking.scm:130]

(endservent)
Close the stream used by @code{getservent}.  The return value is unspecified.
[ice-9/boot-9/networking.scm:133]

(hostent:name obj)
The "official" hostname for @var{host}.
[ice-9/boot-9/networking.scm:137]

(hostent:aliases obj)
A list of aliases for @var{host}.
[ice-9/boot-9/networking.scm:140]

(hostent:addrtype obj)
The host address type.  For hosts with Internet addresses, this will
return @code{AF_INET}.
[ice-9/boot-9/networking.scm:144]

(hostent:length obj)
The length of each address for @var{host}, in bytes.
[ice-9/boot-9/networking.scm:147]

(hostent:addr-list obj)
The list of network addresses associated with @var{host}.
[ice-9/boot-9/networking.scm:150]

(netent:name obj)
The "official" network name.
[ice-9/boot-9/networking.scm:154]

(netent:aliases obj)
A list of aliases for the network.
[ice-9/boot-9/networking.scm:157]

(netent:addrtype obj)
The type of the network number.  Currently, this returns only
@code{AF_INET}.
[ice-9/boot-9/networking.scm:161]

(netent:net obj)
The network number.
[ice-9/boot-9/networking.scm:164]

(protoent:name obj)
The "official" protocol name.
[ice-9/boot-9/networking.scm:168]

(protoent:aliases obj)
A list of aliases for the protocol.
[ice-9/boot-9/networking.scm:171]

(protoent:proto obj)
The protocol number.
[ice-9/boot-9/networking.scm:174]

(servent:name obj)
The "official" name of the network service.
[ice-9/boot-9/networking.scm:178]

(servent:aliases obj)
A list of aliases for the network service.
[ice-9/boot-9/networking.scm:181]

(servent:port obj)
The Internet port used by the service.
[ice-9/boot-9/networking.scm:184]

(servent:proto obj)
The protocol used by the service.  A service may be listed many times
in the database under different protocol names.
[ice-9/boot-9/networking.scm:188]

(stat:type f)
derived from stat mode.
[ice-9/boot-9/posix.scm:71]

(getpwent)
Return the next entry in the user database, using the stream set by
@code{setpwent}.
[ice-9/boot-9/posix.scm:113]

(setpwent)
Initialize a stream used by @code{getpwent} to read from the user database.
The next use of @code{getpwent} returns the first entry.  The return value
is unspecified.
[ice-9/boot-9/posix.scm:118]

(endpwent)
Close the stream used by @code{getpwent}.  The return value is unspecified.
[ice-9/boot-9/posix.scm:121]

(getpwnam name)
Look up a user name string in the user database.
[ice-9/boot-9/posix.scm:125]

(getpwuid uid)
Look up an integer userid in the user database.
[ice-9/boot-9/posix.scm:128]

(getgrent)
Return the next entry in the group database, using the stream set by
@code{setgrent}.
[ice-9/boot-9/posix.scm:133]

(setgrent)
Initialize a stream used by @code{getgrent} to read from the group database.
The next use of @code{getgrent} returns the first entry.
The return value is unspecified.
[ice-9/boot-9/posix.scm:138]

(endgrent)
Close the stream used by @code{getgrent}.
The return value is unspecified.
[ice-9/boot-9/posix.scm:142]

(getgrnam name)
Look up a group name in the group database.
[ice-9/boot-9/posix.scm:146]

(getgrgid id)
Look up an integer group id in the group database.
[ice-9/boot-9/posix.scm:149]

(symbol-property sym prop)
From @var{sym}'s property list, return the value for property
@var{prop}.  The assumption is that @var{sym}'s property list is an
association list whose keys are distinguished from each other using
@code{equal?}; @var{prop} should be one of the keys in that list.  If
the property list has no entry for @var{prop}, @code{symbol-property}
returns @code{#f}.
[ice-9/boot-9/properties.scm:52]

(set-symbol-property! sym prop val)
In @var{sym}'s property list, set the value for property @var{prop} to
@var{val}, or add a new entry for @var{prop}, with value @var{val}, if
none already exists.  For the structure of the property list, see
@code{symbol-property}.
[ice-9/boot-9/properties.scm:61]

(symbol-property-remove! sym prop)
From @var{sym}'s property list, remove the entry for property
@var{prop}, if there is one.  For the structure of the property list,
see @code{symbol-property}.
[ice-9/boot-9/properties.scm:71]

(make-object-property [default])
Return a procedure-with-setter @var{prop} that can be used to get/set
a single property of arbitrary objects.  Optional arg @var{default}
specifies the default value for objects that do not yet have this
property.  If unspecified, use #f.  For example:

@example
(define otw (make-object-property 99)) ;; on the wall
(otw 'beers) => 99
(set! (otw 'beers) (1- (otw 'beers))) => 98
@end example

Note that @code{(set! (P obj) val)} returns @code{val}.

A single object property created by @code{make-object-property} can
associate distinct property values with all Scheme values that are
distinguishable by @code{eq?} (including, for example, integers).
[ice-9/boot-9/properties.scm:99]

(open-input-file str)
Take a string @var{str} naming an existing file and return an input port
capable of delivering characters from the file.  If the file cannot be
opened, signal an error.
[ice-9/boot-9/r4rs.scm:90]

(open-output-file str)
Take a string @var{str} naming an output file to be created and return an
output port capable of writing characters to a new file by that name.  If
the file cannot be opened, signal an error.  If a file with the given name
already exists, the effect is unspecified.
[ice-9/boot-9/r4rs.scm:99]

(open-io-file str)
Open file with name @var{str} for both input and output.
[ice-9/boot-9/r4rs.scm:105]

(call-with-input-file str proc)
Call @var{proc} with an input port opened on the file @var{str}.
The file must already exist. If the file cannot be opened, an error is
signalled.  If the procedure returns, then close the port automatically
and return the value yielded by the procedure.  If the procedure does
not return, then the port will not be closed automatically unless it is
possible to prove that the port will never again be used for a read or
write operation.
[ice-9/boot-9/r4rs.scm:120]

(call-with-output-file str proc)
closed automatically unless it is possible to prove that the port will
never again be used for a read or write operation.
[ice-9/boot-9/r4rs.scm:135]

(with-input-from-file file thunk)
Arrange input to be from @var{file} and call @var{thunk} with no arguments.
The file must already exist.  During the call, @code{current-input-port}
returns the input port that is opened on @var{file}.  When the @var{thunk}
returns, close the port and restore the previous default.  Return the value
yielded by @var{thunk}.  If an escape procedure is used to escape from the
continuation of these procedures, behavior is implementation dependent.
[ice-9/boot-9/r4rs.scm:164]

(with-output-to-file file thunk)
Arrange for output to be written to @var{file} and call @var{thunk} with
no arguments.  The effect is unspecified if the file already exists.
During the call, @code{current-output-port} returns the output port that
is opened on @var{file}.  When the @var{thunk} returns, close the port and
restore the previous default.  Return the value yielded by @var{thunk}.  If
an escape procedure is used to escape from the continuation of these
procedures, behavior is implementation dependent.
[ice-9/boot-9/r4rs.scm:179]

(with-error-to-file file thunk)
Arrange for errors to be written to @var{file} and call @var{thunk} with
no arguments.  The effect is unspecified if the file already exists.
During the call, @code{current-error-port} returns the error port that
is opened on @var{file}.  When the @var{thunk} returns, close the port and
restore the previous default.  Return the value yielded by @var{thunk}.  If
an escape procedure is used to escape from the continuation of these
procedures, behavior is implementation dependent.
[ice-9/boot-9/r4rs.scm:194]

(with-input-from-string string thunk)
Connect an input port to @var{string} and call @var{thunk} with no arguments.
During the call, @code{current-input-port} returns an input port connected
to the text of @var{string}.  When the @var{thunk} returns, close the port.
Return the value yielded by @var{thunk}.  If an escape procedure is used
to escape from the continuation of these procedures, behavior is
implementation dependent.
[ice-9/boot-9/r4rs.scm:208]

(with-output-to-string thunk)
Call @var{thunk} and return its output as a string.
[ice-9/boot-9/r4rs.scm:215]

(with-error-to-string thunk)
Call @var{thunk} and return its error output as a string.
[ice-9/boot-9/r4rs.scm:222]

(default-lazy-handler key cont tailp)
Save the stack, then throw again.
[ice-9/boot-9/running-repls.scm:82]

(set-batch-mode?! arg)
If @var{arg} is true, switche the interpreter to batch mode.
The @code{#f} case has not been implemented.
[ice-9/boot-9/running-repls.scm:114]

(batch-mode?)
Return a boolean indicating whether the interpreter is in batch mode.
[ice-9/boot-9/running-repls.scm:118]

(quit [exit-val...])
Throw back to the error handler of the current dynamic root.

If integer @var{exit-val} is specified and if Guile is being used
stand-alone and if quit is called from the initial dynamic-root,
@var{exit-val} becomes the exit status of the Guile process and the
process exits.
[ice-9/boot-9/running-repls.scm:273]

(repl-reader prompt)
The default repl-reader function.  We may override this if we've
the readline library.
[ice-9/boot-9/running-repls.scm:313]

(setenv name value)
Modify the environment of the current process, which is
also the default environment inherited by child processes.

If @var{value} is @code{#f}, then @var{name} is removed from the
environment.  Otherwise, the string @var{name}=@var{value} is added
to the environment, replacing any existing string with name matching
@var{name}.

The return value is unspecified.
[ice-9/boot-9/setenv.scm:54]

(make-record-type type-name fields [printer])
Return a @dfn{record-type descriptor}, a value representing a new data
type disjoint from all others.  The @var{type-name} argument must be a
string, but is only used for debugging purposes (such as the printed
representation of a record of the new type).  The @var{field-names}
argument is a list of symbols naming the @dfn{fields} of a record of the
new type.  It is an error if the list contains any duplicates.  It is
unspecified how record-type descriptors are represented.  Optional third
argument @var{printer} is a procedure that takes two args, a record of
the newly defined type and an output port.  The default printer displays
a record along the lines of @code{#<TYPE-NAME FIELD1: VAL1 ...>}.
[ice-9/boot-9/structs-records.scm:100]

(record-type-name obj)
Return the type-name associated with the type represented by rtd.  The
returned value is @code{eqv?} to the @var{type-name} argument given in
the call to @code{make-record-type} that created the type represented by
@var{rtd}.
[ice-9/boot-9/structs-records.scm:134]

(record-type-fields obj)
Return a list of the symbols naming the fields in members of the type
represented by @var{rtd}.  The returned value is @code{equal?} to the
field-names argument given in the call to @code{make-record-type} that
created the type represented by @var{rtd}.
[ice-9/boot-9/structs-records.scm:144]

(record-constructor rtd [field-names])
Return a procedure for constructing new members of the type represented
by @var{rtd}.  The returned procedure accepts exactly as many arguments
as there are symbols in the given list, @var{field-names}; these are
used, in order, as the initial values of those fields in a new record,
which is returned by the constructor procedure.  The values of any
fields not named in that list are unspecified.  The @var{field-names}
argument defaults to the list of field names in the call to
@code{make-record-type} that created the type represented by @var{rtd};
if the @var{field-names} argument is provided, it is an error if it
contains any duplicates or any symbols not in the default list.
[ice-9/boot-9/structs-records.scm:163]

(record-predicate rtd)
Return a procedure for testing membership in the type represented by
@var{rtd}.  The returned procedure accepts exactly one argument and
returns a true value if the argument is a member of the indicated record
type; it returns a false value otherwise.
[ice-9/boot-9/structs-records.scm:177]

(record-accessor rtd field-name)
Return a procedure for reading the value of a particular field of a
member of the type represented by @var{rtd}.  The returned procedure
accepts exactly one argument which must be a record of the appropriate
type; it returns the current value of the field named by the symbol
@var{field-name} in that record.  The symbol @var{field-name} must be a
member of the list of field-names in the call to @code{make-record-type}
that created the type represented by @var{rtd}.
[ice-9/boot-9/structs-records.scm:188]

(record-modifier rtd field-name)
Return a procedure for writing the value of a particular field of a
member of the type represented by @var{rtd}.  The returned procedure
accepts exactly two arguments: first, a record of the appropriate type,
and second, an arbitrary Scheme value; it modifies the field named by
the symbol @var{field-name} in that record to contain the given value.
The returned value of the modifier procedure is unspecified.  The symbol
@var{field-name} must be a member of the list of field-names in the call
to @code{make-record-type} that created the type represented by
@var{rtd}.
[ice-9/boot-9/structs-records.scm:206]

(record? obj)
Return @code{#t} if @var{obj} is a record of any type and @code{#f}
otherwise.

Note that @code{record?} may be true of any Scheme value; there is no
promise that records are disjoint with other Scheme types.
[ice-9/boot-9/structs-records.scm:220]

(record-type-descriptor obj)
Return a record-type descriptor representing the type of the given
record.  That is, for example, if the returned descriptor were passed to
@code{record-predicate}, the resulting predicate would return a true
value when passed the given record.  Note that it is not necessarily the
case that the returned descriptor is the one that was passed to
@code{record-constructor} in the call that created the constructor
procedure that created the given record.
[ice-9/boot-9/structs-records.scm:231]

(symbol-append [symbols...])
Return a symbol whose name is formed by appending the names
of @var{symbols}.
[ice-9/boot-9/symbols.scm:50]

(list->symbol chars)
Return a symbol whose name is composed of @var{chars},
a list of characters.
[ice-9/boot-9/symbols.scm:57]

(symbol [chars...])
Return a symbol whose name is composed of @var{chars}.
[ice-9/boot-9/symbols.scm:63]

(obarray-symbol-append ob [symbols...])
Return a symbol in obarray @var{ob} whose name is formed
by appending the names of @var{symbols}.
[ice-9/boot-9/symbols.scm:70]

(obarray-gensym obarray [opt])
Like @code{gensym} but for @var{obarray}.
[ice-9/boot-9/symbols.scm:78]

(exp z)
Return e to the power of @var{z}, where e is the base of natural
logarithms (2.71828@dots{}).
[ice-9/boot-9/transcendental-functions.scm:52]

(log z)
Return the natural logarithm of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:58]

(sqrt z)
Return the square root of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:65]

(expt z1 z2)
Return @var{z1} raised to the power of @var{z2}.
[ice-9/boot-9/transcendental-functions.scm:73]

(sinh z)
Return the hyperbolic sine of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:86]

(cosh z)
Return the hyperbolic cosine of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:93]

(tanh z)
Return the hyperbolic tangent of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:101]

(asinh z)
Return the hyperbolic arcsine of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:110]

(acosh z)
Return the hyperbolic arccosine of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:116]

(atanh z)
Return the hyperbolic arctangent of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:123]

(sin z)
Return the sine of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:130]

(cos z)
Return the cosine of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:137]

(tan z)
Return the tangent of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:144]

(asin z)
Return the arcsine of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:153]

(acos z)
Return the arccosine of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:160]

(atan z)
Return the arctangent of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:168]

(log10 arg)
Return the base 10 logarithm of @var{z}.
[ice-9/boot-9/transcendental-functions.scm:176]

(id x)
Return @var{x}.
[ice-9/boot-9/trivial-functions.scm:47]

(identity x)
Return @var{x}.
[ice-9/boot-9/trivial-functions.scm:51]

(1+ n)
Return one added to @var{n}.
[ice-9/boot-9/trivial-functions.scm:55]

(-1+ n)
Return one subtracted from @var{n}.
[ice-9/boot-9/trivial-functions.scm:59]

(1- n)
Return one subtracted from @var{n}.
[ice-9/boot-9/trivial-functions.scm:63]

(return-it [args...])
Return the first element in @var{args}, or @code{#f} if there are none.
[ice-9/boot-9/trivial-functions.scm:67]

(and=> value procedure)
If @var{value} is non-#f, call @var{procedure} passing it @var{value}.
[ice-9/boot-9/trivial-functions.scm:71]

(while cond [body...])
Evaluate all expressions in @var{body} in order, as long as @var{cond}
evaluates to a true value.  The @var{cond} expression is tested before
every iteration, so that the body is not evaluated at all if @var{cond}
is @code{#f} right from the start.  Within @var{body}, you can use:

@example
 (continue)     to skip the rest of the body and jump to beginning
 (break [val])  to exit the body, returning val (or #t if not specified)
@end example

If no @code{break} clause is evaluated, the value of @code{while} is #t.
[ice-9/boot-9/while.scm:60]

(with-fluids bindings [body...])
Temporarily set fluids as specified in @var{bindings},
evaluate @var{body}, then restore the previous values.
Each binding in the list @var{bindings} has the form: @code{(fluid value)}.
The resulting syntax is similar to @code{let}:

@example
(with-fluids ((fluid value)
              ...)
  body)
@end example
[ice-9/boot-9/with-fluids.scm:54]

(xcons d a)
Like @code{cons}, but with interchanged arguments.  Useful mostly when
passed to higher-order procedures.
[srfi/srfi-1.scm:205]

(check-arg-type pred arg caller)
internal helper, similar to (scsh utilities) check-arg.
[srfi/srfi-1.scm:210]

(non-negative-integer? x)
the srfi spec doesn't seem to forbid inexact integers.
[srfi/srfi-1.scm:218]

(list-tabulate n init-proc)
Return an @var{n}-element list, where each list element is produced by
applying the procedure @var{init-proc} to the corresponding list
index.  The order in which @var{init-proc} is applied to the indices
is not specified.
[srfi/srfi-1.scm:225]

(circular-list elt1 [rest...])
Return a circular list containing the given arguments @var{elt1}
@var{elt2} @dots{}.
[srfi/srfi-1.scm:235]

(proper-list? x)
Return @code{#t} if @var{obj} is a proper list, that is a finite list,
terminated with the empty list.  Otherwise, return @code{#f}.
[srfi/srfi-1.scm:267]

(circular-list? x)
Return @code{#t} if @var{obj} is a circular list, otherwise return
@code{#f}.
[srfi/srfi-1.scm:273]

(dotted-list? x)
Return @code{#t} if @var{obj} is a dotted list, return @code{#f}
otherwise.  A dotted list is a finite list which is not terminated by
the empty list, but some other value.
[srfi/srfi-1.scm:290]

(null-list? x)
Return @code{#t} if @var{lst} is the empty list @code{()}, @code{#f}
otherwise.  If something else than a proper or circular list is passed
as @var{lst}, an error is signalled.  This procedure is recommended
for checking for the end of a list in contexts where dotted lists are
not allowed.
[srfi/srfi-1.scm:314]

(not-pair? x)
Return @code{#t} is @var{obj} is not a pair, @code{#f} otherwise.
This is shorthand notation @code{(not (pair? @var{obj}))} and is
supposed to be used for end-of-list checking in contexts where dotted
lists are allowed.
[srfi/srfi-1.scm:328]

(list= elt= [rest...])
Return @code{#t} if all argument lists are equal, @code{#f} otherwise.
List equality is determined by testing whether all lists have the same
length and the corresponding elements are equal in the sense of the
equality predicate @var{elt=}.  If no or only one list is given,
@code{#t} is returned.
[srfi/srfi-1.scm:337]

(first pair)
These are synonyms for @code{car}, @code{cadr}, @code{caddr}, @dots{}.
[srfi/srfi-1.scm:358]

(car+cdr pair)
Return two values, the @sc{car} and the @sc{cdr} of @var{pair}.
[srfi/srfi-1.scm:380]

(take lst i)
Return a list containing the first @var{i} elements of @var{lst}.

@code{take!} may modify the structure of the argument list @var{lst}
in order to produce the result.
[srfi/srfi-1.scm:387]

(drop lst i)
Return a list containing all but the first @var{i} elements of
@var{lst}.
[srfi/srfi-1.scm:398]

(take-right flist i)
Return the a list containing the @var{i} last elements of @var{flist}.
[srfi/srfi-1.scm:406]

(drop-right flist i)
Return the a list containing all but the @var{i} last elements of
@var{flist}.

@code{drop-right!} may modify the structure of the argument list
@var{flist} in order to produce the result.
[srfi/srfi-1.scm:421]

(split-at lst i)
Return two values, a list containing the first @var{i} elements of the
list @var{lst} and a list containing the remaining elements.

@code{split-at!} may modify the structure of the argument list
@var{lst} in order to produce the result.
[srfi/srfi-1.scm:465]

(last lst)
Return the last element of the non-empty, finite list @var{lst}.
[srfi/srfi-1.scm:486]

(length+ clist)
Return the length of the argument list @var{lst}.  When @var{lst} is a
circular list, @code{#f} is returned.
[srfi/srfi-1.scm:494]

(concatenate l-o-l)
Construct a list by appending all lists in @var{list-of-lists}.

@code{concatenate!} may modify the structure of the given lists in
order to produce the result.
[srfi/srfi-1.scm:512]

(append-reverse rev-head tail)
Reverse @var{rev-head}, append @var{tail} and return the result.  This
is equivalent to @code{(append (reverse @var{rev-head}) @var{tail})},
but more efficient.

@code{append-reverse!} may modify @var{rev-head} in order to produce
the result.
[srfi/srfi-1.scm:551]

(zip clist1 [rest...])
Return a list as long as the shortest of the argument lists, where
each element is a list.  The first list contains the first elements of
the argument lists, the second list contains the second elements, and
so on.
[srfi/srfi-1.scm:566]

(unzip1 lst)
@code{unzip1} takes a list of lists, and returns a list containing the
first elements of each list, @code{unzip2} returns two lists, the
first containing the first elements of each lists and the second
containing the second elements of each lists, and so on.
[srfi/srfi-1.scm:580]

(fold kons knil list1 [rest...])
Fold the procedure @var{kons} across all elements of @var{lst1},
@var{lst2}, @dots{}.  Produce the result of

@code{(@var{kons} @var{en1} @var{en2} @dots{} (@var{kons} @var{e21}
@var{e22} (@var{kons} @var{e11} @var{e12} @var{knil})))},

if @var{enm} are the elements of the lists @var{lst1}, @var{lst2},
@dots{}.
[srfi/srfi-1.scm:628]

(fold-right kons knil clist1 [rest...])
Similar to @code{fold}, but applies @var{kons} in right-to-left order
to the list elements, that is:

@code{(@var{kons} @var{e11} @var{e12}(@var{kons} @var{e21}
@var{e22}  @dots{} (@var{kons} @var{en1} @var{en2} @var{knil})))},
[srfi/srfi-1.scm:647]

(pair-fold kons knil clist1 [rest...])
Like @code{fold}, but apply @var{kons} to the pairs of the list
instead of the list elements.
[srfi/srfi-1.scm:661]

(pair-fold-right kons knil clist1 [rest...])
Like @code{fold-right}, but apply @var{kons} to the pairs of the list
instead of the list elements.
[srfi/srfi-1.scm:677]

(unfold p f g seed [rest...])
@code{unfold} is defined as follows:

@lisp
(unfold p f g seed) =
   (if (p seed) (tail-gen seed)
       (cons (f seed)
             (unfold p f g (g seed))))
@end lisp

@table @var
@item p
Determines when to stop unfolding.

@item f
Maps each seed value to the corresponding list element.

@item g
Maps each seed value to next seed valu.

@item seed
The state value for the unfold.

@item tail-gen
Creates the tail of the list; defaults to @code{(lambda (x) '())}.
@end table

@var{g} produces a series of seed values, which are mapped to list
elements by @var{f}.  These elements are put into a list in
left-to-right order, and @var{p} tells when to stop unfolding.
[srfi/srfi-1.scm:718]

(unfold-right p f g seed [rest...])
Construct a list with the following loop.

@lisp
(let lp ((seed seed) (lis tail))
   (if (p seed) lis
       (lp (g seed)
           (cons (f seed) lis))))
@end lisp

@table @var
@item p
Determines when to stop unfolding.

@item f
Maps each seed value to the corresponding list element.

@item g
Maps each seed value to next seed valu.

@item seed
The state value for the unfold.

@item tail-gen
Creates the tail of the list; defaults to @code{(lambda (x) '())}.
@end table
[srfi/srfi-1.scm:757]

(reduce f ridentity lst)
@code{reduce} is a variant of @code{fold}.  If @var{lst} is
@code{()}, @var{ridentity} is returned.  Otherwise, @code{(fold (car
@var{lst}) (cdr @var{lst}))} is returned.
[srfi/srfi-1.scm:774]

(reduce-right f ridentity lst)
This is the @code{fold-right} variant of @var{reduce}.
[srfi/srfi-1.scm:779]

(map f list1 [rest...])
Map the procedure over the list(s) @var{lst1}, @var{lst2}, @dots{} and
return a list containing the results of the procedure applications.
This procedure is extended with respect to R5RS, because the argument
lists may have different lengths.  The result list will have the same
length as the shortest argument lists.  The order in which @var{f}
will be applied to the list element(s) is not specified.
[srfi/srfi-1.scm:804]

(for-each f list1 [rest...])
Apply the procedure @var{f} to each pair of corresponding elements of
the list(s) @var{lst1}, @var{lst2}, @dots{}.  The return value is not
specified.  This procedure is extended with respect to R5RS, because
the argument lists may have different lengths.  The shortest argument
list determines the number of times @var{f} is called.  @var{f} will
be applied to the list elements in left-to-right order.
[srfi/srfi-1.scm:822]

(append-map f clist1 [rest...])
Equivalent to

@lisp
(apply append (map f clist1 clist2 ...))
@end lisp

and

@lisp
(apply append! (map f clist1 clist2 ...))
@end lisp

Map @var{f} over the elements of the lists, just as in the @code{map}
function. However, the results of the applications are appended
together to make the final result. @code{append-map} uses
@code{append} to append the results together; @code{append-map!} uses
@code{append!}.

The dynamic order in which the various applications of @var{f} are
made is not specified.
[srfi/srfi-1.scm:858]

(map! f list1 [rest...])
Linear-update variant of @code{map} -- @code{map!} is allowed, but not
required, to alter the cons cells of @var{lst1} to construct the
result list.

The dynamic order in which the various applications of @var{f} are
made is not specified. In the n-ary case, @var{lst2}, @var{lst3},
@dots{} must have at least as many elements as @var{lst1}.
[srfi/srfi-1.scm:890]

(pair-for-each f clist1 [rest...])
Like @code{for-each}, but applies the procedure @var{f} to the pairs
from which the argument lists are constructed, instead of the list
elements.  The return value is not specified.
[srfi/srfi-1.scm:911]

(filter-map f clist1 [rest...])
Like @code{map}, but only results from the applications of @var{f}
which are true are saved in the result list.
[srfi/srfi-1.scm:929]

(filter pred list)
Return a list containing all elements from @var{lst} which satisfy the
predicate @var{pred}.  The elements in the result list have the same
order as in @var{lst}.  The order in which @var{pred} is applied to
the list elements is not specified.

@code{filter!} is allowed, but not required to modify the structure of
the list.
[srfi/srfi-1.scm:956]

(partition pred lst)
Return two lists, one containing all elements from @var{lst} which
satisfy the predicate @var{pred}, and one list containing the elements
which do not satisfy the predicated.  The elements in the result lists
have the same order as in @var{lst}.  The order in which @var{pred} is
applied to the list elements is not specified.

@code{partition!} is allowed, but not required to modify the structure of
the input list.
[srfi/srfi-1.scm:979]

(remove pred list)
Return a list containing all elements from @var{lst} which do not
satisfy the predicate @var{pred}.  The elements in the result list
have the same order as in @var{lst}.  The order in which @var{pred} is
applied to the list elements is not specified.

@code{remove!} is allowed, but not required to modify the structure of
the input list.
[srfi/srfi-1.scm:1003]

(find pred clist)
Return the first element of @var{lst} which satisfies the predicate
@var{pred} and @code{#f} if no such element is found.
[srfi/srfi-1.scm:1037]

(find-tail pred clist)
Return the first pair of @var{lst} whose @sc{car} satisfies the
predicate @var{pred} and @code{#f} if no such element is found.
[srfi/srfi-1.scm:1047]

(take-while pred ls)
Return the longest initial prefix of @var{lst} whose elements all
satisfy the predicate @var{pred}.

@code{take-while!} is allowed, but not required to modify the input
list while producing the result.
[srfi/srfi-1.scm:1060]

(drop-while pred clist)
Drop the longest initial prefix of @var{lst} whose elements all
satisfy the predicate @var{pred}.
[srfi/srfi-1.scm:1079]

(span pred lst)
@code{span} splits the list @var{lst} into the longest initial prefix
whose elements all satisfy the predicate @var{pred}, and the remaining
tail.  @code{break} inverts the sense of the predicate.

@code{span!} and @code{break!} are allowed, but not required to modify
the structure of the input list @var{lst} in order to produce the
result.
[srfi/srfi-1.scm:1095]

(any pred ls [lists...])
Apply @var{pred} across the lists and return a true value if the
predicate returns true for any of the list elements(s); return
@code{#f} otherwise.  The true value returned is always the result of
the first successful application of @var{pred}.
[srfi/srfi-1.scm:1128]

(every pred ls [lists...])
Apply @var{pred} across the lists and return a true value if the
predicate returns true for every of the list elements(s); return
@code{#f} otherwise.  The true value returned is always the result of
the final successful application of @var{pred}.
[srfi/srfi-1.scm:1154]

(list-index pred clist1 [rest...])
Return the index of the leftmost element that satisfies @var{pred}.
[srfi/srfi-1.scm:1177]

(member x list [rest...])
Return the first sublist of @var{lst} whose @sc{car} is equal to
@var{x}.  If @var{x} does no appear in @var{lst}, return @code{#f}.
Equality is determined by the equality predicate @var{=}, or
@code{equal?} if @var{=} is not given.
[srfi/srfi-1.scm:1197]

(delete x list [rest...])
Return a list containing all elements from @var{lst}, but without the
elements equal to @var{x}.  Equality is determined by the equality
predicate @var{=}, which defaults to @code{equal?} if not given.

@code{delete!} is allowed, but not required to modify the structure of
the argument list in order to produce the result.
[srfi/srfi-1.scm:1215]

(delete-duplicates list [rest...])
Return a list containing all elements from @var{lst}, but without
duplicate elements.  Equality of elements is determined by the
equality predicate @var{=}, which defaults to @code{equal?} if not
given.

@code{delete-duplicates!} is allowed, but not required to modify the
structure of the argument list in order to produce the result.
[srfi/srfi-1.scm:1237]

(alist-cons key datum alist)
Equivalent to

@lisp
(cons (cons @var{key} @var{datum}) @var{alist})
@end lisp

This procedure is used to coons a new pair onto an existing
association list.
[srfi/srfi-1.scm:1285]

(alist-copy alist)
Return a newly allocated copy of @var{alist}, that means that the
spine of the list as well as the pairs are copied.
[srfi/srfi-1.scm:1291]

(alist-delete key alist [rest...])
Return a list containing the pairs of @var{alist}, but without the
pairs whose @sc{cars} are equal to @var{key}.  Equality is determined
by @var{=}, which defaults to @code{equal?} if not given.

@code{alist-delete!} is allowed, but not required to modify the
structure of the list @var{alist} in order to produce the result.
[srfi/srfi-1.scm:1307]

(lset<= = [rest...])
Return @code{#t} if every @var{listi} is a subset of @var{listi+1},
otherwise return @code{#f}.  Returns @code{#t} if called with less
than two arguments. @var{=} is used for testing element equality.
[srfi/srfi-1.scm:1327]

(lset= = list1 [rest...])
Return @code{#t} if all argument lists are equal. @var{=} is used for
testing element equality.
[srfi/srfi-1.scm:1338]

(lset-adjoin = list [rest...])
Add all @var{elts} to the list @var{list}, suppressing duplicates and
return the resulting list.  @code{lset-adjoin!} is allowed, but not
required to modify its first argument. @var{=} is used for testing
element equality.
[srfi/srfi-1.scm:1352]

(lset-union = [rest...])
Return the union of all argument list sets.  The union is the set of
all elements which appear in any of the argument sets.
@code{lset-union!} is allowed, but not required to modify its first
argument. @var{=} is used for testing element equality.
[srfi/srfi-1.scm:1365]

(lset-intersection = list1 [rest...])
Return the intersection of all argument list sets.  The intersection
is the set containing all elements which appear in all argument sets.
@code{lset-intersection!} is allowed, but not required to modify its
first argument. @var{=} is used for testing element equality.
[srfi/srfi-1.scm:1383]

(lset-difference = list1 [rest...])
Return the difference of all argument list sets.  The difference is
the the set containing all elements of the first list which do not
appear in the other lists.  @code{lset-difference!}  is allowed, but
not required to modify its first argument. @var{=} is used for testing
element equality.
[srfi/srfi-1.scm:1399]

(lset-xor = [rest...])
Return the set containing all elements which appear in the first
argument list set, but not in the second; or, more generally: which
appear in an odd number of sets.  @code{lset-xor!}  is allowed, but
not required to modify its first argument. @var{=} is used for testing
element equality.
[srfi/srfi-1.scm:1419]

(lset-diff+intersection = list1 [rest...])
Return two values, the difference and the intersection of the argument
list sets. This works like a combination of @code{lset-difference} and
@code{lset-intersection}, but is more efficient.
@code{lset-diff+intersection!}  is allowed, but not required to modify
its first argument. @var{=} is used for testing element equality.  You
have to use some means to deal with the multiple values these
procedures return (@pxref{Multiple Values}).
[srfi/srfi-1.scm:1446]

(define-reader-ctor symbol proc)
Define @var{proc} as the reader constructor for hash-comma forms with a
tag @var{symbol}.  @var{proc} will be applied to the datum(s) following
the tag in the hash-comma expression after the complete form has been
read in.  The result of @var{proc} is returned by the Scheme reader.
[srfi/srfi-10.scm:94]

(lookup symbol)
Retrieve the constructor procedure for the tag @var{symbol} or
throw an error if no such tag is defined.
[srfi/srfi-10.scm:102]

(hash-comma char port)
This is the actual reader extension.
[srfi/srfi-10.scm:111]

(string-hash s [bound [start [end]]])
Return a hash value of the string @var{s} in the range 0 @dots{}
@var{bound} - 1.  @code{string-hash-ci} is the case-insensitive variant.
Optional third and fourth args @var{start} and @var{end} delimit the string.
[srfi/srfi-13.scm:155]

(string-hash-ci s [bound [start [end]]])
Return a hash value of the string @var{s} in the range 0 @dots{}
@var{bound} - 1.  This is the case-insensitive variant of
@code{string-hash}.  Optional third and fourth args @var{start}
and @var{end} delimit the string.
[srfi/srfi-13.scm:176]

(->char-set x)
Coerce @var{x} into a character set.  @var{x} may be a string, a
character or a character set.
[srfi/srfi-14.scm:129]

(priv:time-error caller type value)
FIXME: should this be something other than misc-error?
[srfi/srfi-19.scm:266]

(date->broken-down-time date)
Helpers
FIXME: finish this and publish it?
[srfi/srfi-19.scm:395]

(time-monotonic->time-utc time-in)
these depend on time-monotonic having the same definition as time-tai!
[srfi/srfi-19.scm:626]

(priv:encode-julian-day-number day month year)
gives the julian day which starts at noon.
[srfi/srfi-19.scm:719]

(priv:decode-julian-day-number jdn)
gives the seconds/date/month/year
[srfi/srfi-19.scm:733]

(priv:time->julian-day-number seconds tz-offset)
special thing -- ignores nanos
[srfi/srfi-19.scm:759]

(time-monotonic->date time [tz-offset...])
this is the same as time-tai->date.
[srfi/srfi-19.scm:834]

(priv:week-day day month year)
from calendar faq
[srfi/srfi-19.scm:922]

(priv:natural-year n)
given a 'two digit' number, find the year within 50 years +/-
[srfi/srfi-19.scm:970]

(time-monotonic->julian-day time)
this is the same as time-tai->julian-day
[srfi/srfi-19.scm:1031]

(priv:locale-print-time-zone date port)
FIXME: mkoeppe: Put a symbolic time zone in the date structs.
Print it here instead of the numerical offset if available.
[srfi/srfi-19.scm:1159]

(priv:locale-am/pm hr)
FIXME: we should use strftime to determine this dynamically if possible.
Again, locale specific.
[srfi/srfi-19.scm:1165]

(priv:integer-reader upto port)
read an integer upto n characters long on port; upto -> #f is any length
[srfi/srfi-19.scm:1438]

(priv:integer-reader-exact n port)
read *exactly* n characters and convert to integer; could be padded
[srfi/srfi-19.scm:1455]

(priv:locale-reader port indexer)
looking at a char, read the char string, run thru indexer, return index
[srfi/srfi-19.scm:1528]

(cut slot [slots...])
Expand to a procedure that specializes @code{slot} and @code{slots},
if they are the special symbol @code{<>} or @code{<...>}.  The latter
can only appear as the last element of @code{slots}.  Elements that
are neither of these special symbols are evaluated at run-time in
their respective positions.
[srfi/srfi-26.scm:69]

(cute [slots...])
Expand to a procedure that specializes @code{slots},
if they are the special symbol @code{<>} or @code{<...>}.  The latter
can only appear as the last element of @code{slots}.  Elements that
are neither of these special symbols are evaluated at expansion-time
in their respective positions.
[srfi/srfi-26.scm:98]

(make-parameter init [converter])
Return a new parameter object to a cell in the global dynamic environment
created by calling @var{converter} on @var{init}.  If @var{converter} is
not specified, it defaults to @code{identity}.
[srfi/srfi-39.scm:86]

(parameterize bindings [body...])
Dynamically bind parameter objects specified in @var{bindings}
and evaluate @var{body}.  Each binding in @var{bindings} has the
form @code{(expr1 expr2)}, where @var{expr1} evaluates to a parameter
object.  The order of evaluation for @var{expr1} and @var{expr2} is
not specified.
[srfi/srfi-39.scm:108]

(hash-f char port)
Reader extension for #f32() and #f64() vectors.
[srfi/srfi-4.scm:106]

(hash-u char port)
Reader extension for #u8(), #u16(), #u32() and #u64() vectors.
[srfi/srfi-4.scm:130]

(hash-s char port)
Reader extension for #s8(), #s16(), #s32() and #s64() vectors.
[srfi/srfi-4.scm:164]

(string-any pred s [start [end]])
Check if the predicate @var{pred} is true for any character in
the string @var{s}, proceeding from left (index @var{start}) to
right (index @var{end}).  If @code{string-any} returns true,
the returned true value is the one produced by the first
successful application of @var{pred}.
[srfi/srfi-13.c:72]

(string-every pred s [start [end]])
Check if the predicate @var{pred} is true for every character
in the string @var{s}, proceeding from left (index @var{start})
to right (index @var{end}).  If @code{string-every} returns
true, the returned true value is the one produced by the final
application of @var{pred} to the last character of @var{s}.
[srfi/srfi-13.c:103]

(string-tabulate proc len)
@var{proc} is an integer->char procedure.  Construct a string
of size @var{len} by applying @var{proc} to each index to
produce the corresponding string element.  The order in which
@var{proc} is applied to the indices is not specified.
[srfi/srfi-13.c:134]

(string->list str [start [end]])
Convert the string @var{str} into a list of characters.
[srfi/srfi-13.c:164]

(reverse-list->string chrs)
An efficient implementation of @code{(compose string->list
reverse)}:

@smalllisp
(reverse-list->string '(#\a #\B #\c)) @result{} "cBa"
@end smalllisp
[srfi/srfi-13.c:190]

(string-join ls [delimiter [grammar]])
Append the string in the string list @var{ls}, using the string
@var{delim} as a delimiter between the elements of @var{ls}.
@var{grammar} is a symbol which specifies how the delimiter is
placed between the strings, and defaults to the symbol
@code{infix}.

@table @code
@item infix
Insert the separator between list elements.  An empty string
will produce an empty list.
@item string-infix
Like @code{infix}, but will raise an error if given the empty
list.
@item suffix
Insert the separator after every list element.
@item prefix
Insert the separator before each list element.
@end table
[srfi/srfi-13.c:242]

(string-copy str [start [end]])
Return a freshly allocated copy of the string @var{str}.  If
given, @var{start} and @var{end} delimit the portion of
@var{str} which is copied.
[srfi/srfi-13.c:384]

(substring/shared str start [end])
Like @code{substring}, but the result may share memory with the
argument @var{str}.
[srfi/srfi-13.c:402]

(string-copy! target tstart s [start [end]])
Copy the sequence of characters from index range [@var{start},
@var{end}) in string @var{s} to string @var{target}, beginning
at index @var{tstart}.  The characters are copied left-to-right
or right-to-left as needed -- the copy is guaranteed to work,
even if @var{target} and @var{s} are the same string.  It is an
error if the copy operation runs off the end of the target
string.
[srfi/srfi-13.c:427]

(string-take s n)
Return the @var{n} first characters of @var{s}.
[srfi/srfi-13.c:454]

(string-drop s n)
Return all but the first @var{n} characters of @var{s}.
[srfi/srfi-13.c:471]

(string-take-right s n)
Return the @var{n} last characters of @var{s}.
[srfi/srfi-13.c:488]

(string-drop-right s n)
Return all but the last @var{n} characters of @var{s}.
[srfi/srfi-13.c:505]

(string-pad s len [chr [start [end]]])
Take characters from @var{start} to @var{end} from the
string @var{s} and return a new string, right-padded by the
character @var{chr} to length @var{len}.  If the resulting
string is longer than @var{len}, it is truncated on the right.
[srfi/srfi-13.c:525]

(string-pad-right s len [chr [start [end]]])
Take characters from @var{start} to @var{end} from the
string @var{s} and return a new string, left-padded by the
character @var{chr} to length @var{len}.  If the resulting
string is longer than @var{len}, it is truncated on the left.
[srfi/srfi-13.c:567]

(string-trim s [char_pred [start [end]]])
Trim @var{s} by skipping over all characters on the left
that satisfy the parameter @var{char_pred}:

@itemize @bullet
@item
if it is the character @var{ch}, characters equal to
@var{ch} are trimmed,

@item
if it is a procedure @var{pred} characters that
satisfy @var{pred} are trimmed,

@item
if it is a character set, characters in that set are trimmed.
@end itemize

If called without a @var{char_pred} argument, all whitespace is
trimmed.
[srfi/srfi-13.c:620]

(string-trim-right s [char_pred [start [end]]])
Trim @var{s} by skipping over all characters on the rightt
that satisfy the parameter @var{char_pred}:

@itemize @bullet
@item
if it is the character @var{ch}, characters equal to @var{ch}
are trimmed,

@item
if it is a procedure @var{pred} characters that satisfy
@var{pred} are trimmed,

@item
if it is a character sets, all characters in that set are
trimmed.
@end itemize

If called without a @var{char_pred} argument, all whitespace is
trimmed.
[srfi/srfi-13.c:695]

(string-trim-both s [char_pred [start [end]]])
Trim @var{s} by skipping over all characters on both sides of
the string that satisfy the parameter @var{char_pred}:

@itemize @bullet
@item
if it is the character @var{ch}, characters equal to @var{ch}
are trimmed,

@item
if it is a procedure @var{pred} characters that satisfy
@var{pred} are trimmed,

@item
if it is a character set, the characters in the set are
trimmed.
@end itemize

If called without a @var{char_pred} argument, all whitespace is
trimmed.
[srfi/srfi-13.c:770]

(string-fill! str chr [start [end]])
Store @var{chr} in every element of the given @var{str}.
The return value is unspecified.
[srfi/srfi-13.c:855]

(string-compare s1 s2 proc_lt proc_eq proc_gt [start1 [end1 [start2 [end2]]]])
Apply @var{proc_lt}, @var{proc_eq}, @var{proc_gt} to the
mismatch index, depending upon whether @var{s1} is less than,
equal to, or greater than @var{s2}.  The mismatch index is the
largest index @var{i} such that for every 0 <= @var{j} <
@var{i}, @var{s1}[@var{j}] = @var{s2}[@var{j}] -- that is,
@var{i} is the first position that does not match.
[srfi/srfi-13.c:881]

(string-compare-ci s1 s2 proc_lt proc_eq proc_gt [start1 [end1 [start2 [end2]]]])
Apply @var{proc_lt}, @var{proc_eq}, @var{proc_gt} to the
mismatch index, depending upon whether @var{s1} is less than,
equal to, or greater than @var{s2}.  The mismatch index is the
largest index @var{i} such that for every 0 <= @var{j} <
@var{i}, @var{s1}[@var{j}] = @var{s2}[@var{j}] -- that is,
@var{i} is the first position that does not match.  The
character comparison is done case-insensitively.
[srfi/srfi-13.c:924]

(string= s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} and @var{s2} are not equal, a true
value otherwise.
[srfi/srfi-13.c:962]

(string<> s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} and @var{s2} are equal, a true
value otherwise.
[srfi/srfi-13.c:997]

(string< s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} is greater or equal to @var{s2}, a
true value otherwise.
[srfi/srfi-13.c:1032]

(string> s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} is less or equal to @var{s2}, a
true value otherwise.
[srfi/srfi-13.c:1067]

(string<= s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} is greater to @var{s2}, a true
value otherwise.
[srfi/srfi-13.c:1102]

(string>= s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} is less to @var{s2}, a true value
otherwise.
[srfi/srfi-13.c:1137]

(string-ci= s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} and @var{s2} are not equal, a true
value otherwise.  The character comparison is done
case-insensitively.
[srfi/srfi-13.c:1173]

(string-ci<> s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} and @var{s2} are equal, a true
value otherwise.  The character comparison is done
case-insensitively.
[srfi/srfi-13.c:1209]

(string-ci< s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} is greater or equal to @var{s2}, a
true value otherwise.  The character comparison is done
case-insensitively.
[srfi/srfi-13.c:1245]

(string-ci> s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} is less or equal to @var{s2}, a
true value otherwise.  The character comparison is done
case-insensitively.
[srfi/srfi-13.c:1281]

(string-ci<= s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} is greater to @var{s2}, a true
value otherwise.  The character comparison is done
case-insensitively.
[srfi/srfi-13.c:1317]

(string-ci>= s1 s2 [start1 [end1 [start2 [end2]]]])
Return @code{#f} if @var{s1} is less to @var{s2}, a true value
otherwise.  The character comparison is done
case-insensitively.
[srfi/srfi-13.c:1353]

(string-prefix-length s1 s2 [start1 [end1 [start2 [end2]]]])
Return the length of the longest common prefix of the two
strings.
[srfi/srfi-13.c:1388]

(string-prefix-length-ci s1 s2 [start1 [end1 [start2 [end2]]]])
Return the length of the longest common prefix of the two
strings, ignoring character case.
[srfi/srfi-13.c:1417]

(string-suffix-length s1 s2 [start1 [end1 [start2 [end2]]]])
Return the length of the longest common suffix of the two
strings.
[srfi/srfi-13.c:1446]

(string-suffix-length-ci s1 s2 [start1 [end1 [start2 [end2]]]])
Return the length of the longest common suffix of the two
strings, ignoring character case.
[srfi/srfi-13.c:1475]

(string-prefix? s1 s2 [start1 [end1 [start2 [end2]]]])
Is @var{s1} a prefix of @var{s2}?
[srfi/srfi-13.c:1503]

(string-prefix-ci? s1 s2 [start1 [end1 [start2 [end2]]]])
Is @var{s1} a prefix of @var{s2}, ignoring character case?
[srfi/srfi-13.c:1532]

(string-suffix? s1 s2 [start1 [end1 [start2 [end2]]]])
Is @var{s1} a suffix of @var{s2}?
[srfi/srfi-13.c:1561]

(string-suffix-ci? s1 s2 [start1 [end1 [start2 [end2]]]])
Is @var{s1} a suffix of @var{s2}, ignoring character case?
[srfi/srfi-13.c:1590]

(string-index s char_pred [start [end]])
Search through the string @var{s} from left to right, returning
the index of the first occurence of a character which

@itemize @bullet
@item
equals @var{char_pred}, if it is character,

@item
satisifies the predicate @var{char_pred}, if it is a procedure,

@item
is in the set @var{char_pred}, if it is a character set.
@end itemize
[srfi/srfi-13.c:1633]

(string-index-right s char_pred [start [end]])
Search through the string @var{s} from right to left, returning
the index of the last occurence of a character which

@itemize @bullet
@item
equals @var{char_pred}, if it is character,

@item
satisifies the predicate @var{char_pred}, if it is a procedure,

@item
is in the set if @var{char_pred} is a character set.
@end itemize
[srfi/srfi-13.c:1692]

(string-skip s char_pred [start [end]])
Search through the string @var{s} from left to right, returning
the index of the first occurence of a character which

@itemize @bullet
@item
does not equal @var{char_pred}, if it is character,

@item
does not satisify the predicate @var{char_pred}, if it is a
procedure,

@item
is not in the set if @var{char_pred} is a character set.
@end itemize
[srfi/srfi-13.c:1752]

(string-skip-right s char_pred [start [end]])
Search through the string @var{s} from right to left, returning
the index of the last occurence of a character which

@itemize @bullet
@item
does not equal @var{char_pred}, if it is character,

@item
does not satisifie the predicate @var{char_pred}, if it is a
procedure,

@item
is not in the set if @var{char_pred} is a character set.
@end itemize
[srfi/srfi-13.c:1812]

(string-count s char_pred [start [end]])
Return the count of the number of characters in the string
@var{s} which

@itemize @bullet
@item
equals @var{char_pred}, if it is character,

@item
satisifies the predicate @var{char_pred}, if it is a procedure.

@item
is in the set @var{char_pred}, if it is a character set.
@end itemize
[srfi/srfi-13.c:1871]

(string-contains s1 s2 [start1 [end1 [start2 [end2]]]])
Does string @var{s1} contain string @var{s2}?  Return the index
in @var{s1} where @var{s2} occurs as a substring, or false.
The optional start/end indices restrict the operation to the
indicated substrings.
[srfi/srfi-13.c:1925]

(string-contains-ci s1 s2 [start1 [end1 [start2 [end2]]]])
Does string @var{s1} contain string @var{s2}?  Return the index
in @var{s1} where @var{s2} occurs as a substring, or false.
The optional start/end indices restrict the operation to the
indicated substrings.  Character comparison is done
case-insensitively.
[srfi/srfi-13.c:1966]

(string-upcase! str [start [end]])
Destructively upcase every character in @code{str}.

@lisp
(string-upcase! y)
@result{} "ARRDEFG"
y
@result{} "ARRDEFG"
@end lisp
[srfi/srfi-13.c:2024]

(string-upcase str [start [end]])
Upcase every character in @code{str}.
[srfi/srfi-13.c:2042]

(string-downcase! str [start [end]])
Destructively downcase every character in @var{str}.

@lisp
y
@result{} "ARRDEFG"
(string-downcase! y)
@result{} "arrdefg"
y
@result{} "arrdefg"
@end lisp
[srfi/srfi-13.c:2083]

(string-downcase str [start [end]])
Downcase every character in @var{str}.
[srfi/srfi-13.c:2101]

(string-titlecase! str [start [end]])
Destructively titlecase every first character in a word in
@var{str}.
[srfi/srfi-13.c:2148]

(string-titlecase str [start [end]])
Titlecase every first character in a word in @var{str}.
[srfi/srfi-13.c:2164]

(string-reverse str [start [end]])
Reverse the string @var{str}.  The optional arguments
@var{start} and @var{end} delimit the region of @var{str} to
operate on.
[srfi/srfi-13.c:2201]

(string-reverse! str [start [end]])
Reverse the string @var{str} in-place.  The optional arguments
@var{start} and @var{end} delimit the region of @var{str} to
operate on.  The return value is unspecified.
[srfi/srfi-13.c:2223]

(string-append/shared [ls ...])
Like @code{string-append}, but the result may share memory
with the argument strings.
[srfi/srfi-13.c:2242]

(string-concatenate ls)
Append the elements of @var{ls} (which must be strings)
together into a single string.  Guaranteed to return a freshly
allocated string.
[srfi/srfi-13.c:2263]

(string-concatenate-reverse ls [final_string [end]])
Without optional arguments, this procedure is equivalent to

@smalllisp
(string-concatenate (reverse ls))
@end smalllisp

If the optional argument @var{final_string} is specified, it is
consed onto the beginning to @var{ls} before performing the
list-reverse and string-concatenate operations.  If @var{end}
is given, only the characters of @var{final_string} up to index
@var{end} are used.

Guaranteed to return a freshly allocated string.
[srfi/srfi-13.c:2316]

(string-concatenate/shared ls)
Like @code{string-concatenate}, but the result may share memory
with the strings in the list @var{ls}.
[srfi/srfi-13.c:2386]

(string-concatenate-reverse/shared ls [final_string [end]])
Like @code{string-concatenate-reverse}, but the result may
share memory with the the strings in the @var{ls} arguments.
[srfi/srfi-13.c:2404]

(string-map proc s [start [end]])
@var{proc} is a char->char procedure, it is mapped over
@var{s}.  The order in which the procedure is applied to the
string elements is not specified.
[srfi/srfi-13.c:2417]

(string-map! proc s [start [end]])
@var{proc} is a char->char procedure, it is mapped over
@var{s}.  The order in which the procedure is applied to the
string elements is not specified.  The string @var{s} is
modified in-place, the return value is not specified.
[srfi/srfi-13.c:2448]

(string-fold kons knil s [start [end]])
Fold @var{kons} over the characters of @var{s}, with @var{knil}
as the terminating element, from left to right.  @var{kons}
must expect two arguments: The actual character and the last
result of @var{kons}' application.
[srfi/srfi-13.c:2477]

(string-fold-right kons knil s [start [end]])
Fold @var{kons} over the characters of @var{s}, with @var{knil}
as the terminating element, from right to left.  @var{kons}
must expect two arguments: The actual character and the last
result of @var{kons}' application.
[srfi/srfi-13.c:2504]

(string-unfold p f g seed [base [make_final]])
@itemize @bullet
@item @var{g} is used to generate a series of @emph{seed}
values from the initial @var{seed}: @var{seed}, (@var{g}
@var{seed}), (@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}),
@dots{}
@item @var{p} tells us when to stop -- when it returns true
when applied to one of these seed values.
@item @var{f} maps each seed value to the corresponding
character in the result string.  These chars are assembled
into the string in a left-to-right order.
@item @var{base} is the optional initial/leftmost portion
of the constructed string; it default to the empty
string.
@item @var{make_final} is applied to the terminal seed
value (on which @var{p} returns true) to produce
the final/rightmost portion of the constructed string.
It defaults to @code{(lambda (x) )}.
@end itemize
[srfi/srfi-13.c:2545]

(string-unfold-right p f g seed [base [make_final]])
@itemize @bullet
@item @var{g} is used to generate a series of @emph{seed}
values from the initial @var{seed}: @var{seed}, (@var{g}
@var{seed}), (@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}),
@dots{}
@item @var{p} tells us when to stop -- when it returns true
when applied to one of these seed values.
@item @var{f} maps each seed value to the corresponding
character in the result string.  These chars are assembled
into the string in a right-to-left order.
@item @var{base} is the optional initial/rightmost portion
of the constructed string; it default to the empty
string.
@item @var{make_final} is applied to the terminal seed
value (on which @var{p} returns true) to produce
the final/leftmost portion of the constructed string.
It defaults to @code{(lambda (x) )}.
@end itemize
[srfi/srfi-13.c:2607]

(string-for-each proc s [start [end]])
@var{proc} is mapped over @var{s} in left-to-right order.  The
return value is not specified.
[srfi/srfi-13.c:2653]

(string-for-each-index proc s [start [end]])
@var{proc} is mapped over @var{s} in left-to-right order.  The
return value is not specified.
[srfi/srfi-13.c:2675]

(xsubstring s from [to [start [end]]])
This is the @emph{extended substring} procedure that implements
replicated copying of a substring of some string.

@var{s} is a string, @var{start} and @var{end} are optional
arguments that demarcate a substring of @var{s}, defaulting to
0 and the length of @var{s}.  Replicate this substring up and
down index space, in both the positive and negative directions.
@code{xsubstring} returns the substring of this string
beginning at index @var{from}, and ending at @var{to}, which
defaults to @var{from} + (@var{end} - @var{start}).
[srfi/srfi-13.c:2705]

(string-xcopy! target tstart s sfrom [sto [start [end]]])
Exactly the same as @code{xsubstring}, but the extracted text
is written into the string @var{target} starting at index
@var{tstart}.  The operation is not defined if @code{(eq?
@var{target} @var{s})} or these arguments share storage -- you
cannot copy a string on top of itself.
[srfi/srfi-13.c:2744]

(string-replace s1 s2 [start1 [end1 [start2 [end2]]]])
Return the string @var{s1}, but with the characters
@var{start1} @dots{} @var{end1} replaced by the characters
@var{start2} @dots{} @var{end2} from @var{s2}.
[srfi/srfi-13.c:2785]

(string-tokenize s [token_set [start [end]]])
Split the string @var{s} into a list of substrings, where each
substring is a maximal non-empty contiguous sequence of
characters from the character set @var{token_set}, which
defaults to @code{char-set:graphic} from module (srfi srfi-14).
If @var{start} or @var{end} indices are provided, they restrict
@code{string-tokenize} to operating on the indicated substring
of @var{s}.
[srfi/srfi-13.c:2819]

(string-filter s char_pred [start [end]])
Filter the string @var{s}, retaining only those characters that
satisfy the @var{char_pred} argument.  If the argument is a
procedure, it is applied to each character as a predicate, if
it is a character, it is tested for equality and if it is a
character set, it is tested for membership.
[srfi/srfi-13.c:2878]

(string-delete s char_pred [start [end]])
Filter the string @var{s}, retaining only those characters that
do not satisfy the @var{char_pred} argument.  If the argument
is a procedure, it is applied to each character as a predicate,
if it is a character, it is tested for equality and if it is a
character set, it is tested for membership.
[srfi/srfi-13.c:2944]

(char-set? obj)
Return @code{#t} if @var{obj} is a character set, @code{#f}
otherwise.
[srfi/srfi-14.c:121]

(char-set= [char_sets ...])
Return @code{#t} if all given character sets are equal.
[srfi/srfi-14.c:131]

(char-set<= [char_sets ...])
Return @code{#t} if every character set @var{cs}i is a subset
of character set @var{cs}i+1.
[srfi/srfi-14.c:161]

(char-set-hash cs [bound])
Compute a hash value for the character set @var{cs}.  If
@var{bound} is given and non-zero, it restricts the
returned value to the range 0 @dots{} @var{bound - 1}.
[srfi/srfi-14.c:199]

(char-set-cursor cs)
Return a cursor into the character set @var{cs}.
[srfi/srfi-14.c:232]

(char-set-ref cs cursor)
Return the character at the current cursor position
@var{cursor} in the character set @var{cs}.  It is an error to
pass a cursor for which @code{end-of-char-set?} returns true.
[srfi/srfi-14.c:252]

(char-set-cursor-next cs cursor)
Advance the character set cursor @var{cursor} to the next
character in the character set @var{cs}.  It is an error if the
cursor given satisfies @code{end-of-char-set?}.
[srfi/srfi-14.c:271]

(end-of-char-set? cursor)
Return @code{#t} if @var{cursor} has reached the end of a
character set, @code{#f} otherwise.
[srfi/srfi-14.c:294]

(char-set-fold kons knil cs)
Fold the procedure @var{kons} over the character set @var{cs},
initializing it with @var{knil}.
[srfi/srfi-14.c:308]

(char-set-unfold p f g seed [base_cs])
This is a fundamental constructor for character sets.
@itemize @bullet
@item @var{g} is used to generate a series of ``seed'' values
from the initial seed: @var{seed}, (@var{g} @var{seed}),
(@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}), @dots{}
@item @var{p} tells us when to stop -- when it returns true
when applied to one of the seed values.
@item @var{f} maps each seed value to a character. These
characters are added to the base character set @var{base_cs} to
form the result; @var{base_cs} defaults to the empty set.
@end itemize
[srfi/srfi-14.c:338]

(char-set-unfold! p f g seed base_cs)
This is a fundamental constructor for character sets.
@itemize @bullet
@item @var{g} is used to generate a series of ``seed'' values
from the initial seed: @var{seed}, (@var{g} @var{seed}),
(@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}), @dots{}
@item @var{p} tells us when to stop -- when it returns true
when applied to one of the seed values.
@item @var{f} maps each seed value to a character. These
characters are added to the base character set @var{base_cs} to
form the result; @var{base_cs} defaults to the empty set.
@end itemize
[srfi/srfi-14.c:382]

(char-set-for-each proc cs)
Apply @var{proc} to every character in the character set
@var{cs}.  The return value is not specified.
[srfi/srfi-14.c:411]

(char-set-map proc cs)
Map the procedure @var{proc} over every character in @var{cs}.
@var{proc} must be a character -> character procedure.
[srfi/srfi-14.c:430]

(char-set-copy cs)
Return a newly allocated character set containing all
characters in @var{cs}.
[srfi/srfi-14.c:456]

(char-set [rest ...])
Return a character set containing all given characters.
[srfi/srfi-14.c:476]

(list->char-set list [base_cs])
Convert the character list @var{list} to a character set.  If
the character set @var{base_cs} is given, the character in this
set are also included in the result.
[srfi/srfi-14.c:504]

(list->char-set! list base_cs)
Convert the character list @var{list} to a character set.  The
characters are added to @var{base_cs} and @var{base_cs} is
returned.
[srfi/srfi-14.c:538]

(string->char-set str [base_cs])
Convert the string @var{str} to a character set.  If the
character set @var{base_cs} is given, the characters in this
set are also included in the result.
[srfi/srfi-14.c:565]

(string->char-set! str base_cs)
Convert the string @var{str} to a character set.  The
characters from the string are added to @var{base_cs}, and
@var{base_cs} is returned.
[srfi/srfi-14.c:597]

(char-set-filter pred cs [base_cs])
Return a character set containing every character from @var{cs}
so that it satisfies @var{pred}.  If provided, the characters
from @var{base_cs} are added to the result.
[srfi/srfi-14.c:622]

(char-set-filter! pred cs base_cs)
Return a character set containing every character from @var{cs}
so that it satisfies @var{pred}.  The characters are added to
@var{base_cs} and @var{base_cs} is returned.
[srfi/srfi-14.c:658]

(ucs-range->char-set lower upper [error [base_cs]])
Return a character set containing all characters whose
character codes lie in the half-open range
[@var{lower},@var{upper}).

If @var{error} is a true value, an error is signalled if the
specified range contains characters which are not contained in
the implemented character range.  If @var{error} is @code{#f},
these characters are silently left out of the resultung
character set.

The characters in @var{base_cs} are added to the result, if
given.
[srfi/srfi-14.c:696]

(ucs-range->char-set! lower upper error base_cs)
Return a character set containing all characters whose
character codes lie in the half-open range
[@var{lower},@var{upper}).

If @var{error} is a true value, an error is signalled if the
specified range contains characters which are not contained in
the implemented character range.  If @var{error} is @code{#f},
these characters are silently left out of the resultung
character set.

The characters are added to @var{base_cs} and @var{base_cs} is
returned.
[srfi/srfi-14.c:750]

(char-set-size cs)
Return the number of elements in character set @var{cs}.
[srfi/srfi-14.c:782]

(char-set-count pred cs)
Return the number of the elements int the character set
@var{cs} which satisfy the predicate @var{pred}.
[srfi/srfi-14.c:799]

(char-set->list cs)
Return a list containing the elements of the character set
@var{cs}.
[srfi/srfi-14.c:822]

(char-set->string cs)
Return a string containing the elements of the character set
@var{cs}.  The order in which the characters are placed in the
string is not defined.
[srfi/srfi-14.c:841]

(char-set-contains? cs ch)
Return @code{#t} iff the character @var{ch} is contained in the
character set @var{cs}.
[srfi/srfi-14.c:867]

(char-set-every pred cs)
Return a true value if every character in the character set
@var{cs} satisfies the predicate @var{pred}.
[srfi/srfi-14.c:880]

(char-set-any pred cs)
Return a true value if any character in the character set
@var{cs} satisfies the predicate @var{pred}.
[srfi/srfi-14.c:904]

(char-set-adjoin cs [rest ...])
Add all character arguments to the first argument, which must
be a character set.
[srfi/srfi-14.c:927]

(char-set-delete cs [rest ...])
Delete all character arguments from the first argument, which
must be a character set.
[srfi/srfi-14.c:955]

(char-set-adjoin! cs [rest ...])
Add all character arguments to the first argument, which must
be a character set.
[srfi/srfi-14.c:983]

(char-set-delete! cs [rest ...])
Delete all character arguments from the first argument, which
must be a character set.
[srfi/srfi-14.c:1010]

(char-set-complement cs)
Return the complement of the character set @var{cs}.
[srfi/srfi-14.c:1036]

(char-set-union [rest ...])
Return the union of all argument character sets.
[srfi/srfi-14.c:1057]

(char-set-intersection [rest ...])
Return the intersection of all argument character sets.
[srfi/srfi-14.c:1086]

(char-set-difference cs1 [rest ...])
Return the difference of all argument character sets.
[srfi/srfi-14.c:1126]

(char-set-xor [rest ...])
Return the exclusive-or of all argument character sets.
[srfi/srfi-14.c:1156]

(char-set-diff+intersection cs1 [rest ...])
Return the difference and the intersection of all argument
character sets.
[srfi/srfi-14.c:1197]

(char-set-complement! cs)
Return the complement of the character set @var{cs}.
[srfi/srfi-14.c:1235]

(char-set-union! cs1 [rest ...])
Return the union of all argument character sets.
[srfi/srfi-14.c:1252]

(char-set-intersection! cs1 [rest ...])
Return the intersection of all argument character sets.
[srfi/srfi-14.c:1280]

(char-set-difference! cs1 [rest ...])
Return the difference of all argument character sets.
[srfi/srfi-14.c:1308]

(char-set-xor! cs1 [rest ...])
Return the exclusive-or of all argument character sets.
[srfi/srfi-14.c:1336]

(char-set-diff+intersection! cs1 cs2 [rest ...])
Return the difference and the intersection of all argument
character sets.
[srfi/srfi-14.c:1375]

(u8vector? obj)
Return @code{#t} if @var{obj} is a vector of type u8,
@code{#f} otherwise.
[srfi/srfi-4.c:434]

(make-u8vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:448]

(u8vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:478]

(u8vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:490]

(u8vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:502]

(u8vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:519]

(u8vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:542]

(list->u8vector l)
Convert the list @var{l}, which must only contain unsigned
8-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:565]

(s8vector? obj)
Return @code{#t} if @var{obj} is a vector of type s8,
@code{#f} otherwise.
[srfi/srfi-4.c:604]

(make-s8vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:618]

(s8vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:648]

(s8vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:660]

(s8vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:672]

(s8vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:689]

(s8vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:712]

(list->s8vector l)
Convert the list @var{l}, which must only contain signed
8-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:735]

(u16vector? obj)
Return @code{#t} if @var{obj} is a vector of type u16,
@code{#f} otherwise.
[srfi/srfi-4.c:776]

(make-u16vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:790]

(u16vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:815]

(u16vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:827]

(u16vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:839]

(u16vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:856]

(u16vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:875]

(list->u16vector l)
Convert the list @var{l}, which must only contain unsigned
16-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:898]

(s16vector? obj)
Return @code{#t} if @var{obj} is a vector of type s16,
@code{#f} otherwise.
[srfi/srfi-4.c:930]

(make-s16vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:944]

(s16vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:969]

(s16vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:981]

(s16vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:993]

(s16vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:1010]

(s16vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:1029]

(list->s16vector l)
Convert the list @var{l}, which must only contain signed
16-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:1052]

(u32vector? obj)
Return @code{#t} if @var{obj} is a vector of type u32,
@code{#f} otherwise.
[srfi/srfi-4.c:1087]

(make-u32vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:1101]

(u32vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:1126]

(u32vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:1138]

(u32vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:1150]

(u32vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:1167]

(u32vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:1186]

(list->u32vector l)
Convert the list @var{l}, which must only contain unsigned
32-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:1209]

(s32vector? obj)
Return @code{#t} if @var{obj} is a vector of type s32,
@code{#f} otherwise.
[srfi/srfi-4.c:1242]

(make-s32vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:1256]

(s32vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:1281]

(s32vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:1293]

(s32vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:1305]

(s32vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:1322]

(s32vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:1341]

(list->s32vector l)
Convert the list @var{l}, which must only contain signed
32-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:1364]

(u64vector? obj)
Return @code{#t} if @var{obj} is a vector of type u64,
@code{#f} otherwise.
[srfi/srfi-4.c:1399]

(make-u64vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:1413]

(u64vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:1438]

(u64vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:1450]

(u64vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:1462]

(u64vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:1479]

(u64vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:1498]

(list->u64vector l)
Convert the list @var{l}, which must only contain unsigned
64-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:1521]

(s64vector? obj)
Return @code{#t} if @var{obj} is a vector of type s64,
@code{#f} otherwise.
[srfi/srfi-4.c:1554]

(make-s64vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:1568]

(s64vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:1593]

(s64vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:1605]

(s64vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:1617]

(s64vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:1634]

(s64vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:1653]

(list->s64vector l)
Convert the list @var{l}, which must only contain signed
64-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:1676]

(f32vector? obj)
Return @code{#t} if @var{obj} is a vector of type f32,
@code{#f} otherwise.
[srfi/srfi-4.c:1711]

(make-f32vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:1725]

(f32vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:1759]

(f32vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:1771]

(f32vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:1783]

(f32vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:1800]

(f32vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:1827]

(list->f32vector l)
Convert the list @var{l}, which must only contain unsigned
8-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:1850]

(f64vector? obj)
Return @code{#t} if @var{obj} is a vector of type f64,
@code{#f} otherwise.
[srfi/srfi-4.c:1891]

(make-f64vector n [fill])
Create a newly allocated homogeneous numeric vector which can
hold @var{len} elements.  If @var{fill} is given, it is used to
initialize the elements, otherwise the contents of the vector
is unspecified.
[srfi/srfi-4.c:1905]

(f64vector [l ...])
Create a newly allocated homogeneous numeric vector containing
all argument values.
[srfi/srfi-4.c:1930]

(f64vector-length uvec)
Return the number of elements in the homogeneous numeric vector
@var{uvec}.
[srfi/srfi-4.c:1942]

(f64vector-ref uvec index)
Return the element at @var{index} in the homogeneous numeric
vector @var{uvec}.
[srfi/srfi-4.c:1954]

(f64vector-set! uvec index value)
Set the element at @var{index} in the homogeneous numeric
vector @var{uvec} to @var{value}.  The return value is not
specified.
[srfi/srfi-4.c:1971]

(f64vector->list uvec)
Convert the homogeneous numeric vector @var{uvec} to a list.
[srfi/srfi-4.c:1990]

(list->f64vector l)
Convert the list @var{l}, which must only contain signed
8-bit values, to a numeric homogeneous vector.
[srfi/srfi-4.c:2013]

(binary-port? obj)
Return #t if @var{obj} is a port that supports
binary operations.
[srfi/srfi-56.c:107]

(character-port? obj)
Return #t if @var{obj} is a port that supports
character operations.
[srfi/srfi-56.c:122]

(open-binary-input-file filename)
Return an input port for @var{filename} such that @code{binary-port?}
applied to it returns #t.
[srfi/srfi-56.c:131]

(open-binary-output-file filename)
Return an output port for @var{filename} such that @code{binary-port?}
applied to it returns #t.
[srfi/srfi-56.c:142]

(call-with-binary-input-file filename proc)
Open binary input port to @var{filename} and call @var{proc} with it.
[srfi/srfi-56.c:152]

(call-with-binary-output-file filename proc)
Open binary output port to @var{filename} and call @var{proc} with it.
[srfi/srfi-56.c:164]

(with-input-from-binary-file filename thunk)
Arrange for input to be read from a binary port open on @var{filename}.
Call @var{thunk}.
[srfi/srfi-56.c:177]

(with-output-to-binary-file filename thunk)
Arrange for output to be written to a binary port open on @var{filename}.
Call @var{thunk}.
[srfi/srfi-56.c:198]

(read-byte [port])
Read a byte from the current input port.
Return an integer between 0-255, or the EOF object.
Optional arg @var{port} specifies the port to read from.
[srfi/srfi-56.c:223]

(write-byte n [port])
Write byte @var{n} in range 0-255 to current output port.
Optional arg @var{port} specifies the port to write to.
[srfi/srfi-56.c:240]

(peek-byte [port])
Return the next byte available from the current input port.
Optional arg @var{port} specifies a port to check, instead.
If no bytes are available, return the eof object.
[srfi/srfi-56.c:265]

(byte-ready? [port])
Return #t if reading from the current input port would produce a byte.
Optional arg @var{port} specifies a port to check, instead.
[srfi/srfi-56.c:283]

(default-endian)
Return either @code{big-endian} or @code{little-endian} (a symbol).
[srfi/srfi-56.c:330]

(read-binary-uint size [port [endian]])
Read an unsigned integer of @var{size} bytes from the current input port.
Optional second arg @var{port} specifies the port to read, instead.
Optional third arg @var{endian} is either `big-endian' or `little-endian'
(a symbol).  If fewer than @var{size} bytes are available in the port,
return the eof object.
[srfi/srfi-56.c:368]

(read-binary-sint size [port [endian]])
Read a signed integer of @var{size} bytes from the current input port.
Optional second arg @var{port} specifies the port to read, instead.
Optional third arg @var{endian} is either `big-endian' or `little-endian'
(a symbol).  If fewer than @var{size} bytes are available in the port,
return the eof object.
[srfi/srfi-56.c:413]

(read-binary-uint8 [port [endian]])
Read an unsigned integer of one byte from the current input port.
Optional arg @var{port} specifies a port to read from, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:481]

(read-binary-uint16 [port [endian]])
Read an unsigned integer of two bytes from the current input port.
Optional arg @var{port} specifies a port to read from, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:494]

(read-binary-uint32 [port [endian]])
Read an unsigned integer of four bytes from the current input port.
Optional arg @var{port} specifies a port to read from, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:507]

(read-binary-uint64 [port [endian]])
Read an unsigned integer of eight bytes from the current input port.
Optional arg @var{port} specifies a port to read from, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:520]

(read-binary-sint8 [port [endian]])
Read a signed integer of one byte from the current input port.
Optional arg @var{port} specifies the port to read, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:533]

(read-binary-sint16 [port [endian]])
Read a signed integer of two bytes from the current input port.
Optional arg @var{port} specifies the port to read, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:546]

(read-binary-sint32 [port [endian]])
Read a signed integer of four bytes from the current input port.
Optional arg @var{port} specifies the port to read, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:559]

(read-binary-sint64 [port [endian]])
Read a signed integer of eight bytes from the current input port.
Optional arg @var{port} specifies the port to read, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:572]

(write-binary-uint size n [port [endian]])
Write @var{size} bytes to the current output port representing unsigned
integer @var{n}.  Signal error if @var{n} is negative.
Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:588]

(write-binary-sint size n [port [endian]])
Write @var{size} bytes to the current output port representing signed
integer @var{n}.  Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:633]

(write-binary-uint8 n [port [endian]])
Write one byte to the current output port representing unsigned
integer @var{n}.  Signal error if @var{n} is negative.
Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:663]

(write-binary-uint16 n [port [endian]])
Write two bytes to the current output port representing unsigned
integer @var{n}.  Signal error if @var{n} is negative.
Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:676]

(write-binary-uint32 n [port [endian]])
Write four bytes to the current output port representing unsigned
integer @var{n}.  Signal error if @var{n} is negative.
Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:690]

(write-binary-uint64 n [port [endian]])
Write eight bytes to the current output port representing unsigned
integer @var{n}.  Signal error if @var{n} is negative.
Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:703]

(write-binary-sint8 n [port [endian]])
Write one byte to the current output port representing signed
integer @var{n}.  Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:715]

(write-binary-sint16 n [port [endian]])
Write two bytes to the current output port representing signed
integer @var{n}.  Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:727]

(write-binary-sint32 n [port [endian]])
Write four bytes to the current output port representing signed
integer @var{n}.  Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:739]

(write-binary-sint64 n [port [endian]])
Write eight bytes to the current output port representing signed
integer @var{n}.  Optional third arg @var{port} specifies a port to write
to, instead.  Optional fourth arg @var{endian} is an endian symbol.
[srfi/srfi-56.c:751]

(read-network-uint16 [port])
Read two bytes in network byte order from the current input port.
Return an unsigned integer.
Optional arg @var{port} specifies a port to read from, instead.
[srfi/srfi-56.c:766]

(read-network-uint32 [port])
Read four bytes in network byte order from the current input port.
Return an unsigned integer.
Optional arg @var{port} specifies a port to read from, instead.
[srfi/srfi-56.c:778]

(read-network-uint64 [port])
Read eight bytes in network byte order from the current input port.
Return an unsigned integer.
Optional arg @var{port} specifies a port to read from, instead.
[srfi/srfi-56.c:790]

(read-network-sint16 [port])
Read two bytes in network byte order from the current input port.
Return a signed integer.
Optional arg @var{port} specifies a port to read from, instead.
[srfi/srfi-56.c:802]

(read-network-sint32 [port])
Read four bytes in network byte order from the current input port.
Return a signed integer.
Optional arg @var{port} specifies a port to read from, instead.
[srfi/srfi-56.c:814]

(read-network-sint64 [port])
Read eight bytes in network byte order from the current input port.
Return a signed integer.
Optional arg @var{port} specifies a port to read from, instead.
[srfi/srfi-56.c:826]

(write-network-uint16 n [port])
Write unsigned integer @var{n} as two bytes, in network byte order,
to the current output port.  Signal error if @var{n} is negative.
Optional second arg @var{port} specifies a port to write to, instead.
[srfi/srfi-56.c:838]

(write-network-uint32 n [port])
Write unsigned integer @var{n} as four bytes, in network byte order,
to the current output port.  Signal error if @var{n} is negative.
Optional second arg @var{port} specifies a port to write to, instead.
[srfi/srfi-56.c:850]

(write-network-uint64 n [port])
Write unsigned integer @var{n} as eight bytes, in network byte order,
to the current output port.  Signal error if @var{n} is negative.
Optional second arg @var{port} specifies a port to write to, instead.
[srfi/srfi-56.c:862]

(write-network-sint16 n [port])
Write signed integer @var{n} as two bytes, in network byte order,
to the current output port.  Optional second arg @var{port} specifies
a port to write to, instead.
[srfi/srfi-56.c:874]

(write-network-sint32 n [port])
Write signed integer @var{n} as four bytes, in network byte order,
to the current output port.  Optional second arg @var{port} specifies
a port to write to, instead.
[srfi/srfi-56.c:886]

(write-network-sint64 n [port])
Write signed integer @var{n} as eight bytes, in network byte order,
to the current output port.  Optional second arg @var{port} specifies
a port to write to, instead.
[srfi/srfi-56.c:898]

(read-ber-integer [port])
Read a BER integer from the current input port.
Optional arg @var{port} specifies a port to read from, instead.
[srfi/srfi-56.c:912]

(write-ber-integer n [port])
Write integer @var{n} as a BER integer to the current output port.
Optional arg @var{port} specifies a port to write to, instead.
[srfi/srfi-56.c:939]

(default-float-endian)
Return either @code{big-endian} or @code{little-endian} (a symbol).
[srfi/srfi-56.c:971]

(read-ieee-float32 [port [endian]])
Read an IEEE single-precision float from the current input port.
Optional arg @var{port} specifies a port to read from, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:984]

(read-ieee-float64 [port [endian]])
Read an IEEE double-precision float from the current input port.
Optional arg @var{port} specifies a port to read from, instead.
Optional second arg @var{endian} is a symbol.
Return the eof object if not enough bytes are available.
[srfi/srfi-56.c:1017]

(write-ieee-float32 n [port [endian]])
Write number @var{n} as an IEEE single-precision float to the current
output port.
Optional arg @var{port} specifies a port to write to, instead.
Optional second arg @var{endian} is a symbol.
[srfi/srfi-56.c:1050]

(write-ieee-float64 n [port [endian]])
Write number @var{n} as an IEEE double-precision float to the current
output port.
Optional arg @var{port} specifies a port to write to, instead.
Optional second arg @var{endian} is a symbol.
[srfi/srfi-56.c:1084]

(compiled-regexp? obj)
Return #t iff @var{obj} is a compiled regexp, i.e.,
an object returned by @code{regcomp}.
[rgx/rgx.c:170]

(regcomp pat [cfl])
Compile the regular expression @var{pat} using POSIX rules.
@var{cfl} is optional and should be specified using symbolic
names:

@defvar REG_EXTENDED
use extended POSIX syntax
@end defvar
@defvar REG_ICASE
use case-insensitive matching
@end defvar
@defvar REG_NEWLINE
allow anchors to match after newline characters in the
string and prevents @code{.} or @code{[^...]} from matching
newlines.
@end defvar

The @code{logior} procedure can be used to combine multiple flags.
The default is to use POSIX basic syntax, which makes @code{+}
and @code{?} literals and @code{\+} and @code{\?} operators.
Backslashes in @var{pat} must be escaped if specified in a
literal string e.g., @code{"\(a\)\?"}.
[rgx/rgx.c:199]

(regexec rgx str [match_pick [eflags]])
Match string @var{str} against the compiled POSIX regular
expression @var{rgx}.  @var{match-pick} and @var{eflags} are
optional.  Possible flags (which can be
combined using the @code{logior} procedure) are:

@defvar REG_NOTBOL
The beginning of line operator won't match the beginning of
@var{str} (presumably because it's not the beginning of a line)
@end defvar
@defvar REG_NOTEOL
Similar to REG_NOTBOL, but prevents the end of line operator
from matching the end of @var{str}.
@end defvar

If no match is possible, regexec returns #f.
Otherwise @var{match-pick} determines the return value:

@code{#t} or unspecified: a newly-allocated vector is returned,
containing pairs with the indices of the matched part of
@var{str} and any substrings.

@code{""}: a list is returned: the first element contains a
nested list with the matched part of @var{str} surrounded by
the the unmatched parts.  Remaining elements are matched
substrings (if any).  All returned substrings share memory with
@var{str}.

@code{#f}: regexec returns #t if a match is made, otherwise #f.

vector: the supplied vector is returned, with the first element
replaced by a pair containing the indices of the matched portion
of @var{string} and further elements replaced by pairs containing
the indices of matched substrings (if any).

list: a list will be returned, with each member of the list
specified by a code in the corresponding position of the supplied
list:

a number: the numbered matching substring (0 for the entire
match).

@code{#\<}: the beginning of @var{str} to the beginning of
the part matched by regex.

@code{#\>}: the end of the matched part of @var{str} to the
end of @var{str}.

@code{#\c}: the "final tag", which seems to be associated
with the "cut operator", which doesn't seem to be available
through the posix interface.

e.g., @code{(list #\< 0 1 #\>)}.  The returned substrings
share memory with @var{str}.
[rgx/rgx.c:288]

(regexp->dfa regexp [cfl])
Return a deterministic finite automaton compiled from
regular expression @var{regexp}.  Optional arg @var{cfl} are
flags are one of @code{REG_EXTENDED} or @code{REG_NEWLINE}
(use @code{logior} to combine them).
[rgx/rgx.c:551]

(dfa-fork dfa)
[TODO: Write proper docs for @code{dfa-fork}.]
[rgx/rgx.c:615]

(reset-dfa! dfa)
Reset the deterministic finite automaton @var{dfa}.
[rgx/rgx.c:644]

(dfa-final-tag dfa)
Return the final tag of deterministic finite automaton @var{dfa}.
[rgx/rgx.c:663]

(dfa-continuable? dfa)
Return #t iff the deterministic finite automaton @var{dfa}
is continuable.
[rgx/rgx.c:679]

(advance-dfa! dfa s)
Advance deterministic finite automaton @var{dfa} over
string @var{s}.
[rgx/rgx.c:695]

(pp-lexer-spec spec)
Pretty-print the lexer-spec @var{spec}.
[lang/debug-common.scm:65]

(pp-grammar spec)
Pretty-print the grammar @var{spec}.
[lang/debug-common.scm:82]

(nick obj)
Return the nickname of @var{obj} if available.
If @var{obj} is @code{#f} or the empty list @code{()}, return @var{obj}.
Otherwise, return the memory address of @var{obj} as a hex string.
[lang/debug-common.scm:113]

(nick! obj nick)
Set the nickname for @var{obj} to @var{nick}.
Return @var{obj}.
[lang/debug-common.scm:124]

(production-symbol p)
Return the symbol expanded by a production @var{p}.
[lang/grammar.scm:132]

(production-expansion p)
Return the list of symbols in the expansion of a production @var{p}.
[lang/grammar.scm:137]

(production-body p)
Return the body of a productions reduction procedure
from production @var{p}.
[lang/grammar.scm:143]

(grammar-start-symbol g)
Return the starting symbol of grammar @var{g}.

By convention, the first production determines the start symbol but in
fact, any symbol could be used.  A grammar can have mulitple entry points,
for example.
[lang/grammar.scm:157]

(cache-ref-set! g prop new)
(see Memory Management comment below)
[lang/grammar.scm:162]

(grammar-non-terminals g)
Return the non-terminal symbols of grammar @var{g}.

The list is computed by looking at the lhs of each production.
[lang/grammar.scm:173]

(grammar-terminals g)
Return the list of terminals of grammar @var{g}.

The list is computed by looking at all the symbols
used in expansions, and subtracting out the non-terminals.
[lang/grammar.scm:185]

(grammar-nullables g)
Return those non-terminals of grammar @var{g}
that can derive the empty string.
[lang/grammar.scm:199]

(symbol-productions g nt)
Return the productions in grammar @var{g}
with lhs eq? to non-terminal @var{nt}.
[lang/grammar.scm:223]

(grammar-cache g)
Return the @code{grammar-cache} object property of grammar @var{g}.
[lang/grammar.scm:250]

(lexeme-reader dfa)
Return a procedure that returns a lexeme, according to the @var{dfa}.
The returned proc, let's call it @code{read-lexeme}, has signature:
@smallexample
(read-lexeme [port])
@end smallexample
The rest of this description is about @code{read-lexeme}.

Read a lexeme, as defined by @var{dfa}, from @var{port} or the current input.

@var{dfa} should match an entire lexeme
and nothing more.  @code{read-lexeme} will return:
@smallexample
(<n> <token>)
@end smallexample

where @code{<token>} is a string containing the characters matched, and
@code{<n>} indicates the token type.

A novel regexp operator is particularly important when using this
procedure: the cut operator.

The cut operator, written @samp{[[:cut <n>:]]}, causes immediate termination
of a match.  @code{<n>} must be an integer.  If it is 0, the match fails.
Otherwise, the match succeeds, returning @code{<n>} in the match data.
Using the Scheme procedure @code{regexec}, the match-data selector
@code{#\c} retrieves the cut value.  For example:
@example
(define r (regcomp "if[[:cut 1:]]\\|else[[:cut 2:]]"))

(regexec r "if" '(#\c 0))
@result{} (1 "if")

(regexec r "else" '(#\c 0))
@result{} (2 "else")
@end example

The above examples illustrate how the return value of @code{read-lexeme} is
formed.  Sufficient characters are read to form a match while leaving
one character left over.  The extra character is put back on the
input stream and match-data for @code{(#\c 0)} is returned.

If the end of file is reached before a match is found, then the lexer
should call @code{eof-token} with the string of read-but-yet-unmatched
characters, and return the resulting value.

There are two exceptions to the rule that the lexer will read, then
unread an "extra" character for each lexeme.  The first exception
is if EOF is reached after finding a match, but before reading an
an extra character.  In that case, the match is simply returned.
The second exception is if the cut value of the match is less than
0, the lexeme is immediately returned without reading additional
characters.

Using this interface is quite similar to using the lex language,
except for the handling of illegal (non-lexable) input.  The unix
lexical analyzers are able to report an error as soon as
characters are read which could not possibly begin a lexeme.  This
lexer, on the other hand, naively continues to read characters
until eof is reached.  This reflects a deficiency of the regexec
interface (it has no way to report that not only was no match
found, but no match could be formed by adding more characters).
The work-around is to carefully write "regexp" so that it matches
illegal input and returns such as a distinct token type.  A more
robust (lex-like) solution will eventually be implemented.
[lang/lex.scm:123]

(lexer-regexp-and-handler spec return)
Return a regexp and a procedure suitable for lexing according to
the analyzer specification @var{spec}.  Call @var{return} when done,
like so:
@smallexample
(RETURN regexp handler)
@end smallexample
See @code{make-lexer} for an example of how this is used.
[lang/lex.scm:207]

(make-lexer specification)
Return a lexical analyzer built from @var{specification}.

A lexer is built from a specification that consists of regexps
and actions.  The regexps are listed in order of precedence,
each matching a particular token type.

The actions are either a token-id (a symbol or #f), or a procedure.

If an action is a token-id @code{<i>} then when a matching token is read,
the list @code{(<i> <lexeme>)} is returned (where @code{<lexeme>} is a string
consisting of the matched characters).

If an action is a procedure, the procedure is called with one argument,
the lexeme string.  The return value of the procedure is returned from
the lexer.

Here is a sample specification:
@example
(define ctax-lexer-specification
  `(("[0-9]\\+\\.\\?[0-9]*"          ,(lambda (token)
                                        (list 'number
                                             (number->string token))))
    ("if"                            if)
    ("else"                          else)
    ("while"                         while)
    ("for"                           for)
    ("return"                        return)
    ("do"                            do)
    ("scm"                           scm)
    ("break"                         break)
    ("continue"                      continue)
    ("[a-zA-Z][a-z?!<>=0-9_]*"       ,(lambda (token)
                                        (list 'identifier
                                             (string->symbol token))))
    ("//[^\n]*"                      #f)
    ("[ \t\n]\\+"                    #f)
    ("[^ \t\n]\\+"                   error)))
@end example

WARNING: all lexers should be total -- that is, they must succeed at
dividing all possible input streams into tokens.  No provision is made to
cleanly handle non-matching input.  That's why the example lexer includes
a token type "error" -- to consume non-lexable input until syncronizing
characters (whitespace in this case) are found.

Generally speaking, given a specification, the lexer will return the
longest matching lexeme. If two cases both match, the lexer will use the
one that occurs first in the specification.

The rule that longest matches may be overrided for a particular type of
lexeme by putting the keyword @code{#:shortest} after the action in the lexer
specification.  If such a lexeme type is ever matched, it is returned
immediately without consuming addtional characters to look for a longer
match.
[lang/lex.scm:291]

(eof-token? obj)
Return #t iff @var{obj} is an eof token.
[lang/lex.scm:318]

(eof-token [etc...])
Return a recognizable eof token with @var{etc} information.
You can recognize it as such using procedure @code{eof-token?}.
This procedure will probably be made private in the future.
Do not use it.
[lang/lex.scm:327]

(VALIDATE:production obj)
Check production-specific invariants for @var{obj}.
If there is a problem, signal error with message of the form:
@smallexample
supposed production INVARIANT-ERROR
@end smallexample
where @var{invariant-error} is one of:
@itemize
@item not a list
@item has length not >= 2
@item car not a symbol
@item cadr not a list of symbols
@end itemize
[lang/lr0-debug.scm:113]

(VALIDATE:item obj)
Check item-specific variants for @var{obj}.
If there is a problem, signal error with message of the form:
@smallexample
supposed item INVARIANT-ERROR
@end smallexample
where @var{invariant-error} is one of:
@itemize
@item not a list
@item cdr CDR not a subset of the expansion EXPANSION
@end itemize
[lang/lr0-debug.scm:135]

(VALIDATE:item-set obj)
Check item-set-specific variants for @var{obj}.
If there is a problem, signal error with message of the form:
@smallexample
supposed item-set INVARIANT-ERROR
@end smallexample
where @var{invariant-error} is one of:
@itemize
@item not a list
@end itemize
Additionally, check each member of the item-set with
@code{VALIDATE:item}.
[lang/lr0-debug.scm:163]

(grammar-with-nicknames grammar)
Decorate @var{grammar} productions with nicknames and return it.
For each production, call @code{VALIDATE:production} on it and
then decorate with a string of the form "PRODUCTION-SYMBOL[ADDRESS]".
[lang/lr0-debug.scm:176]

(display-item item)
Display item @var{item} to the current output port.
[lang/lr0-debug.scm:195]

(display-grammar-item-table table)
Display grammar item table @var{table} to the current output port.
[lang/lr0-debug.scm:204]

(display-item-set is)
Display the item-set @var{is} to the current output port.
[lang/lr0-debug.scm:212]

(display-item-set-closure isc)
Display the item-set closure @var{isc} to the current output port.
[lang/lr0-debug.scm:218]

(make-item grammar production pos)
Return an item from GRAMMAR PRODUCTION at a certain position POS.
Note that POS mus be eq? to some tail of the expansion of PRODUCTION
and that PRODUCTION must not share any cons pairs with any other
grammar production.  The returned item is associated with GRAMMAR.
[lang/lr0.scm:196]

(item-production item)
Return the production corresponding to ITEM.
[lang/lr0.scm:202]

(item-position item)
Return the position, a (possibly empty) list, corresponding to ITEM.
This is also known as its "right hand expansion".
[lang/lr0.scm:208]

(grammar-item-table g)
Return the item table for grammar @var{g}, making it if necessary.

Every grammar is given an item table: a vector of all items
associated with the grammar.  An item's position in this table
is called the item's "index".

The extent of the table is tied to the extent of @var{g}, and the
extent of items to the table.  For a given production, and position,
make-item (see below) will always return @code{eq?} items from the
item-table of the grammar.
[lang/lr0.scm:229]

(item-index item)
Return item-index of GRAMMAR item ITEM.
[lang/lr0.scm:248]

(item-set g [items...])
Return an item set built from a GRAMMAR's ITEMS.
The item set has the same extent as GRAMMAR.

Item sets are represented as a (possibly empty) list of items.  Sets
have the property that equal? sets are eq?, and that elements of each
set are ordered from highest-numbered index to lowest.
[lang/lr0.scm:263]

(item-set-union g sets)
Return an item set built from a union of GRAMMAR's item sets SETS.
[lang/lr0.scm:283]

(item-set-start-kernel g)
Return the kernel of the starting superstate for grammar @var{g}.
This is an item-set of sorts.

Only the initial items of start-symbol productions are included in
this set.  Compose with @code{item-set-closure} to also obtain all items
reachable by epsilon transitions.
[lang/lr0.scm:302]

(item-set-successor-kernel g is symbol)
For grammar @var{g}, with item-set @var{is}, shift symbol @var{symbol}
and return the resulting (possibly empty) item-set.

Only the items which are direct successors of items in @var{is} are present
in the successor kernel.  To also include all items reachable by epsilon
transitions, use @code{item-set-closure}.
[lang/lr0.scm:315]

(item-set-reductions g is)
For grammar @var{g}, return the (possibly empty) set of all productions
that can be reduced from item-set @var{is}, disregarding the context and
look-ahead.
[lang/lr0.scm:329]

(item-closure g it)
Compute the partial epsilon transition closure for a GRAMMAR's ITEM.
This is used by `item-set-closure', primarily.
[lang/lr0.scm:339]

(item-set-closure g is)
For grammar @var{g}, return the epsilon transition
closure of item set @var{is}.

In the LR(0) NFA, if we are at the state:

@smallexample
        A -> w * B v
@end smallexample

Then we are also an epsilon transition (not to be confused
with an empty reduction) away from also being in the items:

@smallexample
        B -> * u
        B -> * r
        B -> * s
        ...
@end smallexample

So if a superstate contains @code{A->w*Bv}, then it should also contain
the inital states of @code{B}.  This rule applies transitively.

If @var{is} was returned by @code{item-set-start-kernel}, then this procedure
returns the DFA start state.

If @var{is} was returned by @code{item-set-successor-kernel}, and the IS
argument to @code{item-set-successor-kernel} was a DFA state, then this
procedure returns a DFA state.
[lang/lr0.scm:446]

(VALIDATE:state-stack-entry obj)
Check state-stack-entry specific invariants for @var{obj}.
(Actually, at this time, no checks are done.)  Return @var{obj}.
[lang/lr1-debug.scm:108]

(display-state-stack-entry state)
Display state stack entry @var{state} to the current output port.
[lang/lr1-debug.scm:116]

(parser-value-cons v vs)
Return the result of adding value @var{v} to value stack @var{vs}.
[lang/lr1.scm:184]

(parser-value-car vs)
Return the top of the value stack @var{vs}.
[lang/lr1.scm:187]

(parser-value-cdr vs)
Return the rest of the value stack @var{vs}, excluding the top value.
[lang/lr1.scm:190]

(parser-value-cdr-ref vs n)
Return the rest of the value stack @var{vs}, excluding the first @var{n} values.
[lang/lr1.scm:193]

(parser-context-cons g state context)
For grammar @var{g}, return the result of adding @var{state}
to the @var{context} stack.
[lang/lr1.scm:200]

(parser-context-car context)
Return the top of the @var{context} stack.
[lang/lr1.scm:205]

(parser-context-cdr context)
Return the rest of the @var{context} stack.
[lang/lr1.scm:208]

(parser-context-cdr-ref context n)
Return the rest of the @var{context} stack, excluding the first @var{n} states.
[lang/lr1.scm:211]

(make-parser-state g is)
For grammar @var{g}, return the parser state associated with
item set @var{is}, creating it if necessary.
[lang/lr1.scm:224]

(parser-state-item-set state)
Return the item set extracted from a parser @var{state}.
[lang/lr1.scm:232]

(parser-state-action-cache state)
Return the action-cache extracted from a parse @var{state}.
[lang/lr1.scm:236]

(parser-start-state g)
Return the initial parser state derived from grammar @var{g}'s
@code{item-set-start-kernel}.  Cache the return value.
[lang/lr1.scm:375]

(parser-action g state token-type module)
Given grammar @var{g}'s @var{state} and the current @var{token-type},
determine the action to take (shift, reduce, or error) in @var{module}'s
environment, and return the form:

@smallexample
  (ACTION [DATA])
@end smallexample

Here @code{DATA} is next state (if shifting), a list of the production
functions (if reducing), or empty (if error).  Cache the return value.
[lang/lr1.scm:394]

(lr1-parse g lexer parse-error module)
Do parsing for grammar @var{g} that uses token-providing procedure
@var{lexer} and error-handling procedure @var{parser-error}, with
reductions taking place in the environment of module @var{module}.

[At this time, I don't know if this procedure returns.  So far, I've only
 tested with a throw in the reduction body. --ttn]
[lang/lr1.scm:423]

(yy-parse grammar lexer module)
Parse @var{grammar} with @var{lexer} proc in @var{module}'s environment.
NOTE: This procedure is still highly experimental; use it only if you're
ready to go look at the source to figure out and/or fix problems.
[lang/yy.scm:116]

(system-big-endian?)
Return @code{#t} if the native encoding of numbers is
big-endian for the machine running Guile, @code{#f} if
the native encoding is little-endian.
[database/binconv.c:106]

(integer-byte-string->integer s signed_p [big_endian_p])
Convert the machine-format number encoded in string @var{s}
to an exact integer.  The string must contain either 2, 4, or
8 characters.  If @var{signed?} is true, then the string is
decoded as a two's-complement number, otherwise it is decoded
as an unsigned integer.  If @var{big-endian?} is true, then
the first character's ASCII value provides the most significant
eight bits of the number, otherwise the first character provides
the least-significant eight bits, and so on.  The default value
of big-endian? is the result of @code{system-big-endian?}.
[database/binconv.c:123]

(integer->integer-byte-string n size signed_p [big_endian_p [dest]])
Convert the exact integer @var{n} to a machine-format number
encoded in a string of length @var{size}, which must be 2, 4,
or 8. If @var{signed?} is true, then the number is encoded with
two's complement, otherwise it is encoded as an unsigned bit
stream.  If @var{big-endian?} is true, then the most significant
eight bits of the number are encoded in the first character of
the resulting string, otherwise the least-significant bits are
encoded in the first character, and so on.  The default value of
@var{big-endian?} is the result of @code{system-big-endian?}.

If @var{dest} is provided, it must be a mutable string of
length @var{size}; in that case, the encoding of @var{n} is
written into @var{dest}, and @var{dest} is returned as the
result.  If @var{dest} is not provided, the result is a newly
allocated string.  If @var{n} cannot be encoded in a string of
the requested size and format, an error is thrown.  If @var{dest}
is provided and it is not of length @var{size}, an error is
thrown.
[database/binconv.c:190]

(floating-point-byte-string->real s [big_endian_p])
Convert the IEEE floating-point number encoded in string
@var{s} to an inexact real number.  The string must contain
either 4 or 8 characters.  If @var{big-endian?} is true,
then the first character's ASCII value provides the most
siginficant eight bits of the IEEE representation,
otherwise the first character provides the
least-significant eight bits, and so on.  The default value
of @var{big-endian?} is the result of @code{system-big-endian?}.
[database/binconv.c:249]

(real->floating-point-byte-string x size [big_endian_p [dest]])
Convert the real number @var{x} to its IEEE representation in a
string of length @var{size}, which must be 4 or 8.  If
@var{big-endian?} is true, then the most significant eight
bits of the number are encoded in the first character of the
resulting string, otherwise the least-significant bits are
encoded in the first character, and so on.  The default value
of @var{big-endian?} is the result of @code{system-big-endian?}.
If @var{dest} is provided, it must be a mutable string of
length @var{size}; in that case, the encoding of @var{x} is written
into @var{dest}, and @var{dest} is returned as the result.  If
@var{dest} is not provided, the result is a newly allocated
string.  If @var{dest} is provided and it is not of length
@var{size}, an error is thrown.
[database/binconv.c:287]

(create-index-file! out-name in-name delim [flags...])
Create index file @var{out-name} from cookie file @var{in-name}, separating
cookies by looking for char @var{delim} on a line by itself.  Optional
@var{flags} are keywords:

@table @code
@item #:random
Set bit 0 (corresponding to a mask of #x1) in the flags word in the header,
but do nothing else at the moment (FIXME).

@item #:ordered
Set bit 1 (corresponding to a mask of #x2) in the flags word in the header,
and order the offsets by sorting the cookies with @code{string<?}, ignoring
non-alphanumeric leading characters.

@item #:rotated
Set bit 2 (corresponding to a mask of #x4) in the flags word in the header,
to note that the cookies are @dfn{ROT13}.
@end table

Return #t on success.
[database/fcookie.scm:202]

(fortune-cookie cookie-file [dat-file])
Return a randomly-chosen string extracted from @var{cookie-file},
using the index file named by appending @file{.dat} to @var{cookie-file}.
Optional arg @var{dat-file} specifies the index file to use instead of the
default.
[database/fcookie.scm:283]

(memory-word-size)
Return the number of bits in a memory word.
[database/memword.c:77]

(memory-word-get object [offset])
Return the memory word of @var{object}.
If @var{object} can occupy more than one consecutive
word in memory, optional arg @var{offset} (default
value: zero) selects which one.
If @var{offset} is greater than the object size in
memory, return #f.
Signal error if @var{object} is not recognized.
[database/memword.c:90]

(tmpfile)
Return an input/output port to a unique temporary file
named using the path prefix @code{P_tmpdir} defined in
@file{stdio.h}.
The file is automatically deleted when the port is closed
or the program terminates.

The name of the temporary file associated with the returned
port is not available to Scheme programs;
@code{(port-filename (tmpfile))} always returns the
symbol @code{tmpfile}.
[database/tmpfile.c:74]

(system-big-endian?)
Return @code{#t} if the native encoding of numbers is
big-endian for the machine running Guile, @code{#f} if
the native encoding is little-endian.
[database/binconv.c:106]

(integer-byte-string->integer s signed_p [big_endian_p])
Convert the machine-format number encoded in string @var{s}
to an exact integer.  The string must contain either 2, 4, or
8 characters.  If @var{signed?} is true, then the string is
decoded as a two's-complement number, otherwise it is decoded
as an unsigned integer.  If @var{big-endian?} is true, then
the first character's ASCII value provides the most significant
eight bits of the number, otherwise the first character provides
the least-significant eight bits, and so on.  The default value
of big-endian? is the result of @code{system-big-endian?}.
[database/binconv.c:123]

(integer->integer-byte-string n size signed_p [big_endian_p [dest]])
Convert the exact integer @var{n} to a machine-format number
encoded in a string of length @var{size}, which must be 2, 4,
or 8. If @var{signed?} is true, then the number is encoded with
two's complement, otherwise it is encoded as an unsigned bit
stream.  If @var{big-endian?} is true, then the most significant
eight bits of the number are encoded in the first character of
the resulting string, otherwise the least-significant bits are
encoded in the first character, and so on.  The default value of
@var{big-endian?} is the result of @code{system-big-endian?}.

If @var{dest} is provided, it must be a mutable string of
length @var{size}; in that case, the encoding of @var{n} is
written into @var{dest}, and @var{dest} is returned as the
result.  If @var{dest} is not provided, the result is a newly
allocated string.  If @var{n} cannot be encoded in a string of
the requested size and format, an error is thrown.  If @var{dest}
is provided and it is not of length @var{size}, an error is
thrown.
[database/binconv.c:190]

(floating-point-byte-string->real s [big_endian_p])
Convert the IEEE floating-point number encoded in string
@var{s} to an inexact real number.  The string must contain
either 4 or 8 characters.  If @var{big-endian?} is true,
then the first character's ASCII value provides the most
siginficant eight bits of the IEEE representation,
otherwise the first character provides the
least-significant eight bits, and so on.  The default value
of @var{big-endian?} is the result of @code{system-big-endian?}.
[database/binconv.c:249]

(real->floating-point-byte-string x size [big_endian_p [dest]])
Convert the real number @var{x} to its IEEE representation in a
string of length @var{size}, which must be 4 or 8.  If
@var{big-endian?} is true, then the most significant eight
bits of the number are encoded in the first character of the
resulting string, otherwise the least-significant bits are
encoded in the first character, and so on.  The default value
of @var{big-endian?} is the result of @code{system-big-endian?}.
If @var{dest} is provided, it must be a mutable string of
length @var{size}; in that case, the encoding of @var{x} is written
into @var{dest}, and @var{dest} is returned as the result.  If
@var{dest} is not provided, the result is a newly allocated
string.  If @var{dest} is provided and it is not of length
@var{size}, an error is thrown.
[database/binconv.c:287]

(create-index-file! out-name in-name delim [flags...])
Create index file @var{out-name} from cookie file @var{in-name}, separating
cookies by looking for char @var{delim} on a line by itself.  Optional
@var{flags} are keywords:

@table @code
@item #:random
Set bit 0 (corresponding to a mask of #x1) in the flags word in the header,
but do nothing else at the moment (FIXME).

@item #:ordered
Set bit 1 (corresponding to a mask of #x2) in the flags word in the header,
and order the offsets by sorting the cookies with @code{string<?}, ignoring
non-alphanumeric leading characters.

@item #:rotated
Set bit 2 (corresponding to a mask of #x4) in the flags word in the header,
to note that the cookies are @dfn{ROT13}.
@end table

Return #t on success.
[database/fcookie.scm:202]

(fortune-cookie cookie-file [dat-file])
Return a randomly-chosen string extracted from @var{cookie-file},
using the index file named by appending @file{.dat} to @var{cookie-file}.
Optional arg @var{dat-file} specifies the index file to use instead of the
default.
[database/fcookie.scm:283]

(memory-word-size)
Return the number of bits in a memory word.
[database/memword.c:77]

(memory-word-get object [offset])
Return the memory word of @var{object}.
If @var{object} can occupy more than one consecutive
word in memory, optional arg @var{offset} (default
value: zero) selects which one.
If @var{offset} is greater than the object size in
memory, return #f.
Signal error if @var{object} is not recognized.
[database/memword.c:90]

(tmpfile)
Return an input/output port to a unique temporary file
named using the path prefix @code{P_tmpdir} defined in
@file{stdio.h}.
The file is automatically deleted when the port is closed
or the program terminates.

The name of the temporary file associated with the returned
port is not available to Scheme programs;
@code{(port-filename (tmpfile))} always returns the
symbol @code{tmpfile}.
[database/tmpfile.c:74]

(known? name)
If @var{name} (a string) is known, return #t, otherwise #f.
[cmdt/known-names.c:7926]

(known-info name)
If @var{name} (a string) is known, return a
list of the form @code{(GROUPS CLASS EXTRA)}.
If @var{name} is unknown, return #f.
[cmdt/known-names.c:7941]
