!=
(!= z1 ...) => boolean
Return `#t' if all arguments after the first are not numerically
equal to the first argument, `#f' otherwise.
[number.c:1143]

#:export
Keyword
Used in the option list of `use-modules'.
[modules.c:590]

#:use-module
Keyword
Used in the option list of `use-modules'.
[modules.c:583]

%%return-to-continuation
(%%return-to-continuation cont values) => *unspecified*
Internal procedure.  Do not use.
[control.c:145]

%dlcall
(%dlcall address) => *unspecified*
Call the function specified by `address', which must be a module's
initialization function of type result_t (* init_func_t) (void).
A `dl-error' exception is thrown if the called function did not
return `RESULT_SUCCESS'.
[dynlib.c:183]

%dlclose
(%dlclose handle) => *unspecified*
Close the dynamically loaded shared library specified by `handler'.
Only call this once per opened library.
[dynlib.c:121]

%dlopen
(%dlopen filename flags) => handle
Open the shared library named `filename' using the open flags
`flags'.  `flags' may be the bitwise or of the constants
`RTLD_LAZY', `RTLD_GLOBAL' and `RTLD_NOW'.  Return a
handle which can be used in calls to `%dlsym' and `%dlclose'.
The default for `flags' is `RTLD_NOW'.
A `dl-error' exception is thrown if the library could not be loaded.
[dynlib.c:82]

%dlsym
(%dlsym handle str) => integer
Find the symbol `str' in the shared library specified by `handle'.
Return an integer value denoting an address, which can be used in calls
to `%dlcall'.  A `dl-error' exception is thrown if the symbol
could not be found.
[dynlib.c:146]

%eval-time-taken%
Integer variable
The time spent in evaluation in clock ticks.  This is a read-only variable.
Only contains a sane value if the times() C library call is available.
[eval.c:2475]

%max-evaluate-stack%
Integer variable
Limits the size the evaluation stack can grow to.  Set this to a larger
value if you encounter `stack-overflow' exceptions.
[eval.c:2468]

%print-backtrace%
Boolean variable
If set to `#t', a procedure backtrace will be printed immediately
whenever an error or exception is encountered.  If `#f', you have to
call the procedure `backtrace' to get a procedure backtrace.
[eval.c:2505]

%print-backtrace-limit%
Integer variable
This variable limits the lines which will be printed in procedure
backtraces.
[eval.c:2512]

%print-read%
Boolean variable
If this is `#t', all expressions read from the current input port
will be printed to the current output port before evaluation.
[eval.c:2482]

%print-result%
Boolean variable
If this is `#t', evaluation results will be printed to the current
output port even if a script is being evaluated.
[eval.c:2489]

%read-delimited!
(%read-delimited! delims buf gobble? [port start end]) => pair
Read a delimited string into `buf' from `port', using the
current input port if not specified.  The string read is stored into
`buf' from positions START to END, which default to 0 and the
length of `buf', respecively. Characters are read until any of
the characters in the string `delims' is read.  When
`gobble?'  is true, the terminating character is discarded,
otherwise it is stored at the end of `buf'.  Returns a pair of
the terminating character (or the end-of- file object) and the
number of characters read and stored into `buf'.
[iofun.c:386]

%read-line
(%read-line [port]) => string
Read a newline-terminated line from `port', or the current input port
if not specified.  Return the end-of-file object when reaching the end of
file.
[iofun.c:290]

%save-backtrace%
Boolean variable
If this is `#t', the evaluator will save a backtrace of procedure
applications.  This is needed if you want to have procedure backtraces
on errors.
[eval.c:2497]

*
(* z1 ...) => number
Multiply all argument values and return the product. Return 1 if
called without parameters.
[number.c:501]

+
(+ z1 ...) => number
Add all numbers in the argument list and return the sum.  If called
without parameters, 0 is returned.
[number.c:380]

-
(- z1 ...) => number
Take the first argument and subtract all remaining argument values one
after the other. At least one parameter is required, if called with
exactly one parameter, the negated value of the parameter is returned.
[number.c:435]

/
(/ z1 ...) => number
Divide the first argument by all remaining arguments in turn.  If
called with one parameter, the reciprocal of the argument is returned.
Should any of the remaining arguments be zero, a division-by-zero
error is signalled.
[number.c:553]

<
(< z1 ...) => boolean
Return `#t' if all arguments are strictly ordered in increasing
order.
[number.c:1213]

<=
(<= z1 ...) => boolean
Return `#t' if all arguments are ordered in increasing order.
[number.c:1285]

=
(= z1 ...) => boolean
Return `#t' if all arguments are numerically equal, `#f' otherwise.
[number.c:1073]

>
(> z1 ...) => boolean
Return `#t' if all arguments are strictly ordered in decreasing
order.
[number.c:1358]

>=
(>= z1 ...) => boolean
Return `#t' if all arguments are ordered in decreasing order.
[number.c:1431]

PI
Constant
The number pi=3.14159265358...
[number.c:2396]

RTLD_GLOBAL
Constant
If specified as an argument to `%dlopen', the library will be
available to other processes as well.
[dynlib.c:366]

RTLD_LAZY
Constant
If specified as an argument to `%dlopen', symbols in the loaded
library are relocated as needed.
[dynlib.c:352]

RTLD_NOW
Constant
If specified as an argument to `%dlopen', all symbols are relocated
on load time.
[dynlib.c:359]

SEEK_CUR
Constant
To be used in calls to `seek'.  Moves the file pointer relatively to
the current position.
[iofun.c:1441]

SEEK_END
Constant
To be used in calls to `seek'.  Moves the file pointer relatively to
the end offset of the file.
[iofun.c:1448]

SEEK_SET
Constant
To be used in calls to `seek'.  Moves the file pointer to an absolut
offset.
[iofun.c:1434]

abs
(abs x) => number
Return the absolute value of the argument.
[number.c:617]

accept
(accept port) => (port . addr)
[net.c:428]

access?
(access? name mode) => boolean
Checks whether the process would be allowed to read, write or test
for existence of the file (or other file system object) whose name
is pathname.  If pathname is a symbolic link permissions of the file
referred to by this symbolic link are tested.  Returns `#t' if
access is permitted, `#f' otherwise.  This function may raise a
`system-error' exception if an error occurs.  `mode' is a
mask of one or more of the following constants: `R_OK', `W_OK',
`X_OK', `F_OK'.  `access?' is only successful if all
requested permissions are granted.
[posix.c:1036]

acos
(acos z) => number
Return the arccosine of `z'.
[number.c:1791]

alist-cons
(alist-cons key datum alist) => alist
Cons a new alist entry mapping from `key' to `datum' onto
`alist'.
[srfi-1.c:1538]

alist-copy
(alist-copy alist) => alist
Make a fresh copy of `alist'.  This means copying each pair that
forms an association as well as the spine of the list.
[srfi-1.c:1557]

alist-delete
(alist-delete obj alist [=]) => alist
`alist-delete' deletes all associations from `alist' with the
given `key', using key-comparison procedure `=', which defaults
to `equal?'.  The dynamic order in which the various applications
of `=' are made is not specified.
[srfi-1.c:1597]

alist-delete!
(alist-delete! obj alist [=]) => alist
`alist-delete!' is the destructive variant of `alist-delete'.
It may modify its argument list in order to produce its result.
[srfi-1.c:1674]

and
(and expression ...) => value(s)
`and' evaluates all `expressions' in order, but stops
evaluation as soon as one of the `expressions' returns a false
value. Returns `#f' if any of the expressions returns `#f' and
returns the result of the last expression otherwise. When called without
arguments, `#t' is returned.
[syntax.c:1302]

angle
(angle z) => number
Return the angle of `z' in polar representation.  This is -PI for
negative numbers and 0 for positive numbers since complex numbers are
not supported.
[number.c:668]

append
(append list ...) => list
Append all argument `list's to one list.
[list.c:758]

append!
(append! list ...) => list
Append all argument `list's to one list.  The argument lists are
modified to produce the resulting list.
[list.c:807]

append-reverse
(append-reverse rev-head tail)
`append-reverse' returns `(append (reverse rev-head) tail)'.
It is provided because it is a common operation.
[srfi-1.c:1820]

append-reverse!
(append-reverse! rev-head tail)
`append-reverse!' returns `(append! (reverse rev-head) tail)'.
It is provided because it is a common operation.
`append-reverse!' is just the destructive variant of
`append-reverse'.
[srfi-1.c:1848]

apply
(apply proc arg ... arglist) => value(s)
Apply the procedure `proc' to the `arguments'.  The arguments may
be any values, but the last must be a list.  All arguments before the
last are cons'ed onto the last and then `proc' is applied to the
resulting list.
[control.c:332]

apply-macro
(apply-macro macro list) => object
Apply the macro `macro', which must have been created with
`define-macro' to the argument list `list'.  This will cause
the transformer procedure for `macro' to be applied to the arguments
in `list'.  The value returned by the macro transformer is returned.
[macros.c:120]

apropos
(apropos str) => *unspecified*
Print information about all procedures which have `str' somewhere
in their name to the current output port.
[doc.c:285]

arith-overflow
Exception
Thrown when any numerical operation happens to overflow.
[number.c:2403]

arithmetic
Exception
Thrown when any arithmetic error other than overflow is encountered.
[number.c:2411]

ash
(ash n1 n2) => integer
Shift the integer `n1' left by `n2' bits if `n2' is not less
than zero, or shift `n2' arithmetically right by -`n2' bits if
`n2' is less than zero.
[number.c:1049]

asin
(asin z) => number
Return the arcsine of `z'.
[number.c:1766]

assoc
(assoc obj list [=]) => pair | #f
`alist' (for association list) must be a list of pairs.  Return
the first pair in `alist' whose car field is `obj'. If no
pair in `alist' has `obj' as its car, then `#f' is
returned. `assv' uses `eqv?' for comparing the values.
`assoc' is extended from R5RS to allow the client to pass in an
optional equality procedure `=' to compare keys.
[list.c:1413]

assq
(assq obj list) => pair | #f
`alist' (for association list) must be a list of pairs.  Return
the first pair in `alist' whose car field is `obj'. If no
pair in `alist' has `obj' as its car, then `#f' is
returned. `assq' uses `eq?' for comparing the values.
[list.c:1331]

assv
(assv obj list) => pair | #f
`alist' (for association list) must be a list of pairs.  Return
the first pair in `alist' whose car field is `obj'. If no
pair in `alist' has `obj' as its car, then `#f' is
returned. `assv' uses `eqv?' for comparing the values.
[list.c:1371]

atan
(atan z) => number
(atan y x) => number
Return the arctangent of `z'.
If called with two arguments, return the arctangent of the two
variables `y' and `x'. It is similar to computing the arctangent of
`y' / `x', except that the signs of both arguments are used to
determine the quadrant of the result.
[number.c:1821]

backtrace
(backtrace) => *unspecified*
Print the current error backtrace to the current error port.
[eval.c:2295]

basename
(basename name [suffix]) => string
Removes any leading directory components from `name'; if
`suffix' is specified and is identical to the end of name, it is
removed from `name' as well.
[stringfun.c:997]

begin
(begin command ...) => value(s)
`begin' accepts one or more expressions as its arguments. All
expressions are evaluated in the order they appear in the argument list
and the result of the last expression is returned. The result is
unspecified if no `command' is given.
[syntax.c:1008]

bind
(bind scheme-port family address port) => *unspecified*
Bind the port `scheme-port', created with a call to
`socket' to the address specified by `family',
`address', and the port number `port'.
[net.c:362]

boolean->integer
(boolean->integer b) => integer
Return 0 if `b' is `#f', 1 otherwise.
[boolean.c:76]

boolean?
(boolean? obj) => boolean
Returns `#t' if `obj' is a boolean value, `#f' otherwise.
[boolean.c:42]

box-ref
(box-ref box) => obj
Return the object contained in the box object `box'.
[box.c:85]

box-set!
(box-set! box obj) => *unspecified*
Store the Scheme object `obj' in the box object `box'.
[box.c:102]

box?
(box? obj) => boolean
Return `#t' if `obj'is a box object.
[box.c:54]

break
(break value) => *noreturn*
Return from the enclosing while statement and make it return the value
`value'.
[init.scm:111]

caaaar
(caaaar pair) => object
Equivalent to (car (car (car (car pair)))).
[list.c:395]

caaadr
(caaadr pair) => object
Equivalent to (car (car (car (cdr pair)))).
[list.c:415]

caaar
(caaar pair) => object
Equivalent to (car (car (car pair))).
[list.c:243]

caadar
(caadar pair) => object
Equivalent to (car (car (cdr (car pair)))).
[list.c:435]

caaddr
(caaddr pair) => object
Equivalent to (car (car (cdr (cdr pair)))).
[list.c:455]

caadr
(caadr pair) => object
Equivalent to (car (car (cdr pair))).
[list.c:262]

caar
(caar pair) => object
Equivalent to (car (car pair)).
[list.c:171]

cadaar
(cadaar pair) => object
Equivalent to (car (cdr (car (car pair)))).
[list.c:475]

cadadr
(cadadr pair) => object
Equivalent to (car (cdr (car (cdr pair)))).
[list.c:495]

cadar
(cadar pair) => object
Equivalent to (car (cdr (car pair))).
[list.c:281]

caddar
(caddar pair) => object
Equivalent to (car (cdr (cdr (car pair)))).
[list.c:515]

cadddr
(cadddr pair) => object
Equivalent to (car (cdr (cdr (cdr pair)))).
[list.c:535]

caddr
(caddr pair) => object
Equivalent to (car (cdr (cdr pair))).
[list.c:300]

cadr
(cadr pair) => object
Equivalent to (car (cdr pair)).
[list.c:189]

call-with-current-continuation
(call-with-current-continuation proc) => value(s)
Call the procedure `proc' with the current continuation as the only
parameter and return the value(s) returned by `proc'.  When the passed
continuation is called later, it will return to the corresponding call
to `call-with-current-continuation'.
[control.c:55]

call-with-input-file
(call-with-input-file filename proc) => object
Apply `proc' to an input port reading from `filename' and return
the value returned by `proc'.
[iofun.c:880]

call-with-input-string
(call-with-input-string string proc) => object
Apply `proc' to an input string port reading from `string' and
return the value returned by `proc'.
[iofun.c:1060]

call-with-output-file
(call-with-output-file filename proc) => object
Apply `proc' to an output port writing to `filename' and return
the value returned by `proc'.
[iofun.c:913]

call-with-output-string
(call-with-output-string string proc) => object
Apply `proc' to an output string port and return the accumulated
string of output.
[iofun.c:1082]

call-with-values
(call-with-values producer consumer)
Call `producer', which must be a thunk returning any number of values,
and apply `consumer' to the list of values returned by `producer'.
This is the standard procedure for handling multiple values in Scheme.
[values.c:83]

car
(car pair) => object
Return the car of `pair'.
[list.c:132]

car+cdr
(car+cdr pair) => [obj1 obj2]
The fundamental pair deconstructor.  Return two values, the first being
the `car', the second being the `cdr' of the pair.
[srfi-1.c:1043]

case
(case key clause1 clause2 ...) => value(s)
`key' may be any expression. Each `clause' should have the form
`clause' may be of the form
`case' expression is evaluated by first evaluating the `key'.
The resulting value is compared against each of the `datums' using
the equality predicate `eqv?', and if a match is found, the
`expression' following the matching `datum' is evaluated and the
result of the last `expression' is returned as the result of the
`case' expression.
Should no `clause' match and an `else' clause is present, that
clause is chosen and the `expressions' following the `else' are
evaluated in order to compute the result of the `case' expression.
[syntax.c:923]

catch
(catch tag thunk handler) => value(s)
Call `thunk' and return its value(s), but if an exception with an
exception tag equal to `tag' is encountered or `tag' is `#t',
`handler' will be called with the tag and the values of the exception.
In that case, the value(s) returned by `handler' are returned.
[control.c:222]

cdaaar
(cdaaar pair) => object
Equivalent to (cdr (car (car (car pair)))).
[list.c:555]

cdaadr
(cdaadr pair) => object
Equivalent to (cdr (car (car (cdr pair)))).
[list.c:575]

cdaar
(cdaar pair) => object
Equivalent to (cdr (car (car pair))).
[list.c:319]

cdadar
(cdadar pair) => object
Equivalent to (cdr (car (cdr (car pair)))).
[list.c:595]

cdaddr
(cdaddr pair) => object
Equivalent to (cdr (car (cdr (cdr pair)))).
[list.c:615]

cdadr
(cdadr pair) => object
Equivalent to (cdr (car (cdr pair))).
[list.c:338]

cdar
(cdar pair) => object
Equivalent to (cdr (car pair)).
[list.c:207]

cddaar
(cddaar pair) => object
Equivalent to (cdr (cdr (car (car pair)))).
[list.c:635]

cddadr
(cddadr pair) => object
Equivalent to (cdr (cdr (car (cdr pair)))).
[list.c:655]

cddar
(cddar pair) => object
Equivalent to (cdr (cdr (car pair))).
[list.c:357]

cdddar
(cdddar pair) => object
Equivalent to (cdr (cdr (cdr (car pair)))).
[list.c:675]

cddddr
(cddddr pair) => object
Equivalent to (cdr (cdr (cdr (cdr pair)))).
[list.c:695]

cdddr
(cdddr pair) => object
Equivalent to (cdr (cdr (cdr pair))).
[list.c:376]

cddr
(cddr pair) => object
Equivalent to (cdr (cdr pair)).
[list.c:225]

cdr
(cdr pair) => object
Return the cdr of `pair'.
[list.c:149]

ceiling
(ceiling x) => integer
Return the smallest integer not smaller than `x'.
[number.c:1955]

char->integer
(char->integer ch) => integer
Convert the character `ch' to its character code.
[char.c:404]

char-alphabetic?
(char-alphabetic? ch) => boolean
Return `#t' if `ch' is an alpabetic character, `#f'
otherwise.
[char.c:290]

char-ci<=?
(char-ci<=? ch1 ch2) => boolean
Return `#t' if `ch1' is less or equal to `ch2', `#f'
otherwise.  Case is ignored when comparing.
[char.c:221]

char-ci<?
(char-ci<? ch1 ch2) => boolean
Return `#t' if `ch1' is less than `ch2', `#f' otherwise.
Case is ignored when comparing.
[char.c:198]

char-ci=?
(char-ci=? ch1 ch2) => boolean
Return `#t' if `ch1' is equal to `ch2', `#f' otherwise.
Case is ignored when comparing.
[char.c:175]

char-ci>=?
(char-ci>=? ch1 ch2) => boolean
Return `#t' if `ch1' is greater than or equal to `ch2',
`#f' otherwise.  Case is ignored when comparing.
[char.c:267]

char-ci>?
(char-ci>? ch1 ch2) => boolean
Return `#t' if `ch1' is greater than `ch2', `#f' otherwise.
Case is ignored when comparing.
[char.c:244]

char-downcase
(char-downcase ch) => character
Convert the character `ch' to its lowercase equivalent, if it hase
one, return `ch' otherwise.
[char.c:460]

char-lower-case?
(char-lower-case? ch) => boolean
Return `#t' if `ch' is a lower case character, `#f'
otherwise.
[char.c:382]

char-numeric?
(char-numeric? ch) => boolean
Return `#t' if `ch' is a numeric character, `#f'
otherwise.
[char.c:313]

char-ready?
(char-ready? [port]) => boolean
Return `#t' if a character is available for reading from `port'
or the current input port, if `port' is not given.
[iofun.c:260]

char-upcase
(char-upcase ch) => character
Convert the character `ch' to its uppercase equivalent, if it hase
one, return `ch' otherwise.
[char.c:442]

char-upper-case?
(char-upper-case? ch) => boolean
Return `#t' if `ch' is an upper case character, `#f'
otherwise.
[char.c:359]

char-whitespace?
(char-whitespace? ch) => boolean
Return `#t' if `ch' is a whitespace character, `#f'
otherwise.
[char.c:336]

char<=?
(char<=? ch1 ch2) => boolean
Return `#t' if `ch1' less or equal to `ch2', `#f'
otherwise.
[char.c:107]

char<?
(char<? ch1 ch2) => boolean
Return `#t' if `ch1' is less than `ch2', `#f' otherwise.
[char.c:84]

char=?
(char=? ch1 ch2) => boolean
Return `#t' if `ch1' is equal to `ch2', `#f' otherwise.
[char.c:62]

char>=?
(char>=? ch1 ch2) => boolean
Return `#t' if `ch1' is greater than or equal to `ch2',
`#f' otherwise.
[char.c:152]

char>?
(char>? ch1 ch2) => boolean
Return `#t' if `ch1' is greater than `ch2', `#f' otherwise.
[char.c:129]

char?
(char? obj) => boolean
Return `#t' if `obj' is a character object, `#f' otherwise.
[char.c:45]

chdir
(chdir string) => *unspecified*
Change the current working directory to `string'.
[posix.c:353]

chmod
(chmod path mode) => *unspecified*
The mode of the file given by `path' is changed to `mode'.
`mode' is a mask made from the `S_I...' constants listed in the
description of `stat'.  This function may raise a
`system-error' exception if an error occurs.
[posix.c:1513]

chown
(chown path uid gid) => *unspecified*
Set the user identifier and group identifier of the file `path' to
`uid' and `gid'.  If any of `uid' or `gid' is equal to
-1, that component of `path''s ownership is not changed.  This
function may raise a `system-error' exception if an error occurs.
[posix.c:1540]

circular-list
(circular-list elt1 elt2 ...) => circular-list
Constructs a circular list of the elements.
[srfi-1.c:510]

circular-list?
(circular-list? list) => boolean
Return `#t' if `x' is a circular list.
[srfi-1.c:654]

cleanup-filename
(cleanup-filename filename) => string
Clean the given `filename' up and convert it to a canonical form by
removing all appearences of parent directory references
(`/foo/..'), current directory marks (`./'), multiple slashes
(`//') and trailing slashes. The root directory indicator `/'
is not deleted, though it is a trailing slash.
[stringfun.c:1133]

close
(close fdesc) => *unspecified*
If `fdesc' is an integer, closes the file descriptor, so that it
no longer refers to any file and may be reused.  If `fdesc' is a
port, it will be closed.  This function may raise a
`system-error' exception if an error occurs.
[posix.c:1191]

close-input-port
(close-input-port port) => *unspecified*
Close the open input port `port'.
[iofun.c:631]

close-output-port
(close-output-port port) => *unspecified*
Close the open output port `port'.
[iofun.c:656]

close-port
(close-port port) => *unspecified*
Close the open port `port'.
[iofun.c:606]

closedir
(closedir stream) => *unspecified*
Close the directory stream `stream'.  The return value is not
specified.
[posix.c:2970]

closure?
(closure? obj) => boolean
Returns `#t' if `obj' is a user-defined procedure, `#f'
otherwise.
[misc.c:209]

command-line
(command-line) => list
Return the command line arguments as a list of strings.
[misc.c:467]

complex?
(complex? obj) => boolean
Return `#t' if `obj' is a complex number, `#f' otherwise.
[number.c:151]

concatenate
(concatenate list-of-lists) => list
Concatenate all lists in the list `list-of-lists' and return the
newly created list.
[srfi-1.c:1753]

concatenate!
(concatenate! list-of-lists) => list
Concatenate all lists in the list `list-of-lists' and return the
result list.  This procedure may alter the lists contained in
the parameter when constructing the result.
[srfi-1.c:1787]

cond
(cond clause1 clause2 ...) => value(s)
Each `clause' is of the form
`clause' may be of the form
`clause' may be an `else clause', which has the form
`cond' expression is evaluated by evaluating the `test'
expressions of successive `clauses' in order until one of them
evaluates to a true values. The first `clause' whose `test'
evaluates to true is chosen and the `expressions' in the clause are
evaluated in order and the value of the last expression is returned as
the value of the `cond' expression. If the selected `clause'
has no `expressions', the value of the `test' is returned. An
`else clause' is chosen and the following `expressions' are
evaluated if no other `test' evaluates to true.
If the selected `clause' has the `=>' form, the
`expression' following the arrow must evaluate to a procedure to
which the result of the `test' is applied to yield the result of the
`cond' expression.
[syntax.c:859]

connect
(connect hostname port) => port
[net.c:184]

cons
(cons obj0 obj1) => pair
Construct a new pair with the car initialized to `obj0' and the
cdr initialized to `obj1'.
[list.c:104]

cons*
(cons* elt1 elt2 ...) => dotted-list
Like `list', but the last argument provides the tail of the
constructed list.
[srfi-1.c:379]

continue
(continue) => *noreturn*
Restart the enclosing while loop with the condition.
[init.scm:116]

copy-file
(copy-file oldfile newfile) => *unspecified*
Copy the file specified by `path-from' to `path-to'.  The
return value is unspecified.
[posix.c:2807]

cos
(cos z) => number
Return the cosine of `z'.
[number.c:1716]

count
(count pred list1 list2 ...) => integer
`pred' is a procedure taking as many arguments as there are lists
and returning a single value.  It is applied element-wise to the
elements of the `lists', and a count is tallied of the number of
elements that return a true value. This count is returned.  `count'
is iterative in that it is guarateed to apply `pred' to the
`list' elements in a left-to-right order.  The counting stops when
the shortest list expires.  At least one of the argument lists must be
finite.
[srfi-1.c:1106]

creat
(sys:creat filename mode) => fdesc
This is equivalent to `open' with flags equal to `(logior
O_CREAT O_WRONLY O_TRUNC)'.
[posix.c:1163]

current-environment
(current-environment) => environment
Return the environment currently used to look up bindings to be used
with `eval'.
[misc.c:300]

current-error-port
(current-error-port) => port
Return the current default port for error output.
[iofun.c:809]

current-input-port
(current-input-port) => port
Return the current default port for input.
[iofun.c:781]

current-module
(current-module) => module
Return the module in which currently definitions take place.
[modules.c:100]

current-output-port
(current-output-port) => port
Return the current default port for output.
[iofun.c:795]

current-time
(current-time) => integer
Return the current time in an integer, represented in the number of
seconds elapsed since 00:00:00 on January 1, 1970, Coordinated Universal
Time (UTC).  The value returned by this procedure can be used in calls
to `gmtime' or `localtime', which split up the time value into
its various parts.
[posix.c:2583]

define
(define var obj) => *unspecified*
(define (var obj ...) body ...) => *unspecified*
(define (var obj ... . obj) body ...) => *unspecified*
Define the variable with the value `obj'.  The latter two forms are
short forms of `(define var (lambda (obj ...) body ...))' or
`(define var (lambda (obj ... . obj) body ...))', respectively.
[syntax.c:673]

define-constant
(define-constant var obj) => *unspecified*
Define a constant called `var' which is bound to the value `obj'.
The constant `var' will be read only.
[syntax.c:746]

define-macro
(define-macro (name arg ...) body) => macro
Define a macro `name' which as many arguments as `args' are
given.  When the macro is expanded, the symbols in `args' are bound
to the actual parameters of the macro call and `body' is evaluated.
The result of evaluating the macro body expression is then substituted
for the macro call.  The return value is unspecified.
[macros.c:192]

define-module
(define-module name option ...) => *unspecified*
Define a module called `name' and switch to the context of the new
module, that means that all definitions made until the end of the file
will be made in the private environment of the module.  Definitions can
be made public using the syntactic form `export', documented below.
Options may be one or more pair of a keyword and a value.  The
following keywords are presently defined: #:use-module, #:export.
[modules.c:133]

define-syntax
(define-syntax name syntax-rule) => *unspecified*
Bind the syntax rules `syntax-rule', which must be created with
`syntax-rules', to `name' in the current environment.  The
return value is unspecified.
[macros.c:744]

defined?
(defined? symbol) => boolean
Return `#t' if `symbol' is defined in the current environment,
`#f' otherwise.
[syntax.c:702]

delay
(delay expression) => promise
Delays the evaluation of expression. Returns a promise, which when later
forced by a call to `force' will evaluate `expression' and
return the result. Evaluation is performed in the same environment in
which the promise was created.
[promise.c:104]

delete
(delete obj list [=]) => list
`delete' uses the comparison procedure `=', which defaults to
`equal?', to find all elements of `list' that are equal to
`x', and deletes them from `list'.  The dymanic order in which
the various applications of `=' are made is not specified.
The list is not disordered -- elements that appear in the result
list occur in the same order as they occur in the argument list.
[srfi-1.c:1275]

delete!
(delete! obj list [=]) => list
`delete!' is the destructive variant of `delete'. It is
allowed to alter the cons cells in its argument list to construct the
result.
[srfi-1.c:1331]

delete-duplicates
(delete-duplicates list [=]) => list
`delete-duplicates' removes duplicate elements from the list
argument.  If there are multiple equal elements in the argument list,
the result list only contains the first or leftmost of these elements in
the result.  The order of the surviving elements is the same as in the
original list.
[srfi-1.c:1391]

delete-duplicates!
(delete-duplicates! list [=]) => list
`delete-duplicates!' is the destructive variant of
`delete-duplicates'. It is allowed to alter the argument list to
produce the result.
[srfi-1.c:1464]

denominator
(denominator q) => integer
Return the denominator of the argument `q'.  Currently, 1 is always
returned because rational numbers are not supported.
[number.c:757]

describe
(describe obj) => *unspecified*
Print all available information about the given object `obj' to
the current output port.
[doc.c:268]

directory-files
(directory-files [dirname]) => list
Return a list containing all files in the directory `dirname'.  This
procedure may throw a `system-error' exception if an error occurs.
[posix.c:2610]

directory-stream?
(directory-stream? obj) => boolean
Return `#t' if `obj' is a directory stream, `#f' otherwise.
[posix.c:2911]

dirname
(dirname filename) => string
Returns a string of all but the final slash-delimited component of
`filename'.  If `filename' is a single component, `dirname'
returns `.' (meaning the current directory).
[stringfun.c:1032]

display
(display obj [port]) => *unspecified*
Print `obj' to `port', or to the current output port if not
specified. `display' prints the object without quoting.
[iofun.c:108]

dl-error
Exception
This exception is thrown if an error occurs while dealing with shared
libraries.  The exception includes a human-readable error message.
[dynlib.c:343]

do
(do ((variable1 init1 step1) ...) (test expression ...) cmd ...) => value(s)
`do' is an iteration construct. First, all `variables' are
bound to the values of their corresponding `init' values.  Then the
`test' expression is evaluated and if the value is false, the
`cmds' are evaluated in order. After each iteration, the
`variables' are bound to the result of evaluating the corresponding
`step' expressions and the `test' is evaluated again. The loop
terminates as soon as the `test' evaluates to a true value. Then the
`expressions' after the `test' are evaluated in order and the
value of the last `expression' is returned as the value of the
`do' expression.
[syntax.c:983]

documentation
(documentation obj) => object
Return the documentation object of the object `obj'.
[doc.c:120]

dotted-list?
(dotted-list? obj) => boolean
Return `#t' if `x' is a finite, non-nil-terminated list.  This
includes non-pair, non-() values (e.g. symbols, numbers), which are
considered to be dotted lists of length 0.
[srfi-1.c:673]

drop
(drop list k) => list
Return a list containing the elements of `list', but without the
first `k' elements. Return `list' if `k' is less or equal to
zero, returns the empty list if `k' is larger than the length of
`list'.
[srfi-1.c:193]

drop-right
(drop-right list k) => list
Return a list containing the elements of `list', but without the last
`k' elements.  Return `list' if `k' is <= 0, and return the
empty list if `k' is greater than the length of the list.
[srfi-1.c:217]

drop-right!
(drop-right! list k) => list
Return a list containing the elements of `list', but without the last
`k' elements.  Return `list' if `k' is <= 0, and return the
empty list if `k' is greater than the length of the list.  This procedure
may modify the parameter `list' as a side effect.
[srfi-1.c:253]

dynamic-wind
(dynamic-wind before thunk after) => value(s)
Call `thunk', but ensure that whenever the dynamic scope of `thunk'
is entered, `before' is called before entering and `after' is
called after control returned from `thunk'.  `before' and `after'
must be chunks.  The value(s) returned by `thunk' are returned.
[control.c:176]

eighth
(eighth list) => object
Return the eighth element from `list'.
[srfi-1.c:952]

endpwent
(endpwent) => vector
Close the `/etc/passwd' user information database.
[posix.c:832]

eof-object?
(eof-object? obj) => boolean
Return `#t' if `obj' is the end-of-file object.
[iofun.c:701]

eq?
(eq? obj1 obj2) => boolean
Return `#t' if `obj1' and `obj2' are the same values, that
means if both are stored at the same location in memory.
[misc.c:114]

equal?
(equal? obj1 obj2)
Return `#t' if the structure of `obj1' and `obj2' is the same.
You can use `equal?' to test lists, vectors and strings for equality,
these data structures are tested recursively.
[misc.c:154]

eqv?
(eqv? obj1 obj2) => boolean
This is the same as `eq?' but differs as far as numbers are
concerned. That means that `(eqv? 1.0 1.0)' returns `#t' in any
case.
[misc.c:134]

error
(error obj ...) => *no-return*
Throw a `misc-error' exception with the arguments as error
values.  At the top-level, the arguments will be printed.  This
procedure does not return.
[control.c:256]

eval
(eval expr [environment]) => value(s)
Evaluate the expression `expr' in the environment specified by
`environment' and return the resulting value(s).  `environment'
defaults to the current top-level environment.
[control.c:309]

even?
(even? object) => boolean
Return `#t' if `obj' is an even number, `#f' otherwise.
[number.c:335]

exact->inexact
(exact->inexact z) => inexact number
Return `z', converted to an inexact value.
[number.c:2074]

exact?
(exact? obj) => boolean
Return `#t' if `obj' is an exact number, `#f' otherwise.
[number.c:238]

execl
(execl filename args) => *no-return*
Execute the file `filename', passing the list `args' as command
line options.  This function may raise a `system-error' exception
if an error occurs.  It will not return if it is successful, because the
new process overlays the old one.
[posix.c:1847]

execle
(execle filename args env) => *no-return*
Like `execl', but pass the environment list `env' together
with the command line arguments `args' to the process.  This
function may raise a `system-error' exception if an error
occurs.  It will not return if it is successful, because the new
process overlays the old one.
[posix.c:1920]

execlp
(execlp filename args) => *no-return*
Like `execl', but search the path for `filename'.  This
function may raise a `system-error' exception if an error
occurs.  It will not return if it is successful, because the new
process overlays the old one.
[posix.c:1883]

exit
(exit [n]) => *no-return*
Exit the current interpreter process.  If `n' is specified, it will
become the process' exit code.  `n' defaults to 0.  This procedure
does not return.
[control.c:288]

exp
(exp z) => number
Implements the exponential function.
[number.c:1641]

expand-macro
(expand-macro list) => object
Expand the macro call represented by `list' and return the expanded
expression.  The `car' of the list must be a macro object.
[macros.c:101]

export
(export symbol ...) => *unspecified*
Add all `symbols' to the export list of the currently active module.
[modules.c:213]

expt
(expt z1 z2) => number
Return `z'1 raised to the power of `z'2.
[number.c:1896]

f32vector
(f32vector num ...) => vector
Create a homogenous 32-bit floating point vector holding all
the 32-bit values `num's passed as arguments.
[uvector.c:1947]

f32vector->list
(f32vector->list vec) => list
Return a list containing the elements of the 32-bit floating point
vector `vec'.
[uvector.c:2060]

f32vector-fill!
(f32vector-fill! vec num) => *undefined*
Store the 32-bit floating point value `num' in all elements of the
32-bit floating point vector `vec', overwriting the old contents of
`vec'.
[uvector.c:2123]

f32vector-length
(f32vector-length vec) => integer
Return the number of elements the homogenous 32-bit floating
point vector `vec' can hold.
[uvector.c:1986]

f32vector-ref
(f32vector-ref vec n) => object
Return the 32-bit value stored at index `n' in the homogenous
32-bit floating point vector `vec'.  The index `n' is zero-based.
[uvector.c:2004]

f32vector-set!
(f32vector-set! vec n num) => *undefined*
Store the 32-bit value at index `n' into the 32-bit floating
point vector `vec'.  The index `n' is zero-based.
[uvector.c:2027]

f32vector?
(f32vector? obj) => boolean
Return `#t', if `obj' is a homogenous 32-bit floating point vector,
`#f' otherwise.
[uvector.c:1890]

f64vector
(f64vector num ...) => vector
Create a homogenous 64-bit floating point vector holding all
the 64-bit values `num's passed as arguments.
[uvector.c:2277]

f64vector->list
(f64vector->list vec) => list
Return a list containing the elements of the 64-bit floating point
vector `vec'.
[uvector.c:2390]

f64vector-fill!
(f64vector-fill! vec num) => *undefined*
Store the 64-bit floating point value `num' in all elements of the
64-bit floating point vector `vec', overwriting the old contents of
`vec'.
[uvector.c:2453]

f64vector-length
(f64vector-length vec) => integer
Return the number of elements the homogenous 64-bit floating
point vector `vec' can hold.
[uvector.c:2316]

f64vector-ref
(f64vector-ref vec n) => object
Return the 64-bit value stored at index `n' in the homogenous
64-bit floating point vector `vec'.  The index `n' is zero-based.
[uvector.c:2334]

f64vector-set!
(f64vector-set! vec n num) => *undefined*
Store the 64-bit value at index `n' into the 64-bit floating
point vector `vec'.  The index `n' is zero-based.
[uvector.c:2357]

f64vector?
(f64vector? obj) => boolean
Return `#t', if `obj' is a homogenous 64-bit floating point vector,
`#f' otherwise.
[uvector.c:2220]

false-if-exception
(false-if-exception expr) => *anything*
Evaluate the expression `expr' and return its value.  When `expr'
raises an exception, return the false value `#f'.
order.
[init.scm:93]

fcntl
(fcntl fd cmd [arg]) => integer
`fcnt' performs one of various operations on the file descriptor
`fd'.  Refer to the Sizzle reference manual and the `fcntl'
man page for the possible commands and more information.
[posix.c:2712]

fifth
(fifth list) => object
Return the fifth element from `list'.
[srfi-1.c:883]

file-char-special?
(file-char-special? filename) => boolean
Return `#t', if `filename' is a special character device file.
[posix.scm:120]

file-creation
Exception
Thrown when a specified file could not be created.
[iofun.c:1462]

file-exists?
(file-exists? filename) => boolean
Return `#t', if a file (or directory) called `filename' exists.
[posix.scm:84]

file-fifo?
(file-fifo? filename) => boolean
Return `#t', if `filename' is a fifo file.
[posix.scm:138]

file-is-directory?
(file-directory? filename) => boolean
Return `#t', if `filename' is a directory.
[posix.scm:93]

file-is-symlink?
(file-is-symlink? filename) => boolean
Return `#t', if `filename' is a symbolic link.
[posix.scm:102]

file-not-found
Exception
Thrown when a specified file name could not be found.
[iofun.c:1455]

file-regular?
(file-regular? filename) => boolean
Return `#t', if `filename' is a regular file.
[posix.scm:111]

file-socket?
(file-socket? filename) => boolean
Return `#t', if `filename' is a socket file.
[posix.scm:147]

fileno
(fileno port) => integer
[posix.c:3059]

first
(first list) => object
Return the first element from `list'.
[srfi-1.c:809]

floor
(floor x) => integer
Return the largest integer not larger than `x'.
[number.c:1928]

fold
(fold kons knil list1 list2 ...) => object
The fundamental list iterator.
First, consider the single list-parameter case if clist1=(e1 e2
`' en) then this procedure returns
`' (kons e1 (kons e1 knil)))
`n' argument lists are provided, then the `kons' procedure
must take `n'+1 parameters: one element from each list, and the
``seed'' or fold state, which is initially `knil'.  The fold
operation terminates when the shortest list runs out of values.  At
least one of the argument lists must be finite.
[srfi-1.c:1169]

for-each
(for-each proc list1 list2 ...) => *unspecified*
Apply the procedure `proc' to the elements of the `list's,
in order.  `proc' must take as many arguments as there are
lists.  The return value is unspecified.
[list.c:1107]

force
(force promise) => value(s)
Force the evaluation of `promise', which must be created with a
prior call to `delay'.  The value of the promise is cached so that
a second force will return the cached value without evaluating it again.
[promise.c:127]

force-output
(force-output [port]) => *unspecified*
Write all pending output of `port' to the underlying file descriptor.
[iofun.c:758]

fork
(fork) => pid
Creates a child process that differs from the parent process only in its
process identifier and parent process identifier, and in the fact that
resource utilizations are set to 0.  File locks and pending signals
are not inherited.  This function may raise a `system-error'
exception if an error occurs.
[posix.c:1605]

form?
(form? obj) => boolean
Returns `#t' if `obj' is a syntactic form, `#f'
otherwise.
[misc.c:191]

fourth
(fourth list) => object
Return the fourth element from `list'.
[srfi-1.c:863]

fsync
(fsync fdesc) => *unspecified*
`fdesc' must be either a valid file descripor or a file port.
All pending output is written if `fdesc' is a file port.  The
data buffered for the underlying file descriptor is then forced to
be written to disk using the system call `fsync'.
[posix.c:2763]

ftell
(ftell port) => integer
Return the current file pointer position of `port'.
[iofun.c:510]

garbage-collect
(garbage-collect) => *unspecified*
Invoke the garbage collector.
[misc.c:422]

gc-message
Boolean variable
If set to `#t', messages will printed whenever garbage collection
takes place.
[gc.c:781]

gc-stats
(gc-stats) => alist
Return an association list with some garbage collection statistics.
[gc.c:720]

gcd
(gcd [n1 [n2]]) => integer
Return the greatest common divisor of its arguments.  Without
arguments, 0 is returned, if only `n1' is given, `n1' is returned.
[number.c:2287]

gensym
(gensym [prefix]) => symbol
Generate a new symbol, constructed from `prefix' and the value of a
counter which is incremented after each call.  `prefix' defaults to
`)gen', if not given.
[symbol.c:103]

get-output-string
(get-output-string string-port) => string
Given an output port created with `open-output-string', returns a
string consisting of the characters that have been output to the port so
far.
[sport.c:233]

getcwd
(getcwd) => string
Return the current working directory.
[posix.c:305]

getdomainname
(getdomainname) => string
Get the domain name of the local host.
[net.c:829]

getegid
(getegid) => integer
Returns the effective group identifier of the running Sizzle process.  A
`system-error' exception may be raised if an error occurs.
[posix.c:570]

getenv
(getenv str) => string
Return the value of the environment variable `str'.  Return `#f' if
the environment variable `str' is not defined.
[posix.c:204]

geteuid
(geteuid) => integer
Returns the effective user identifier of the running Sizzle process.  A
`system-error' exception may be raised if an error occurs.
[posix.c:464]

getgid
(getgid) => integer
Returns the group identifier of the running Sizzle process.  A
`system-error' exception may be raised if an error occurs.
[posix.c:517]

getgroups
(getgroups) => vector
Returns a vector containing all groups the current user belongs to.
This function may raise a `system-error' exception if an error
occurs.
[posix.c:861]

gethostbyname
(gethostbyname hostname) => integer
[net.c:170]

gethostname
(gethostname) => string
Get the host name of the local host.
[net.c:781]

getpeername
(getpeername port) => address
[net.c:688]

getpgid
(getpgid pid) => integer
Returns the process group identifier of the process specified by
`pid'.  If `pid' is zero, the process identifier of the current
process is used.  This function may raise a `system-error'
exception if an error occurs.
[posix.c:625]

getpgrp
(getpgrp) => integer
This is equivalent to `(getpgid 0)'.
[posix.c:648]

getpid
(getpid)
Get the process identification of the current process.
[posix.c:377]

getppid
(getppid)
Get the process idenfication of the parent of the current process.
[posix.c:391]

getpwent
(getpwent) => vector
Returns a vector containing the broken out fields of a line from
`/etc/passwd' for the next entry.  The returned vector has the
same format as for `getpwnam'.
[posix.c:769]

getpwnam
(getpwnam name) => vector
Returns a vector containing the broken out fields of a line from
`/etc/passwd' for the entry that matches the user name
`name'. This function may raise a `system-error' exception
if an error occurs.  The returned vector contains the seven fields:
username, password, uid, gid, gecos, dir, shell.
[posix.c:691]

getpwuid
(getpwuid uid) => vector
Returns a vector containing the broken out fields of a line from
`/etc/passwd' for the entry that matches the user identifier
`uid'.  This function may raise a `system-error' exception if an
error occurs.  The returned vector has the same format as for
`getpwnam'.
[posix.c:731]

getsockname
(getsockname port) => address
[net.c:657]

getuid
(getuid)
Get the user identification of the user running the current process.
[posix.c:413]

gmtime
(gmtime x) => vector
Split up the time object `x', which represents the current time
in standard Unix convention in seconds since January 1, 1970.
Returns a vector with the split up fields of the time.  The times in
the vector is in Coordinated Universal Time. The result vector
contains the following fields: seconds, minutes, hours, day of
month, month, year, day of the week, day in the year, daylight
saving time, time zone offset, time zone name or `#f' if not
specified.
[posix.c:2524]

hash
(hash obj n) => integer
Determine a hash value for `obj' that is suitable for lookups in
a hash table of size `n', where `equal?' is used as the
equality predicate.  The function returns an integer in the range 0
to `n' - 1.  Note that this function may use internal
addresses.  Thus two calls to the same function where the keys are
equal according to the sameness predicate used are not guaranteed to
deliver the same value if the key object `obj' gets garbage
collected in between.
[hashtab.c:214]

hash-create-handle!
(hash-create-handle! tab key value) => pair
Look up `key' in `table' and return its handle.  If
`key' is not already present, a new handle is created which
associates `key' with `init'.  Return the handle looked up
or newly created.
[hashtab.c:749]

hash-fold
(hash-fold proc seed table) => object
Iterate over the elements of the hash table `table'.  `proc'
is applied to every hash table element with the arguments
`(proc key value init)', where on the first call `init' is
the given `seed', and on subsequent calls `init' is the
result of the previous call.
[hashtab.c:914]

hash-get-handle
(hash-get-handle tab key) => pair | #f
This procedure is similar to its `-ref' cousins, but returns
`handles' from the hash table rather than the value associated
with `key'.  By convention, a handle in a hash table is the pair
which associates a key with a value.  Where `hash-ref table
key' returns only a `value', `hash-get-handle table key'
returns the pair `(key . value)'.
[hashtab.c:663]

hash-ref
(hash-ref tab key [default]) => value
Look up `key' in the hash table `tab', and return the
value (if any) associated with it.  If `key' is not found,
return `default' (or `#f' if no `default' argument is
supplied).  `hash-ref' uses `equal?' for equality testing.
[hashtab.c:688]

hash-remove!
(hash-remove! tab key) => pair | #f
Remove `key' (and any value associated with it) from `tab'.
`hash-remove!' uses `equal?' for equality testing. The
procedure returns the handle (that is, the key--value pair) that was
removed or `#f' if the key was not found.
[hashtab.c:781]

hash-set!
(hash-set! tab key value) => value
Find the entry in `tab' associated with `key', and store
`value' there. `hashq-set!' uses `equal?' for equality
testing. This procedure returns the `value'.
[hashtab.c:716]

hashq
(hashq obj n) => integer
Determine a hash value for `obj' that is suitable for lookups in
a hash table of size `n', where `eq?' is used as the
equality predicate.  The function returns an integer in the range 0
to `n' - 1.  Note that this function may use internal
addresses.  Thus two calls to the same function where the keys are
equal according to the sameness predicate used are not guaranteed to
deliver the same value if the key object `obj' gets garbage
collected in between.
[hashtab.c:166]

hashq-create-handle!
(hashq-create-handle! tab key value) => pair
Look up `key' in `table' and return its handle.  If
`key' is not already present, a new handle is created which
associates `key' with `init'.  Return the handle looked up
or newly created.
[hashtab.c:353]

hashq-get-handle
(hashq-get-handle tab key) => pair | #f
This procedure is similar to its `-ref' cousins, but returns
`handles' from the hash table rather than the value associated
with `key'.  By convention, a handle in a hash table is the pair
which associates a key with a value.  Where `hashq-ref table
key' returns only a `value', `hashq-get-handle table key'
returns the pair `(key . value)'.
[hashtab.c:267]

hashq-ref
(hashq-ref tab key [default]) => value
Look up `key' in the hash table `tab', and return the
value (if any) associated with it.  If `key' is not found,
return `default' (or `#f' if no `default' argument is
supplied).  `hashq-ref' uses `eq?' for equality testing.
[hashtab.c:292]

hashq-remove!
(hashq-remove! tab key) => pair | #f
Remove `key' (and any value associated with it) from `tab'.
`hashq-remove!' uses `eq?' for equality testing. The
procedure returns the handle (that is, the key--value pair) that was
removed or `#f' if the key was not found.
[hashtab.c:385]

hashq-set!
(hashq-set! tab key value) => value
Find the entry in `tab' associated with `key', and store
`value' there. `hashq-set!' uses `eq?' for equality
testing. This procedure returns the `value'.
[hashtab.c:320]

hashv
(hashv obj n) => integer
Determine a hash value for `obj' that is suitable for lookups in
a hash table of size `n', where `eqv?' is used as the
equality predicate.  The function returns an integer in the range 0
to `n' - 1.  Note that this function may use internal
addresses.  Thus two calls to the same function where the keys are
equal according to the sameness predicate used are not guaranteed to
deliver the same value if the key object `obj' gets garbage
collected in between.
[hashtab.c:190]

hashv-create-handle!
(hashv-create-handle! tab key value) => pair
Look up `key' in `table' and return its handle.  If
`key' is not already present, a new handle is created which
associates `key' with `init'.  Return the handle looked up
or newly created.
[hashtab.c:551]

hashv-get-handle
(hashv-get-handle tab key) => pair | #f
This procedure is similar to its `-ref' cousins, but returns
`handles' from the hash table rather than the value associated
with `key'.  By convention, a handle in a hash table is the pair
which associates a key with a value.  Where `hashv-ref table
key' returns only a `value', `hashv-get-handle table key'
returns the pair `(key . value)'.
[hashtab.c:465]

hashv-ref
(hashv-ref tab key [default]) => value
Look up `key' in the hash table `tab', and return the
value (if any) associated with it.  If `key' is not found,
return `default' (or `#f' if no `default' argument is
supplied).  `hashv-ref' uses `eqv?' for equality testing.
[hashtab.c:490]

hashv-remove!
(hashv-remove! tab key) => pair | #f
Remove `key' (and any value associated with it) from `tab'.
`hashv-remove!' uses `eqv?' for equality testing. The
procedure returns the handle (that is, the key--value pair) that was
removed or `#f' if the key was not found.
[hashtab.c:583]

hashv-set!
(hashv-set! tab key value) => value
Find the entry in `tab' associated with `key', and store
`value' there. `hashq-set!' uses `eqv?' for equality
testing. This procedure returns the `value'.
[hashtab.c:518]

htonl
(htonl i) => integer
[net.c:719]

htons
(htons i) => integer
[net.c:749]

if
(if cond consequent [alternative]) => value
Evaluate `cond', and if it evaluates to a true value, evaluate
`consequent'.  Otherwise, evaluate `alternative'.  If `cond'
evaluates to `#f' and `alternative' is not given, the return
value is not specified.
[syntax.c:772]

imag-part
(imag-part z) => number
Return the imaginary part of the number `z'.  The Sizzle implementation
simply returns 0, because complex numbers are not supported.
[number.c:716]

inet-aton
(inet-aton addr) => sock-addr
Convert the internet address `addr' from dotted decimal notation
to binary data.
[net.c:877]

inet-ntoa
(inet-ntoa addr) => string
Convert the internet address `addr' from binary representation to
a string.
[net.c:914]

inexact->exact
(inexact->exact z) => exact number
Return `z', converted to an exact value. An error signalled if a
conversion is not possible without losing precision.
[number.c:2043]

inexact?
(inexact? obj) => boolean
Return `#t' if `obj' is an inexact number, `#f' otherwise.
[number.c:255]

input-port?
(input-port? port) => boolean
Return `#t' if `port' is open for input.
[iofun.c:720]

integer->boolean
(integer->boolean i) => boolean
Return `#f' if `i' is 0, `#t' otherwise.
[boolean.c:93]

integer->char
(integer->char n) => character
Convert the character code `n' to a character.
[char.c:421]

integer?
(integer? obj) => boolean
Return `#t' if `obj' is an exact integer number, `#f' otherwise.
[number.c:203]

interaction-environment
(interaction-environment) => environment
Returns the environment of the read-eval-print loop to be used with
`eval'.
[misc.c:245]

invalidate-pointer!
(invalidate-pointer! p) => *unspecified*
Invalidate the pointer `p' by setting its `invalid' flag.
[pointer.c:99]

iota
(iota count [start step]) =>
Returns a list containing the elements
(start start + step ... start + (count - 1) * step)
The `start' and `step' parameters default to 0 and 1,
respectively. This procedure takes its name from the APL primitive.
[srfi-1.c:544]

isatty?
(isatty? [port]) => boolean
Return `#t', if `port' is a tty, `#f' otherwise.  `port'
defaults to the current input port.
[iofun.c:1387]

keyword-table
(keyword-table) => vector
Return the global keyword table.  The keyword table is a vector of keyword
lists.
[misc.c:453]

kill
(kill pid sig) =>
Sends any signal to any process group or process.  If `pid' is
positive, then signal `sig' is sent to `pid'.
If `pid' equals 0, then `sig' is sent to every process in the
process group of the current process.  If `pid' equals -1, then
`sig' is sent to every process except for the first one, from higher
numbers in the process table to lower.  If `pid' is less than -1,
then `sig' is sent to every process in the process group -`pid'.
If `sig' is 0, then no signal is sent, but error checking is still
performed.
This function may raise a `system-error' exception if an error
occurs.
[posix.c:1736]

lambda
(lambda (variable1 ...) command ...)
(lambda (variable1 ... . variablen) command ...)
(lambda variable command ...)
Lambda is used to define procedures. The `variables' are the formal
parameters to which actual parameters will be bount. When the procedure
is called, the actual parameters are bound and the `commands' are
evaluated in order. The three syntactic forms above differ in the way
parameters are bound.  The first lambda takes exactly as many actual
arguments as `variables' are given, the second takes at least as
many actual arguments as `arguments' before the dot are given and
binds `variablen' to a list of the rest of the arguments and the
third form takes any number of arguments which will then be bound to
`variable'.
[syntax.c:1249]

last
(last list) => object
Return the last element of `list' and return the empty list, if
`list' is empty.
[list.c:924]

last-pair
(last-pair list) => pair | '()
Return the last of the pairs from which `list' is constructed.
[list.c:946]

lcm
(lcm [n1 [n2]]) => integer
Return the least common multiple of its arguments.  Without arguments,
1 is returned, if only `n1' is given, `n1' is returned.
[number.c:2317]

length
(length list) => integer
Return the length of `list'.  `list' must be a proper list, or
an error will be signalled.
[list.c:1000]

length+
(length+ list) => integer | #f
Return the length of `list'.  If `list' is a circular, `#f'
is returned.
[srfi-1.c:52]

let
(let [variable] ((variable expression) ...) command ...) => value(s)
`let' creates a block in which all variables named in the first
argument list are redefined to the corresponding values.  The
expressions in the body are executed and afterwards all variables are
rebound to their original values. The result of the last evaluated
expression is returned. If no body expressions are given, the result is
unspecified. When using `let', the `variables' are not visible
to `expressions', because the variables are bound after all the
expressions are evaluated.

The named-let construct is used to implement looping
constructs. `variable' is bound to a lambda expression which takes
the `variables' as its formal parameters and then calls the
expression with actual parameters set to the `expressions'. The body
of the let can than refer to `variable' by calling it recursively as
a function.
[syntax.c:1152]

let*
(let* ((variable expression) ...) command ...) => value(s)
Works like `let', but the `expressions' are evaluated in
left-to-right order where each `variable' is visible to the
expression on its right.
[syntax.c:1185]

let-syntax
(let-syntax ((variable syntax-rule) ...) body) => value(s)
Bind the syntax rules `syntax-rules', which must be created using
the syntactic form `syntax-rules' to the `variables' and evaluate
`body'.  The defined syntactic forms will be visible in `body'
only.  The return value is the return value of the last expression in
`body'.
[macros.c:604]

letrec
(letrec ((variable expression) ...) command ...) => value(s)
Works like `let', but the `variables' are visible to all
`expressions', thus making possible mutual recursive procedures.
[syntax.c:1212]

letrec-syntax
(letrec-syntax ((variable syntax-rule) ...) body) => value(s)
Bind the syntax rules `syntax-rules', which must be created using
the syntactic form `syntax-rules' to the `variables' and evaluate
`body'.  The defined syntactic forms will be visible in the
`syntax-rule' statements and `body' only.  In contrast to
`let-syntax', syntax elements defined in the variable binding
section can refer to each other recursively.  The return value is the
return value of the last expression in `body'.
[macros.c:675]

link
(link oldpath newpath) => *unspecified*
Creates a new link (also known as a hard link) to an existing file.  If
`newpath' exists it will not be overwritten.  The return value is
not specified.  This function may raise a `system-error' exception
if an error occurs.
[posix.c:1382]

list
(list obj ...) => list
Create a list of all arguments.
[list.c:118]

list->f32vector
(list->f32vector list) => vector
Return a 32-bit floating point vector containing the elements of the
list `list'.
[uvector.c:2084]

list->f64vector
(list->f64vector list) => vector
Return a 64-bit floating point vector containing the elements of the
list `list'.
[uvector.c:2414]

list->hashtable
(list->hashtable list) => hashtable
Return a hashtable constructed from the list of alists `list'.
[hashtab.c:882]

list->s16vector
(list->s16vector list) => vector
Return a signed 16-bit vector containing the elements of the list `list'.
[uvector.c:861]

list->s32vector
(list->s32vector list) => vector
Return a signed 32-bit vector containing the elements of the list `list'.
[uvector.c:1473]

list->s64vector
(list->s64vector list) => vector
Return a signed 64-bit vector containing the elements of the list `list'.
[uvector64.c:231]

list->s8vector
(list->s8vector list) => vector
Return a signed 8-bit vector containing the elements of the list `list'.
[uvector.c:242]

list->string
(list->string list) => string
Convert the list `list', which must be made up from character
values, to a string.
[stringfun.c:831]

list->u16vector
(list->u16vector list) => vector
Return a unsigned 16-bit vector containing the elements of the list
`list'.
[uvector.c:1172]

list->u32vector
(list->u32vector list) => vector
Return a unsigned 32-bit vector containing the elements of the list
`list'.
[uvector.c:1769]

list->u64vector
(list->u64vector list) => vector
Return a unsigned 64-bit vector containing the elements of the list
`list'.
[uvector64.c:528]

list->u8vector
(list->u8vector list) => vector
Return a unsigned 8-bit vector containing the elements of the list
`list'.
[uvector.c:552]

list->vector
(list->vector list) => vector
Return a vector containing the elements of the list `list'.
[vector.c:266]

list-copy
(list-copy list) => list
Copies the spine of the argument list.
[srfi-1.c:483]

list-ref
(list-ref list k) => object
Return the element at index `k' in the list `list'.
[list.c:1190]

list-tabulate
(list-tabulate len proc) => string
Returns an `n'-element list. Element `i' ofthe list, where 0 <=
`i' < `n', is produced by calling `(init-proc i)'.  The
dynamic order in which `init-proc' is applied to the indices is not
specified.
[srfi-1.c:445]

list-tail
(list-tail list k) => list
Return the tail of `list' after index `k'.
[list.c:1167]

list=
(list= elt= list1 ...) =>
Determine list equality, given an element-equality procedure.  Proper
list `A' equals proper list `B' if they are of the same length
and their corresponding elements are equal, as determined by `elt='.

It is an error to apply `list=' to anything except proper lists.
[srfi-1.c:738]

list?
(list? obj) => boolean
Return `#t', if `obj' is a proper list, return `#f'
otherwise.
[list.c:50]

listen
(listen port backlog) => *unspecified*
[net.c:405]

load-library
(load-library name [filename]) => *unspecified*
Load the shared library module called `name'.  If `filename' is
not specified, the file name is constructed by prepending "lib" and
appending ".so".  After loading, the function `zzz_init_@var{name'}
is called to initialize the module.  An `dl-error' exception is
thrown if the library could not be loaded or if the init funciotn did not
return `RESULT_SUCCESS'.
[dynlib.c:217]

localtime
(localtime x) => vector
Returns `x' converted to local time in a vector of the format
defined in the description of `gmtime'.
Bug: Right now time zone offset and time zone names are not correctly
set by `localtime'.
[posix.c:2553]

log
(log z) => number
Return the natural logarithm of `z'.
[number.c:1666]

logand
(logand n ...) => integer
Perform a bitwise `and' operation on all arguments and returns the
result. Returns a value with all bits set if called without arguments.
[number.c:936]

logior
(logior n ...) => integer
Perform a bitwise `or' operation on all arguments and returns the
result. Returns a value with no bits set if called without arguments.
[number.c:964]

lognot
(lognot n) => integer
Returns the bitwise negated value of the argument.
[number.c:918]

logxor
(logxor n ...) => integer
Perform a bitwise `exclusive or' operation on all arguments and
returns the result. Returns a value with no bits set if called without
arguments.
[number.c:993]

long?
(long? obj) => boolean
Return `#t' if `obj' is an exact long integer number (a non-immediate
integer, not a bignum), `#f' otherwise.
[number.c:221]

lsh
(lsh n1 n2) => integer
Shift the integer `n1' left by `n2' bits if `n2' is not less
than zero, or shift `n2' logically right by -`n2' bits if `n2'
is less than zero.
[number.c:1022]

lstat
(lstat filename) => filename
Like `stat', but does not follow symbolic links.
[posix.c:994]

magnitude
(magnitude z) => number
Return the magnitude for `z'.  This is the same as `abs', since complex
numbers are not supported.
[number.c:642]

make-box
(make-box obj) => box
Create a new box object containing the Scheme object `obj'.
[box.c:71]

make-f32vector
(make-f32vector len [fill]) => vector
Create a homogenous 32-bit floating point vector capable of
holding `len' elements and initializes the vector fields to `fill'.
If `fill' is omitted, the contents of the vector is undefined.
[uvector.c:1909]

make-f64vector
(make-f64vector len [fill]) => vector
Create a homogenous 64-bit floating point vector capable of
holding `len' elements and initializes the vector fields to `fill'.
If `fill' is omitted, the contents of the vector is undefined.
[uvector.c:2239]

make-hash
(make-hash [capacity] pair ...) => vector
Creates a hash table, initialized with values taken from the
`pairs'.  The car of each pair is taken as a hash key and the
corresponding cdr as the value.  If the first argument is not a pair, it
must be an integer and will give the number of buckets to use for the
hash table.
[hashtab.c:830]

make-list
(make-list n [fill]) => list
Return an `n'-element list, whose elements are all the value
`fill'. If the `fill' argument is not given, the elements of the
list are unspecified.
[srfi-1.c:409]

make-pointer
(make-pointer n) => pointer
Create a new pointer object.  `n' must be a non-negative
integer, and a memory block big enough to hold `n' bytes will be
allocated and the pointer will point to it.  If `n' is 0, then
a null-pointer will be returned.
[pointer.c:74]

make-regexp
(make-regexp flags ...) => regex
Create a compiled regular expression object which represents the
string `string'.  The following additional arguments can be
passed to control regular expression compilation: regexp/icase
regexp/extended regexp/basic regexp/newline
[regexp.c:80]

make-s16vector
(make-s16vector len [fill]) => vector
Create a homogenous signed 16-bit vector capable of holding `len'
elements and initializes the vector fields to `fill'.  If `fill' is
omitted, the contents of the vector is undefined.
[uvector.c:699]

make-s32vector
(make-s32vector len [fill]) => vector
Create a homogenous signed 32-bit vector capable of holding `len'
elements and initializes the vector fields to `fill'.  If `fill' is
omitted, the contents of the vector is undefined.
[uvector.c:1319]

make-s64vector
(make-s64vector len [fill]) => vector
Create a homogenous signed 64-bit vector capable of holding `len'
elements and initializes the vector fields to `fill'.  If `fill' is
omitted, the contents of the vector is undefined.
[uvector64.c:77]

make-s8vector
(make-s8vector len [fill]) => vector
Create a homogenous signed 8-bit vector capable of holding `len'
elements and initializes the vector fields to `fill'.  If `fill' is
omitted, the contents of the vector is undefined.
[uvector.c:80]

make-soft-port
(make-soft-port vec modes) => port
Creates a port which uses the input/output procedures in the vector
`vec'.
The vector must constist of the following elements.  Each element must
be either a procedure or `#f':
0. A procedure accepting one character for writing.
1. A procedure accepting a string for writing (currently ignored).
2. A procedure for flushing the output.
3. A procedure delivering a character, `#f' or `eof-object'.
`#f' and the end-of-file object signal an end of file.
4. A close procedure.  This procedure is only called if a port is
closed with close-{in,out}put-port, not when closed duriong garbage
collection.
The `mode' argument is currently ignored.
[scmport.c:155]

make-string
(make-string k [char]) => string
Return a newly allocated string of length `k'. `char' is used to
initialize the string, if omitted, the contents of the string is
unspecified.
[stringfun.c:126]

make-u16vector
(make-u16vector len [fill]) => vector
Create a homogenous unsigned 16-bit vector capable of holding `len'
elements and initializes the vector fields to `fill'.  If `fill' is
omitted, the contents of the vector is undefined.
[uvector.c:1008]

make-u32vector
(make-u32vector len [fill]) => vector
Create a homogenous unsigned 32-bit vector capable of holding `len'
elements and initializes the vector fields to `fill'.  If `fill' is
omitted, the contents of the vector is undefined.
[uvector.c:1613]

make-u64vector
(make-u64vector len [fill]) => vector
Create a homogenous unsigned 64-bit vector capable of holding `len'
elements and initializes the vector fields to `fill'.  If `fill' is
omitted, the contents of the vector is undefined.
[uvector64.c:371]

make-u8vector
(make-u8vector len [fill]) => vector
Create a homogenous unsigned 8-bit vector capable of holding `len'
elements and initializes the vector fields to `fill'.  If `fill' is
omitted, the contents of the vector is undefined.
[uvector.c:389]

make-variable
(make-variable name setter getter finalizer) => *unspecified*
Create a magic variable with the given setter, getter and finalizer
procedures.  `name' must be a string and is the name of the newly
created variable.  The return value is not specified.
[misc.c:484]

make-vector
(make-vector len [fill]) => vector
Create a vector capable of holding `len' elements and initializes the
vector fields to `fill'.  If `fill' is omitted, the contents of
the vector is undefined.
[vector.c:89]

map
(map proc list1 list2...) => list
Apply the procedure `proc' to the elements of the `list's
and return a list of the results of the procedure applications.
`proc' must take as many arguments as there are `list's.
[list.c:1038]

max
(max x1 x2 ...) => number
Return the maximum of the arguments.
[number.c:1503]

member
(member obj list [=]) => list | #f
Return the first sublist of `list' whose car is
`obj'. `member' uses `equql?' for comparing the
values.  If `obj' does not occur in `list', `#f' is
returned.
`member' is extended from R5RS to allow the client to pass an
optional equality procedure `=' used to compare keys.
[list.c:1281]

memq
(memq obj list) => list | #f
Return the first sublist of `list' whose car is
`obj'. `memq' uses `eq?' for comparing the values.  If
`obj' does not occur in `list', `#f' is returned.
[list.c:1224]

memv
(memv obj list) => list | #f
Return the first sublist of `list' whose car is
`obj'. `memv' uses `eqv?' for comparing the values.  If
`obj' does not occur in `list', `#f' is returned.
[list.c:1251]

min
(min x1 x2 ...) => number
Return the minimum of the arguments.
[number.c:1572]

misc-error
Exception
This is thrown when a miscellaneous error happens.
[eval.c:2453]

module-list
(module-list) => list
Return a list of currently loaded modules.
[modules.c:114]

modulo
(modulo n1 n2) => integer
Return the rest of an integer division of its arguments. An
arithmetic overflow error is signalled if the second operand is equal
to zero. This differs from `remainder' for negative operands.
[number.c:869]

negative?
(negative? obj) => boolean
Return `#t' if `obj' is less than zero, ``#f' otherwise.
[number.c:293]

network-error
Exception
Thrown when an error occurs in any of the network procedures.
[net.c:976]

newline
(newline [port]) => *unspecified*
Print a newline character to `port', or to the current output port if
not given.
[iofun.c:130]

nice
(nice inc) => *unspecified*
Change the current process priority by amount `inc'.  You must be
the system administrator to pass a negative `inc'.  This function
may raise a `system-error' exception if an error occurs.
[posix.c:1965]

ninth
(ninth list) => object
Return the ninth element from `list'.
[srfi-1.c:979]

not
(not obj) => boolean
Returns `#t' if `obj' is false, `#f' otherwise.
[boolean.c:59]

not-pair?
(not-pair? obj) => boolean
Return `#t' if `x' is not a pair.  Provided as a procedure as
it can be useful as the termination condition for list-processing
procedures that wish to handle all lists, both proper and dotted.
[srfi-1.c:717]

ntohl
(ntohl i) => integer
[net.c:734]

ntohs
(ntohs i) => integer
[net.c:764]

null-environment
(null-environment version) => environment
Returns an empty environment to be used with `eval'.  `version'
must be an exact integer spcifying the supported Scheme report version,
currently this is 5.
[misc.c:261]

null-list?
(null-list? list) => boolean
`list' is a proper or circular list.  Returns `#t' if the
argument is the empty list (), and `#f' otherwise.  It is an error
to pass this procedure a value which is not a proper or circular list.
This procedure is recommended as the termination condition for
list--processing procedures that are not defined on dotted lists.
[srfi-1.c:694]

null?
(null? obj) => boolean
Return `#t', if `obj' is a the empty list, return `#f'
otherwise.
[list.c:68]

number->string
(number->string z) => string
(number->string z radix) => string
Convert its argument to a string.  The radix `radix' is used if given;
it defaults to 10.
[number.c:2098]

number?
(number? obj) => boolean
Return `#t' if `obj' is a number, `#f' otherwise.
[number.c:134]

numerator
(numerator q) => integer
Return the numerator of thes argument `q'.  Currently, `q' itself is
returned because rational numbers are not supported.
[number.c:739]

object->string
(object->string obj) => string
Return a string with the characters `display' would produce
when printing `obj'.
[iofun.c:1409]

odd?
(odd? obj) => boolean
Return `#t' if `obj' is an odd number, `#f' otherwise.
[number.c:357]

open-fdes
(open-fdes filename flags [mode]) => fdesc
Attempts to open the file called `filename' and returns a file
descriptor.  `flags' is a mask of one or more of the constants
`O_*'.  If `flags' contains `O_CREAT', the argument `mode'
must be given.  It denotes the set of file permission to give to the new
file.
[posix.c:1131]

open-input-file
(open-input-file filename) => port
Open the file named `filename' for reading and return an input port for
the file.  This may throw a `file-not-found' exception on error.
[iofun.c:548]

open-input-string
(open-input-string string) => string-port
Takes `string' and returns an input port that delivers characters
from the string.  The port can be closed by `close-input-port',
though its storage will be reclaimed by the garbage collector if it
becomes inaccessible.
[sport.c:189]

open-output-file
(open-output-file filename) => port
Open the file named `filename' for writing and return an input port for
the file.  This may throw a `file-creation' exception on error.
[iofun.c:577]

open-output-string
(open-output-string) => string-port
Returns an output port that will accumulate characters for retrieval by
`get-output-string'.  The port can be closed by
`close-output-port', though its storage will be reclaimed by the
garbage collector if it becomes inaccessible.
[sport.c:212]

opendir
(opendir str) => directory-stream
Open the directory called `str' and return a directory stream for that
directory, which can be used in calls to `readdir', `closedir'
and `rewinddir'.  This procedure may raise a `system-error'
exception if an error occurs.
[posix.c:2931]

or
(or expression ...) => value(s)
`and' evaluates all `expressions' in order, but stops
evaluation as soon as one of the `expressions' returns a non-false
value. Returns `#f' if none of the expressions returns `#t'
and returns the result of the first expression returning a non-false
value otherwise.  When called without arguments, `#f' is returned.
[syntax.c:1320]

output-port?
(output-port? port) => boolean
Return `#t' if `port' is open for output.
[iofun.c:739]

pair-fold
(pair-fold kons knil list1 list2 ...) => object
Analogous to `fold', but `kons' is applied to successive
sublists of the lists, rather than successive elements -- that is,
`kons' is applied to the pairs making up the lists.
For finite lists, the `kons' function may reliably apply
`set-cdr!' to the pairs it is given without altering the sequence
of execution.
[srfi-1.c:1222]

pair?
(pair? obj) => boolean
Return `#t', if `obj' is a the cons pair, return `#f'
otherwise.
[list.c:86]

peek-char
(peek-char [port]) => char
Like `read-char', but do not remove the character from the
input port `port', so that it can be read again using
`read-char'.  `port' defaults to the current input port.
[iofun.c:228]

pipe
(pipe) => pair
Creates a pair of ports, pointing to a pipe inode. The car of the
returned pair is an input port for reading, the cdr is an output
port for writing.  This function may raise a `system-error'
exception if an error occurs.
[posix.c:1104]

pointer?
(pointer? obj) => boolean
Return `#t' if `obj'is a pointer object.
[pointer.c:54]

port-closed?
(port-closed? port) => boolean
Return `#t' if `port' is a closed port, `#f' otherwise.
[iofun.c:681]

port-column
(port-column [port]) => integer
Return the column number of `port'.  `port' defaults to the
current input port.
[iofun.c:1305]

port-filename
(port-filename [port]) => string
Return the filename of `port'.  `port' defaults to the current
input port.
[iofun.c:1346]

port-line
(port-line [port]) => integer
Return the line number of `port'.  `port' defaults to the current
input port.
[iofun.c:1264]

positive?
(positive? obj) => boolean
Return `#t' if `obj' is greater than zero, `#f' otherwise.
[number.c:314]

primitive-exit
(primitive-exit [status]) => *no-return*
Terminate the current process without performing any cleanup.  The exit
status is STATUS, which defaults to 0 if not specified.  This procedure
has no return value, because it never returns.
[posix.c:1575]

primitive-load
(primitive-load filename) => *unspecified*
Load the file named `filename' and evaluate its contents in the toplevel
environment.
[eval.c:2175]

primitive-load-path
(primitive-load-path filename) => *unspecified*
Load the file named `filename' and evaluate its contents in the toplevel
environment. This procedure is similar to `primitive-load', but when
`filename' is not an absolute file name, it is searched in the current
directory as well as in all directories listed in the variable
`%load-path'.
[eval.c:2213]

primitive-procedure
(primitive-procedure? obj) => boolean
Returns `#t' if `obj' is a primitive procedure, `#f'
otherwise.
[misc.c:173]

procedure?
(procedure? obj) => boolean
Returns `#t' if `obj' is a primitive or user-defined procedure,
`#f' otherwise.
[misc.c:227]

profile-stats
(profile-stats) => alist
Return an association list with profiling statistics.
[profile.c:62]

proper-list?
(proper-list? list) => boolean
Return `#t' if `x' is a proper list -- a finite,
nil-terminated list.  Return `#f' for any other object.
[srfi-1.c:637]

putenv
(putenv string) => *unspecified*
Put the string `string', which must have the format `VARNAME=VALUE',
into the current process environment.
[posix.c:264]

quasiquote
(quasiquote obj) => object
Return `obj' without evaluating it, but evaluate sub-expressions
in the syntactic forms `unquote' (`,') and `unquote-splicing'
(`,@').  `(quasiquote o)' is equivalent to ``o'.
[syntax.c:516]

quote
(quote obj) => object
Return `obj' without evaluating it.  `(quote o)' is equivalent to
`'o'.
[syntax.c:49]

quotient
(quotient n1 n2) => integer
Perform an integer division operation on the two arguments. An
arithmetic overflow error is signalled if the second operand is equal to
zero.
[number.c:776]

quotify
(quotify str) => string
Return a string with the same contents as `str', but quote all
shell meta-characters.
[posix.scm:157]

random
(random limit) => integer
Return a random integer X in the range 0 <= X < limit.
[misc.c:372]

rational?
(rational? obj) => boolean
Return `#t' if `obj' is a rational number, `#f' otherwise.
[number.c:186]

read
(read [port]) => object
Read a Scheme object from `port', or from the current input port if not
specified.
[iofun.c:151]

read-char
(read-char [port]) => char
Read a character from `port', or from the current input port if not
specified.
[iofun.c:171]

readdir
(readdir stream) => string
Return the next filename from the directory stream `stream', or
the end-of-file object if all files have been read.  This procedure
may raise a `system-error' exception if an error occurs.
[posix.c:2991]

readlink
(readlink filename) => string
Returns the name of the file the link `filename' is referring to.
This function may raise a `system-error' exception if an error
occurs.
[posix.c:1474]

real-part
(real-part z) => number
Return the real part of the number `z'.  In Sizzle, this returns `z'
itself, because complex numbers are not supported.
[number.c:693]

real?
(real? obj) => boolean
Return `#t' if `obj' is a inexact number in floating point
representation, `#f' otherwise.
[number.c:169]

receive
(receive (var0 ...) expr body ...)
Evaluate `expr' and bind all values returned to the variables `var0'
...`varn'. Then execute the `body' expressions.
[init.scm:139]

regexp-exec
(regexp-exec rx str) => #f | vector
Match the regular expression `rx' against `string'.  If
`start' is given, start matching at that position.  Flags may be
a mask of the following constants: regexp/notbol regexp/noteol
[regexp.c:124]

regexp/basic
Constant
Do not support extended Posix regular expressions.
[regexp.c:294]

regexp/extended
Constant
Support extended Posix regular expressions (this is the default).
[regexp.c:282]

regexp/icase
Constant
The matching is performed case-insensitively.
[regexp.c:288]

regexp/newline
Constant
Treat a newline in the matched string as beginning/end of the string as
far as the beginning-of-line and end-of-line operators are concerned.
[regexp.c:301]

regexp/notbol
Constant
The match-beginning-of-line operator always fails to match.
[regexp.c:308]

regexp/noteol
The end-beginning-of-line operator always fails to match.
[regexp.c:313]

regexp?
(regexp? obj) => boolean
Returns `#t' if `obj' is a compiled regular expression object,
`#f' otherwise.
[regexp.c:60]

remainder
(remainder n1 n2) => integer
Return the rest of an integer division of its arguments.  An arithmetic
overflow error is signalled if the second operand is equal to zero.
[number.c:818]

remove
(remove obj list) => list
Return a list which is identical to the parameter `list', but
from which all occurences of `obj' are removed. `remove' uses
`equal?' for comparing the list elements with `obj'.
[list.c:1549]

remq
(remq obj list) => list
Return a list which is identical to the parameter `list', but
from which all occurences of `obj' are removed. `remq' uses
`eq?' for comparing the list elements with `obj'.
[list.c:1487]

remv
(remv obj list) => list
Return a list which is identical to the parameter `list', but
from which all occurences of `obj' are removed. `remv' uses
`eqv?' for comparing the list elements with `obj'.
[list.c:1518]

rename
(rename oldpath newpath) => *unspecified*
Renames a file, moving it between directories if required.
`oldpath' and `newpath' must refer to the same file system.  The
return value is not specified.  This function may raise a
`system-error' exception if an error occurs.
[posix.c:1448]

reverse
(reverse list) => list
Return a list containing the elements of `list' in reverse order.
[list.c:873]

reverse!
(reverse! list) => list
Return a list containing the elements of `list' in reverse order.  The
pairs of which `list' is constructed are modified to produce the result
list.
[list.c:898]

reverse-list->string
(reverse-list->string char-list) => string
An efficient implementation of (compose string->list reverse):
(reverse-list->string '(#\a #\B #\c)) => "cBa"
[srfi-13.c:1808]

rewinddir
(rewinddir stream) => string
Rewind the directory stream to the beginning, so that on the next call
to `readdir', the first file from the stream will be read.  The
return value is not specified.
[posix.c:3034]

round
(round x) => integer
Return the closest integer to `x' rounding it to even when `x' is
halfway between two integers.
[number.c:2011]

s16vector
(s16vector num ...) => vector
Create a homogenous signed 16-bit vector holding all the signed 16-bit
values `num's passed as arguments.
[uvector.c:733]

s16vector->list
(s16vector->list vec) => list
Return a list containing the elements of the signed 16-bit vector `vec'.
[uvector.c:838]

s16vector-fill!
(s16vector-fill! vec num) => *undefined*
Store signed 16-bit value `num' in all elements of the signed 16-bit
vector `vec', overwriting the old contents of `vec'.
[uvector.c:896]

s16vector-length
(s16vector-length vec) => integer
Return the number of elements the homogenous signed 16-bit vector `vec'
can hold.
[uvector.c:769]

s16vector-ref
(s16vector-ref vec n) => object
Return the signed 16-bit value stored at index `n' in the vector
homogenous signed 16-bit `vec'.  The index `n' is zero-based.
[uvector.c:787]

s16vector-set!
(s16vector-set! vec n num) => *undefined*
Store the signed 16-bit value at index `n' into the signed 16-bit vector
`vec'.  The index `n' is zero-based.
[uvector.c:810]

s16vector?
(s16vector? obj) => boolean
Return `#t', if `obj' is a homogenous signed 16-bit vector,
`#f' otherwise.
[uvector.c:680]

s32vector
(s32vector num ...) => vector
Create a homogenous signed 32-bit vector holding all the signed 32-bit
values `num's passed as arguments.
[uvector.c:1352]

s32vector->list
(s32vector->list vec) => list
Return a list containing the elements of the signed 32-bit vector `vec'.
[uvector.c:1450]

s32vector-fill!
(s32vector-fill! vec num) => *undefined*
Store signed 32-bit value `num' in all elements of the signed 32-bit
vector `vec', overwriting the old contents of `vec'.
[uvector.c:1504]

s32vector-length
(s32vector-length vec) => integer
Return the number of elements the homogenous signed 32-bit vector `vec'
can hold.
[uvector.c:1384]

s32vector-ref
(s32vector-ref vec n) => object
Return the signed 32-bit value stored at index `n' in the vector
homogenous signed 32-bit `vec'.  The index `n' is zero-based.
[uvector.c:1402]

s32vector-set!
(s32vector-set! vec n num) => *undefined*
Store the signed 32-bit value at index `n' into the signed 32-bit vector
`vec'.  The index `n' is zero-based.
[uvector.c:1425]

s32vector?
(s32vector? obj) => boolean
Return `#t', if `obj' is a homogenous signed 32-bit vector,
`#f' otherwise.
[uvector.c:1300]

s64vector
(s64vector num ...) => vector
Create a homogenous signed 64-bit vector holding all the signed 64-bit
values `num's passed as arguments.
[uvector64.c:110]

s64vector->list
(s64vector->list vec) => list
Return a list containing the elements of the signed 64-bit vector `vec'.
[uvector64.c:208]

s64vector-fill!
(s64vector-fill! vec num) => *undefined*
Store signed 64-bit value `num' in all elements of the signed 64-bit
vector `vec', overwriting the old contents of `vec'.
[uvector64.c:262]

s64vector-length
(s64vector-length vec) => integer
Return the number of elements the homogenous signed 64-bit vector `vec'
can hold.
[uvector64.c:142]

s64vector-ref
(s64vector-ref vec n) => object
Return the signed 64-bit value stored at index `n' in the vector
homogenous signed 64-bit `vec'.  The index `n' is zero-based.
[uvector64.c:160]

s64vector-set!
(s64vector-set! vec n num) => *undefined*
Store the signed 64-bit value at index `n' into the signed 64-bit vector
`vec'.  The index `n' is zero-based.
[uvector64.c:183]

s64vector?
(s64vector? obj) => boolean
Return `#t', if `obj' is a homogenous signed 64-bit vector,
`#f' otherwise.
[uvector64.c:58]

s8vector
(s8vector num ...) => vector
Create a homogenous signed 8-bit vector holding all the signed 8-bit
values `num's passed as arguments.
[uvector.c:114]

s8vector->list
(s8vector->list vec) => list
Return a list containing the elements of the signed 8-bit vector `vec'.
[uvector.c:219]

s8vector->string
(s8vector->string vec) => string
Convert the homogenous signed 8-bit vector `vec' to a string by taking
each value from the vector, converting it to a character and composing
the characters to a string.
[uvector.c:2663]

s8vector-fill!
(s8vector-fill! vec num) => *undefined*
Store signed 8-bit value `num' in all elements of the signed 8-bit
vector `vec', overwriting the old contents of `vec'.
[uvector.c:277]

s8vector-length
(s8vector-length vec) => integer
Return the number of elements the homogenous signed 8-bit vector `vec'
can hold.
[uvector.c:150]

s8vector-ref
(s8vector-ref vec n) => object
Return the signed 8-bit value stored at index `n' in the vector
homogenous signed 8-bit `vec'.  The index `n' is zero-based.
[uvector.c:168]

s8vector-set!
(s8vector-set! vec n num) => *undefined*
Store the signed 8-bit value at index `n' into the signed 8-bit vector
`vec'.  The index `n' is zero-based.
[uvector.c:191]

s8vector?
(s8vector? obj) => boolean
Return `#t', if `obj' is a homogenous signed 8-bit vector,
`#f' otherwise.
[uvector.c:61]

safe-environment
(safe-environment symbol-list) => environment
Create and return a `safe' environment, in which only the
special forms are defined.  Also, the current bindings for all
symbols in the `symbol-list' are entered into the new
environment.  This procedure can be used to construct environments
in which untrusted code can be safely executed.  The executed code
then only has access to the builtin special forms and all bindings
passed explicitly to `safe-environment', and is not able to
affect any other environments.
[misc.c:321]

scheme-report-environment
(scheme-report-environment version) => environment
Returns an environment with all bindings defined in R5RS to be used with
`eval'.  `version' must be an exact integer spcifying the
supported Scheme report version, currently this is 5.
[misc.c:281]

second
(second list) => object
Return the second element from `list'.
[srfi-1.c:826]

seek
(seek port offset whence) => integer
Move the file pointer of `port' to a new location, specified by
`offset' and `whence'.  `whence' is any of
`SEEK_CUR', `SEEK_SET' or `SEEK_END', like for the C
library call fseek().
[iofun.c:483]

select
(select rdfd wrfd exfd sec usec) => integer
Perform the `select' system call on the file descriptor sets
`rdfd', `wrdf' and `exfd'.  The timeout value is
calculated from the seconds `sec' and the microseconds
`usec'.
[net.c:566]

server-loop
(server-loop port proc) => *unspecified*
[net.c:286]

server-socket
(server-socket port) => port
[net.c:227]

set!
(set! var obj) => *unspecified*
Set the variable `var' to the value `obj'.  `var' must have been
defined earlier using `define'.
[syntax.c:558]

set-car!
(set-car! pair obj) => *unspecified*
Modify `pair' so that `obj' is the new car of `pair'.
[list.c:720]

set-cdr!
(set-cdr! pair obj) => *unspecified*
Modify `pair' so that `obj' is the new cdr of `pair'.
[list.c:739]

set-current-error-port
(set-current-error-port port) => *unspecied*
Set the error output port to `port'.
[iofun.c:860]

set-current-input-port
(set-current-input-port port) => *unspecified*
Set the current input port to `port'.
[iofun.c:823]

set-current-output-port
(set-current-output-port port) => *unspecified*
Set the current output port to `port'.
[iofun.c:841]

set-documentation!
(set-documentation! proc doc) => *unspecified*
Set `doc' as the documentation object for the procedure object
`proc'.
[doc.c:161]

set-port-column!
(set-port-column! port n) => *unspecified*
Set the column number of `port' to `n'.
[iofun.c:1325]

set-port-filename!
(set-port-filename! port filename) => *unspecified*
Set the filename of `port' to `filename'.
[iofun.c:1366]

set-port-line!
(set-port-line! port n) => *unspecified*
Set the line number of `port' to `n'.
[iofun.c:1284]

setdomainname
(setdomainname name) => *unspecified*
Set the domain name of the local host to `name'.
[net.c:853]

setegid
(setegid egid) => *unspecified*
Set the effective group identifier of the running Sizzle process to
`egid'.  A `system-error' exception may be raised if an error
occurs. The return value is not specified.
[posix.c:594]

seteuid
(seteuid euid) => *unspecified*
Set the effective user identifier of the current Sizzle process to
`euid'.  This function may raise a `system-error' exception if
an error occurs.  The return value is not specified.
[posix.c:488]

setgid
(setgid gid) => *unspecified*
Set the group identifier of the running Sizzle process to `gid'.  A
`system-error' exception may be raised if an error occurs.  The
return value is not specified.
[posix.c:541]

sethostname
(sethostname name) => *unspecified*
Set the host name of the local host to `name'.
[net.c:805]

setpwent
(setpwent) => vector
Reset the entry pointer for the passwd database, so that the next
call to `getpwent' will return the first entry.
[posix.c:805]

setuid
(setuid uid) => *unspecified*
Set the user identification of the current process to `uid'.
[posix.c:435]

seventh
(seventh list) => object
Return the seventh element from `list'.
[srfi-1.c:927]

shutdown
(shutdown port how) => *unspecified*
[net.c:634]

signal
(signal sig proc) => *unspecified*
Install a signal handler.  After installing a signal handler with this
function, `proc' is called whenever the signal `no' is sent to
the Sizzle process.
[sig.c:100]

signum
(signum x) => integer
Return -1 if `x' is less than zero, 0 if `x' is equal
to zero and 1 if `z' is greater than zero.
[number.c:2355]

sin
(sin z) => number
Return the sine of `z'.
[number.c:1691]

sixth
(sixth list) => object
Return the sixth element from `list'.
[srfi-1.c:904]

sleep
(sleep n) => integer
Suspend the running process for `n' seconds, or until a signal wakes
up the process.  This function may raise a `system-error' exception
if an error occurs.
[posix.c:1782]

socket
(socket domain type protocol) => port
[net.c:333]

split-at
(split-at list k) => list1 list2
Split the list `list' at index `k' and return two values: the list
of the first `k' elements and the list of the remaining elements.
[srfi-1.c:295]

split-at!
(split-at! list k) => list1 list2
Split the list `list' at index `k' and return two values: the list
of the first `k' elements and the list of the remaining elements.  This
procedure may modify its `list' argument as a side effect.
[srfi-1.c:325]

sqrt
(sqrt x) => number
Return the square root of the argument. Since complex numbers are not
supported, `x' must be positive.
[number.c:1861]

srand
(srand x) => *unspecified*
Set the random number generator seed to X.
[misc.c:397]

stack-overflow
Exception
This is thrown when an evaluation is nested so deep that the stack
grows larger than specified  by the variable `%max-evaluate-stack%'.
If you encounter this exception, you can set that variable to a larger
value.
[eval.c:2428]

standard-error-fdport
Variable
An fdport object connected to the standard error output.
[fdport.c:287]

standard-input-fdport
Variable
An fdport object connected to the standard input.
[fdport.c:275]

standard-input-port
Variable
This variable holds the port bound to the standard error file.
[port.c:748]

standard-input-port
Variable
This variable holds the port bound to the standard input file.
[port.c:736]

standard-input-port
Variable
This variable holds the port bound to the standard output file.
[port.c:742]

standard-output-fdport
Variable
An fdport object connected to the standard output.
[fdport.c:281]

stat
(stat filename) => vector
Returns information about the specified file.  You do not need any
access rights to the file to get this information but you need
search rights to all directories named in the path leading to the
file.  This function may raise a `system-error' exception if an
error occurs.
[posix.c:967]

strftime
(strftime format vec) => string
Format the time-representing vector `vec' according to the format
specifier `format' to a string and return that string.  For details
of the format specified, have a look at `man strftime'.
[posix.c:2477]

string
(string char ...) => string
Return a newly allocated string composed of its arguments, which all
must be characters.
[stringfun.c:171]

string->list
(string->list string [start end]) => string
Convert the string `string' to a list of all characters of
`string'.
`start' and `end' delimit the region of operation and default to
0 and the length of `string'.
[stringfun.c:797]

string->number
(string->number string) => number
(string->number string radix) => number
Convert `string' to a number. When given, `radix' is used as the
default radix which can be overridden with an explicit radix prefix in
`string'. `#f' is returned if `string' is not properly
formatted.
[number.c:2195]

string->s8vector
(string->s8vector str) => s8vector
Convert the string `str' to a homogenous signed 8-bit vector by taking
each character from `str', converting them to integer values and
composing them to a vector.
[uvector.c:2682]

string->symbol
(string->symbol string) => symbol
Converts `string' to a symbol.
[symbol.c:84]

string->u8vector
(string->u8vector str) => u8vector
Convert the string `str' to a homogenous unsigned 8-bit vector by taking
each character from `str', converting them to integer values and
composing them to a vector.
[uvector.c:2725]

string-any
(string-any pred s [start end]) => value
Returns a true value, if the application of `pred' to any of the
characters of `s' yields a true value.  `start' and `end' may
be given to restrict operation to the characters of `s' between these
indices.
[srfi-13.c:517]

string-append
(string-append string ...) => string
Return a string made out of the concatenation of all string arguments.
An empty string is returned if called without arguments.
[stringfun.c:726]

string-chop
(string-chop s) => string
Return a newly allocated string with the contents of `s', but with all
trailing newline characters removed.
[stringfun.c:1157]

string-ci<=?
(string-ci<=? string1 string2) => boolean
Returns `#t' if `string1' is lexicographically less or equal to
`string2', `#f' otherwise. This function ignores case when
comparing.
[stringfun.c:551]

string-ci<?
(string-ci<? string1 string2) => boolean
Returns `#t' if `string1' is lexicographically less than
`string2', `#f' otherwise. This function ignores case when
comparing.
[stringfun.c:519]

string-ci=?
(string-ci=? string1 string2) => boolean
Returns `#t' if `string1' is the same string as `string2',
`#f' otherwise. This function ignores case when comparing.
[stringfun.c:487]

string-ci>=?
(string-ci>=? string1 string2) => boolean
Returns `#t' if `string1' is lexicographically greater or equal
to `string2', `#f' otherwise. This function ignores case when
comparing.
[stringfun.c:615]

string-ci>?
(string-ci>? string1 string2) => boolean
Returns `#t' if `string1' is lexicographically greater than
`string2', `#f' otherwise. This function ignores case when
comparing.
[stringfun.c:583]

string-contains
(string-contains string1 string2 [start1 end1 start2 end2]) => integer|#f
Return the index in `string1' where `string2' occurs as a substring,
or `#f'.  The optional `start/end' indices restrict the operation
to the indicated substrings.  The returned index is in the range
[`start1', `end1').  A successful match must lie entirely in the
[`start1', `end1') range of `string1'.
Note: The current implementation uses the naivest possible algorithm and
is slow when `string1' is a long string.
[srfi-13.c:1672]

string-contains-ci
(string-contains-ci string1 string2 [start1 end1 start2 end2]) => integer|#f
Return the index in `string1' where `string2' occurs as a substring,
or `#f'.  The optional `start/end' indices restrict the operation
to the indicated substrings.  The returned index is in the range
[`start1', `end1').  A successful match must lie entirely in the
[`start1', `end1') range of `string1'.  Case is ignored when
comparing individual characters.
Note: The current implementation uses the naivest possible algorithm and
is slow when `string1' is a long string.
[srfi-13.c:1743]

string-copy
(string-copy string [start end]) => string
Returns a newly allocated string with the same contents as `string'.
`start' and `end' delimit the string to be copied, they default to
0 and the length of `string'.
[stringfun.c:879]

string-count
(string-count string ch/pred [start end]) => integer
Return a count of the number of characters in `string' that satisfy
the `ch/pred' argument.  If this argument is a procedure, it is
applied to all characters as a predicate; if it is a character, it is
used in a equality test.  `start' is the start index and defaults to
zero, `end' is the end index and defatuls to the length of
`string' - 1.
[srfi-13.c:1616]

string-downcase
(string-downcase s [start end]) => string
Convert all characters in `s' to lower case, returning a newly allocated
string.
`start' and `end' delimit the region of operation and default to
0 and the length of `s'.
[srfi-13.c:194]

string-downcase!
(string-downcase! s [start end]) => string
Convert all characters in `s' to lower case, modifying `s' in-place.
`start' and `end' delimit the region of operation and default to
0 and the length of `s'.
[srfi-13.c:149]

string-drop
(string-drop s nchars) => string
Return all but the first `nchars' characters of `s'.
[srfi-13.c:1230]

string-drop-right
(string-drop-right s nchars) => string
Return all but the last `nchars' characters of `s'.
[srfi-13.c:1253]

string-every
(string-every pred s [start end]) => value
Returns a true value, if the applications of `pred' to all of
the characters of `s' yield true values.  `start' and `end'
may be given to restrict operation to the characters of `s' between
these indices.
[srfi-13.c:476]

string-fill!
(string-fill! string char [start end]) =>
Stores the character `char' in all elements of `string'. The
return value is not specified.
`start' and `end' delimit the region which is filled and default
to 0 and the length of `string'.
[stringfun.c:906]

string-hash
(string-hash s [bound start end]) => integer
Compute a hash value for the string `s'.  `bound' is either
the boolean constant `#t' or a positive integer, then the
result of the procedure will be in the range [0, `bound').
`start' and `end' are optional parameters delimiting the
characters which are used to calculate the hash value, they default
to 0 and the length of `s'.
[srfi-13.c:1281]

string-hash-ci
(string-hash-ci s [bound start end]) => integer
Compute a hash value for the string `s'.  `bound' is either
the boolean constant `#t' or a positive integer, then the
result of the procedure will be in the range [0, `bound').
`start' and `end' are optional parameters delimiting the
characters which are used to calculate the hash value, they default
to 0 and the length of `s'.  The case of the characters in `s'
is ignored when computing the hash value.
[srfi-13.c:1324]

string-index
(string-index string ch/pred [from to]) => integer|#f
Scans the string `string' for the leftmost appearance of character
`ch' and returns the index or `#f' if not found.  If the second
argument is a procedure, it must be a predicate which will be applied to
each character in `string', and the index of the first character for
which the predicate yields true is returned.  `from' is
the start index and defaults to zero, `to' is the end index and
defaults to the length of `string' - 1.
[srfi-13.c:1367]

string-index-right
(string-index-right string ch [from to]) => integer|#f
Scans the string `string' for the rightmost appearance of character
`ch' and returns the index or `#f' if not found.  If the second
argument is a procedure, it must be a predicate which will be applied to
each character in `string' from right to left, and the index of the
last character for which the predicate yields true is returned.
`from' is the start index and defaults to zero, `to' is the end
index and defatuls to the length of `string' - 1.  This function
searches from right to left, whereas `string-index' searches from
left to right.
[srfi-13.c:1430]

string-join
(string-join string-list [delimiter grammar]) => string
`string-list' must be a list of strings, `delimiter' must be
a string and `grammar' must be any of the symbols infix, strict-infix,
prefix or suffix.  The strings from `string-list' are joined
with `delimiter' inbetween according to `grammar'.
[srfi-13.c:602]

string-length
(string-length string) => integer
Return the number of characters in `string'.
[stringfun.c:209]

string-null?
(string-null? str) => boolean
Return `#t' if `obj' is a the empty string `""',
`#f' otherwise.
[srfi-13.c:59]

string-pad
(string-pad s len [char start end]) => string
Build a string of length `len' comprised of `s' padded on the
left by as many occurences of the character `char' as needed.  If
`s' has more than `len' characters, it is truncated on the left
to length `len'.  `char' defaults to `#\space'.
[srfi-13.c:1075]

string-pad-right
(string-pad-right s len [char start end]) => string
Build a string of length `len' comprised of `s' padded on the
rightt by as many occurences of the character `char' as needed.  If
`s' has more than `len' characters, it is truncated on the right
to length `len'.  `char' defaults to `#\space'.
[srfi-13.c:1130]

string-prefix-ci?
(string-prefix-ci? s1 s2 [start1 end1 start2 end2]) => boolean
Return `#t' if `s1' is a prefix of `s2'.  Case is ignored
when comparing characters.
[srfi-13.c:933]

string-prefix-length
(string-prefix-length s1 s2 [start1 end1 start2 end2]) => integer
Return the length of the longest common prefix of the two strings.
[srfi-13.c:711]

string-prefix-length-ci
(string-prefix-length-ci s1 s2 [start1 end1 start2 end2]) => integer
Return the length of the longest common prefix of the two strings.
When comparing characters, case is ignored.
[srfi-13.c:755]

string-prefix?
(string-prefix? s1 s2 [start1 end1 start2 end2]) => boolean
Return `#t' if `s1' is a prefix of `s2'.
[srfi-13.c:886]

string-ref
(string-ref string k) => character
Return the `k'th character of `string'. The index is
zero-based. `k' must be a valid index into `string', or an error
will be signalled.
[stringfun.c:228]

string-reverse
(string-reverse s [start end]) => string
Return a reverse version of the string `s'.
[srfi-13.c:1869]

string-reverse!
(string-reverse! s [start end]) => *unspecified*
Reverse the string `s'.
[srfi-13.c:1837]

string-set!
(string k char) => *unspecified*
Store `char' in element `k' of `string'. An error will be
signalled if `k' is not a valid index into `string'.
[stringfun.c:259]

string-skip
(string-skip string ch/pred [start end]) => integer|#f
Scans the string `string' for the leftmost appearance of a
character different to `ch' and returns the index or `#f'
if not found.  If the second argument is a procedure, it must be a
predicate which will be applied to each character in `string',
and the index of the first character for which the predicate yields
false is returned.  `start' is the start index and defaults to
zero, `end' is the end index and defaults to the length of
`string' - 1.
[srfi-13.c:1492]

string-skip-right
(string-skip-right string ch [start end]) => integer|#f
Scans the string `string' for the rightmost appearance of a
character different from `ch' and returns the index or `#f'
if not found.  If the second argument is a procedure, it must be a
predicate which will be applied to each character in `string'
from right to left, and the index of the last character for which
the predicate yields false is returned.  `start' is the start
index and defaults to zero, `end' is the end index and defatuls
to the length of `string' - 1.  This function searches from
right to left, whereas `string-index' searches from left to
right.
[srfi-13.c:1556]

string-split
(string-split ch string) => list
Splits the string `string' into pieces, using `ch' as the
delimiting character. Returns a list of strings, where the stings may be
empty if two or more delimiting characters are in `string' without
characters inbetween.
[stringfun.c:951]

string-suffix-ci?
(string-suffix-ci? s1 s2 [start1 end1 start2 end2]) => boolean
Return `#t' if `s1' is a suffix of `s2'.  Case is
ignored when comparing characters.
[srfi-13.c:1026]

string-suffix-length
(string-suffix-length s1 s2 [start1 end1 start2 end2]) => integer
Return the length of the longest common suffix of the two strings.
[srfi-13.c:798]

string-suffix-length-ci
(string-suffix-length-ci s1 s2 [start1 end1 start2 end2]) => integer
Return the length of the longest common suffix of the two strings.
Case is ignored when comparing characters.
[srfi-13.c:842]

string-suffix?
(string-suffix? s1 s2 [start1 end1 start2 end2]) => boolean
Return `#t' if `s1' is a suffix of `s2'.
[srfi-13.c:979]

string-tabulate
(string-tabulate proc len) => string
Create a string o length `len', where each character is initialized from
the value returned by applying `proc' to the character index.
[srfi-13.c:556]

string-take
(string-take s nchars) => string
Return the first `nchars' characters of `s'.
[srfi-13.c:1183]

string-take-right
(string-take-right s nchars) => string
Return the last `nchars' characters of `s'.
[srfi-13.c:1206]

string-titlecase
(string-titlecase s [start end]) => string
Upper-case all characters in `s' which are starting words, returning
a newly allocated string.
`start' and `end' delimit the region of operation and default to
0 and the length of `s'.
[srfi-13.c:273]

string-titlecase!
(string-titlecase! s [start end]) => string
Upper-case all characters in `s' which are starting words, modifying
S in-place.
`start' and `end' delimit the region of operation and default to
0 and the length of `s'.
[srfi-13.c:218]

string-trim
(string-trim s [char/pred start end]) => string
Skip all characters matching `char' or passing application of
`pred' at the left of the string.  `start' and `end' are
optional parameters to restrict operation to the characters between
these indices.
[srfi-13.c:297]

string-trim-both
(string-trim-both s [char/pred start end]) => string
Skip all characters matching `char' or passing application of
`pred' at both ends of the string.  `start' and `end'
are optional parameters to restrict operation to the characters
between these indices.
[srfi-13.c:407]

string-trim-right
(string-trim-right s [char/pred start end]) => string
Skip all characters matching `char' or passing application of
`pred' at the right of the string.  `start' and `end'
are optional parameters to restrict operation to the characters
between these indices.
[srfi-13.c:352]

string-upcase
(string-upcase s [start end]) => string
Convert all characters in `s' to upper case, returning a newly allocated
string.
`start' and `end' delimit the region of operation and default to
0 and the length of `s'.
[srfi-13.c:126]

string-upcase!
(string-upcase! s [start end]) => string
Convert all characters in `s' to upper case, modifying `s' in-place.
`start' and `end' delimit the region of operation and default to
0 and the length of `s'.
[srfi-13.c:82]

string<=?
(string<=? string1 string2) => boolean
Returns `#t' if `string1' is lexicographically less or equal to
`string2', `#f' otherwise.
[stringfun.c:363]

string<?
(string<? string1 string2) => boolean
Returns `#t' if `string1' is lexicographically less than
`string2', `#f' otherwise.
[stringfun.c:332]

string=?
(string=? string1 string2) =>
Return `#t' if `string1' is the same string as `string2',
`#f' otherwise.
[stringfun.c:302]

string>=?
(string>=? string1 string2) => boolean
Returns `#t' if `string1' is lexicographically greater or equal
to `string2', `#f' otherwise.
[stringfun.c:425]

string>?
(string>? string1 string2) => boolean
Returns `#t' if `string1' is lexicographically greater than
`string2', `#f' otherwise.
[stringfun.c:394]

string?
(string? obj) => boolean
Return `#t' if `obj' is a string, `#f' otherwise.
[stringfun.c:107]

strptime
(strptime format string) => pair
Parse the string `string' according to the format specifier
`format'.  Check out `man strptime' for the format
specification.  Returns a pair consisting of a time vector and the
number of characters of `string' which have been used up when
parsing.  This procedure is essentialy the counterpart of
`strftime'.
[posix.c:2381]

substring
(substring string start end) => string
Return a string formed from the characters of `string' starting at
`start' (inclusive) and ending with `end' (exclusive).  An error
is signalled if the following equation is not satisfied: 0 <=
`start' <= `end' <= `(string-length' `string'`)'
[stringfun.c:648]

symbol->string
(symbol->string symbol) => string
Converts `symbol' to a string.
[symbol.c:67]

symbol-table
(symbol-table) => vector
Return the global symbol table.  The symbol table is a vector of symbol
lists.
[misc.c:438]

symbol?
(symbol? obj) => boolean
Returns `#t' if `obj' is a symbol, `#f' otherwise.
[symbol.c:50]

symlink
(symlink oldpath newpath) => *unspecified*
Creates a new symbolic link to an existing file.  If `newpath'
exists it will not be overwritten.  The return value is not specified.
This function may raise a `system-error' exception if an error
occurs.
[posix.c:1415]

sync
(sync) => *unspecified*
Force all dirty block from the cache of the operating system to be
written to the disks.  This function may raise a `system-error'
exception if an error occurs.
[posix.c:1995]

syntax-rules
(syntax-rules (literal ...) rule ...) => syntax-object
Define a syntactic form.  `literals' is a list of symbols which are to
be treated literally in the `rules'.  Each rule has the form
`(@var{pattern' `templace')}, where each `templace' has the
form `(@var{keyword' `pattern' `')} and each `template'
has the form `constant', `symbol', `(@var{template' `')}
or `#(@var{template' `')}.
[macros.c:982]

sys:pipe
(sys:pipe) => pair
Creates a pair of file descriptors, pointing to a pipe inode. The car of
the returned pair is a file descriptor for reading, the cdr is a file
descriptor for writing.  This function may raise a `system-error'
exception if an error occurs.
[posix.c:1078]

sys:read
(sys:read fd cnt) => u8vec
Read `count' bytes from the file referenced by the file descriptor
`fd' and returns a homogenous unsigned 8-bit vector containing those
bytes.  This function may raise a `system-error' exception if an
error occurs.
[posix.c:1313]

sys:read!
(sys:read! fd u8vec cnt) => *unspecified*
Read `count' bytes from the file referenced by the file descriptor
`fd' and stores them into the homogenous unsigned 8-bit vector
`u8vec'.  The return value is not specified.  This function may
raise a `system-error' exception if an error occurs.
[posix.c:1269]

sys:write
(sys:write fd u8vec cnt) => *unspecified*
Write `count' bytes from the homogenous unsigned 8-bit vector
`u8vec' to the file referenced by the file descriptor `fd'.
Returns the number of bytes actually written.  This function may raise a
`system-error' exception if an error occurs.
[posix.c:1225]

system
(system [command]) => integer|boolean
Execute the given `command' using the operating system's command
processor and return the exit code of the command.  If `command' is not
given, test whether a command processor is available and return `#t' if
it is, `#f' otherwise.
[posix.c:231]

system-error
Exception
Thrown when a system call fails.
[posix.c:3131]

take
(take list k) => list
Return a list containing the first `k' elements of
`list'. Return `list' if `k' is larger then the length
of `list'.
[srfi-1.c:96]

take!
(take! list k) => list
Return a list containing the first `k' elements of
`list'. Return `list' if `k' is larger then the length
of `list'.  The parameter list `list' may be modified as a
side effect.
[srfi-1.c:127]

take-right
(take-right list k) => list
Return a list containing the last `k' elements of `list'.  Return
`list' if `k' is greater than or equal to the length of the list,
return the empty list if `k' is <= 0.
[srfi-1.c:161]

tan
(tan z) => number
Return the tangent of `z'.
[number.c:1741]

tenth
(tenth list) => object
Return the tenth element from `list'.
[srfi-1.c:1009]

third
(third list) => object
Return the third element from `list'.
[srfi-1.c:844]

throw
(throw tag rest ...) => *no-return*
Throw an exception with the exception tag `tag'.  This call does not
return, but will pass control to the next enclosing `catch' procedure
which either specified the exception tag `tag' or `#t'.
[control.c:205]

tmpfile
(tmpfile) =>  port
The `tmpfile' procedure generates a unique temporary filename in
the standard directory for temporary files (normally `/tmp') .  The
temporary file is then opened in binary read/write (w+b) mode.  The file
will be automatically deleted when it is closed or the program
terminates.  The return value is a port open for input and output.  This
function may raise a `system-error' exception if an error occurs.
[posix.c:2290]

tmpnam
(tmpnam) => string
The `tmpnam' procedure generates a unique temporary filename in the
standard directory for temporary files (normally `/tmp').
[posix.c:2255]

toplevel
(toplevel) => *no-return*
This procedure passes control back to the top-level read-eval-print-loop
if in interactive mode and terminates script evaluation if in script
mode.  This procedure does not return.
[control.c:272]

trace
(trace proc on/off) => *unspecified*
If `on/off' is true, start tracing procedure `proc', otherwise,
switch tracing for `proc' off.
[eval.c:2366]

transcript-off
(transcript-off) => *unspecified*
Turn off the transcription started with `transcript-off'.
[eval.c:2338]

transcript-on
(transcript-on filename) => *unspecified*
Start transcription to the file called `filename'.  All following
expression read at the read-eval-print loop will be printed to the file
together with their evaluation result(s).
[eval.c:2312]

truncate
(truncate x) => integer
Return the closest integer to `x' whose absolute value is not larger
than the absolute value of `x'.
[number.c:1983]

u16vector
(u16vector num ...) => vector
Create a homogenous unsigned 16-bit vector holding all the unsigned 16-bit
values `num's passed as arguments.
[uvector.c:1042]

u16vector->list
(u16vector->list vec) => list
Return a list containing the elements of the unsigned 16-bit vector
`vec'.
[uvector.c:1148]

u16vector-fill!
(u16vector-fill! vec num) => *undefined*
Store unsigned 16-bit value `num' in all elements of the unsigned 16-bit
vector `vec', overwriting the old contents of `vec'.
[uvector.c:1207]

u16vector-length
(u16vector-length vec) => integer
Return the number of elements the homogenous unsigned 16-bit vector `vec'
can hold.
[uvector.c:1078]

u16vector-ref
(u16vector-ref vec n) => object
Return the unsigned 16-bit value stored at index `n' in the vector
homogenous unsigned 16-bit `vec'.  The index `n' is zero-based.
[uvector.c:1096]

u16vector-set!
(u16vector-set! vec n num) => *undefined*
Store the unsigned 16-bit value at index `n' into the unsigned 16-bit
vector `vec'.  The index `n' is zero-based.
[uvector.c:1119]

u16vector?
(u16vector? obj) => boolean
Return `#t', if `obj' is a homogenous unsigned 16-bit vector,
`#f' otherwise.
[uvector.c:989]

u32vector
(u32vector num ...) => vector
Create a homogenous unsigned 32-bit vector holding all the unsigned 32-bit
values `num's passed as arguments.
[uvector.c:1646]

u32vector->list
(u32vector->list vec) => list
Return a list containing the elements of the unsigned 32-bit vector
`vec'.
[uvector.c:1745]

u32vector-fill!
(u32vector-fill! vec num) => *undefined*
Store unsigned 32-bit value `num' in all elements of the unsigned 32-bit
vector `vec', overwriting the old contents of `vec'.
[uvector.c:1800]

u32vector-length
(u32vector-length vec) => integer
Return the number of elements the homogenous unsigned 32-bit vector `vec'
can hold.
[uvector.c:1678]

u32vector-ref
(u32vector-ref vec n) => object
Return the unsigned 32-bit value stored at index `n' in the vector
homogenous unsigned 32-bit `vec'.  The index `n' is zero-based.
[uvector.c:1696]

u32vector-set!
(u32vector-set! vec n num) => *undefined*
Store the unsigned 32-bit value at index `n' into the unsigned 32-bit
vector `vec'.  The index `n' is zero-based.
[uvector.c:1719]

u32vector?
(u32vector? obj) => boolean
Return `#t', if `obj' is a homogenous unsigned 32-bit vector,
`#f' otherwise.
[uvector.c:1594]

u64vector
(u64vector num ...) => vector
Create a homogenous unsigned 64-bit vector holding all the unsigned 64-bit
values `num's passed as arguments.
[uvector64.c:404]

u64vector->list
(u64vector->list vec) => list
Return a list containing the elements of the unsigned 64-bit vector
`vec'.
[uvector64.c:503]

u64vector-fill!
(u64vector-fill! vec num) => *undefined*
Store unsigned 64-bit value `num' in all elements of the unsigned 64-bit
vector `vec', overwriting the old contents of `vec'.
[uvector64.c:559]

u64vector-length
(u64vector-length vec) => integer
Return the number of elements the homogenous unsigned 64-bit vector `vec'
can hold.
[uvector64.c:436]

u64vector-ref
(u64vector-ref vec n) => object
Return the unsigned 64-bit value stored at index `n' in the vector
homogenous unsigned 64-bit `vec'.  The index `n' is zero-based.
[uvector64.c:454]

u64vector-set!
(u64vector-set! vec n num) => *undefined*
Store the unsigned 64-bit value at index `n' into the unsigned 64-bit
vector `vec'.  The index `n' is zero-based.
[uvector64.c:477]

u64vector?
(u64vector? obj) => boolean
Return `#t', if `obj' is a homogenous unsigned 64-bit vector,
`#f' otherwise.
[uvector64.c:352]

u8vector
(u8vector num ...) => vector
Create a homogenous unsigned 8-bit vector holding all the unsigned 8-bit
values `num's passed as arguments.
[uvector.c:423]

u8vector->list
(u8vector->list vec) => list
Return a list containing the elements of the unsigned 8-bit vector `vec'.
[uvector.c:528]

u8vector->string
(u8vector->string vec) => string
Convert the homogenous unsigned 8-bit vector `vec' to a string by taking
each value from the vector, converting it to a character and composing
the characters to a string.
[uvector.c:2706]

u8vector-fill!
(u8vector-fill! vec num) => *undefined*
Store unsigned 8-bit value `num' in all elements of the unsigned 8-bit
vector `vec', overwriting the old contents of `vec'.
[uvector.c:587]

u8vector-length
(u8vector-length vec) => integer
Return the number of elements the homogenous unsigned 8-bit vector `vec'
can hold.
[uvector.c:459]

u8vector-ref
(u8vector-ref vec n) => object
Return the unsigned 8-bit value stored at index `n' in the vector
homogenous unsigned 8-bit `vec'.  The index `n' is zero-based.
[uvector.c:477]

u8vector-set!
(u8vector-set! vec n num) => *undefined*
Store the unsigned 8-bit value at index `n' into the unsigned 8-bit
vector `vec'.  The index `n' is zero-based.
[uvector.c:500]

u8vector?
(u8vector? obj) => boolean
Return `#t', if `obj' is a homogenous unsigned 8-bit vector,
`#f' otherwise.
[uvector.c:370]

umask
(umask [mask]) => integer
`umask' sets the umask to `(logand mask #o777)'.  The
umask is used by open(2) to set initial file permissions on a
newly-created file.  Specifically, permissions in the umask are
turned off from the mode argument to open(2) (so, for example, the
common umask default value of 022 results in new files being created
with permissions 0666 & ~022 = 0644 = rw-r--r-- in the usual case
where the mode is specified as 0666).  If `mask' is not given,
the current umask value is returned, without changing the umask for
the process.
[posix.c:2328]

uname
(uname) => vector
Return a vector containing information about the system. This
function may raise a `system-error' exception if an error
occurs.  The returned vector contains the following fields: sysname,
nodename, release, version, machine.
[posix.c:2171]

undefine
(undefine var) => *undefined*
Make the variable `var' undefined in the current environment.
[syntax.c:724]

unless
(unless test stmt ...) => *anything*
If `test' evaluates to the false value, all `stmt's are executed in
order.  The returned value is undefined if the `stmt's are not evaluated,
otherwise the value of the last statement is returned.
[init.scm:83]

unlink
(unlink filename) => *unspecified*
Deletes a name from the filesystem. If that name was the last link to a
file and no processes have the file open the file is deleted and the
space it was using is made available for reuse.  The return value is not
specified.  This function may raise a `system-error' exception if
an error occurs.
[posix.c:1356]

unquote
(unquote obj) => object
Evaluate `obj'.  Only allowed in `quasiquote' forms.
`(unquote o)' is equivalent to `,o'.
[syntax.c:502]

unquote-splicing
(unquote-splicing obj) => object
Evaluate `obj' and splice it into the surrounding list.  Only allowed
in `quasiquote' forms. `(unquote-splicing o)' is equivalent to
`,@o'.
[syntax.c:509]

unread-char
(unread-char char [port]) => char
Put the character `char' back onto the port `port', or the
current input port if not specifed, so that it will be read by the
next call to `read-char'.  Return the given character
`char'.
[iofun.c:201]

use-modules
(use-modules name0 name1 ...) => *unspecified*
Import all modules listed as `names'.  If any module is not yet
loaded, it will be loaded using the load path.  Modules imported by any
of the imported modules will be loaded recursively.
[modules.c:391]

utime
(utime filename [timelist]) => *unspecified*
If `timelist' is omitted, set the access and modification time for
the file `filename' to the current time.  Otherwise, `timelist'
must be a list of two integer values, which will be used to set the
access and modification time of `filename'.  This function may raise
a `system-error' exception if an error occurs.
[posix.c:2211]

values
(values obj ...)
Create multiple values.  Used to return more than one value from a
procedure.
[values.c:64]

vector
(vector obj0 ...) => vector
Create a vector holding all the `obj's passed as arguments.
[vector.c:123]

vector->list
(vector->list vec) => list
Return a list containing the elements of the vector `vec'.
[vector.c:243]

vector-fill!
(vector-fill! vec obj) => *undefined*
Store `obj' in all elements of the vector `vec', overwriting the
old contents of `vec'.
[vector.c:296]

vector-length
(vector-length vec) => integer
Return the number of elements the vector `vec' can hold.
[vector.c:152]

vector-ref
(vector-ref vec n) => object
Return the element stored at index `n' in the vector `vec'.  The
index `n' is zero-based.
[vector.c:170]

vector-set!
(vector-set! vec n obj) => *undefined*
Store the object `obj' a index `n' into the vector `vec'.  The
index `n' is zerobased.
[vector.c:201]

vector?
(vector? obj) => boolean
Return `#t', if `obj' is a vector, `#f' otherwise.
[vector.c:68]

wait
(wait) => pair
Waits for any child process to terminate and returns a pair whose car is
the process id of the child and whose cdr is the exit code.  This
function may raise a `system-error' exception if an error occurs.
[posix.c:1635]

waitpid
(waitpid pid [options]) => pair
Waits until child process `pid' has terminated.  For usage of the
`options' argument, refer to the `waitpid' man page.  This
function may raise a `system-error' exception if an error occurs.
[posix.c:1661]

when
(when test stmt ...)
If `test' evaluates to a true value, all `stmt's are executed in
order.  The returned value is undefined if the `stmt's are not evaluated,
otherwise the value of the last statement is returned.
[init.scm:73]

while
(while test stmt...) => *anything*
Evaluate `test' and if it evaluates to a true value, evaluate the
`stmt's in order.  Repeat this until `test' returns `#f'.
Inside the `stmt's, the procedures `break' and `continue' are
defined, which exit the innermost enclosing while statement and restart
the loop.  Normally, the result of the last statement is returned.
[init.scm:105]

with-error-to-file
(with-error-to-file filename thunk)
Call `thunk', redirecting error output to the file called
`filename'. Return the value returned by `thunk'.
[iofun.c:1022]

with-error-to-port
(with-error-to-port port thunk)
Call `thunk', redirecting error output to `port'.  Return the
value returned by `thunk'.
[iofun.c:1239]

with-error-to-string
(with-error-to-string thunk) => string
Call `thunk', redirecting error output to a string port.  Return the
accumulated string.
[iofun.c:1162]

with-input-from-file
(with-input-from-file filename thunk)
Call `thunk', redirecting input ro read from the file called
`filename'. Return the value returned by `thunk'.
[iofun.c:947]

with-input-from-port
(with-input-from-port port thunk)
Call `thunk', redirecting input to read from `port'.  Return the
value returned by `thunk'.
[iofun.c:1189]

with-input-from-string
(with-input-from-string string thunk) => object
Call `thunk', redirecting input to read from a string port reading
from `string'. Return the value returned from `thunk'.
[iofun.c:1107]

with-output-to-file
(with-output-to-file filename thunk)
Call `thunk', redirecting output to the file called `filename'.
Return the value returned by `thunk'.
[iofun.c:984]

with-output-to-port
(with-output-to-port port thunk)
Call `thunk', redirecting output to `port'.  Return the value
returned by `thunk'.
[iofun.c:1214]

with-output-to-string
(with-output-to-string thunk) => string
Call `thunk', redirecting output to a string port. Return the
accumulated string.
[iofun.c:1135]

write
(write obj [port]) => *unspecified*
Print `obj' to `port', or to the current output port if not
specified. `write' prints the object in the read syntax of the
object, so that it can be read in again using `read'.
[iofun.c:64]

write-char
(write-char char [port]) => *unspecified*
Print the character `char' to `port', or to the current output
port if not given.  `char' is not quoted when printing.
[iofun.c:85]

write-line
(write-line obj [port]) => *unspecified*
Write the object `obj' to the output port `port', or the current
output port if not specified.  Then terminate the current output line
with a newline character.
[iofun.c:350]

wrong-number-args
Exception
This is thrown when a procedure is applied to a number of arguments
not supported by the arity of the procedure.
[eval.c:2437]

wrong-type-argument
Exception
This is thrown when a procedure receives an argument of the wrong type.
[eval.c:2445]

xcons
(xcons d a) => pair
Equivalent to `(cons obj2 obj1)', and is of utility only as a value
to be conveniently passed to higher--order procedures. (`xcons'
stands for `exchanged cons'.)
[srfi-1.c:364]

zero?
(zero? obj) => boolean
Return `#t' if `obj' is equal to zero, `#f' otherwise.
[number.c:272]

