[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] GNU Guile branch, master, updated. release_1-9-11-132-ge
|
From: |
Julian Graham |
|
Subject: |
[Guile-commits] GNU Guile branch, master, updated. release_1-9-11-132-gea28e98 |
|
Date: |
Tue, 22 Jun 2010 03:20:44 +0000 |
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Guile".
http://git.savannah.gnu.org/cgit/guile.git/commit/?id=ea28e981342fd1d381e489e57cddde97eb390442
The branch, master has been updated
via ea28e981342fd1d381e489e57cddde97eb390442 (commit)
from 7cdd1615e055376e001e600a7dad0487b5aceab1 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit ea28e981342fd1d381e489e57cddde97eb390442
Author: Julian Graham <address@hidden>
Date: Mon Jun 21 23:10:13 2010 -0400
Integrate complete R6RS standard libraries documentation.
* doc/ref/r6rs.texi: Reshuffle Andy Wingo's introductory notes; add more
detailed @subsubsections for each library.
-----------------------------------------------------------------------
Summary of changes:
doc/ref/r6rs.texi | 2274 ++++++++++++++++++++++++++++++++++++++++++++++++++---
1 files changed, 2182 insertions(+), 92 deletions(-)
diff --git a/doc/ref/r6rs.texi b/doc/ref/r6rs.texi
index c8bc815..afe9ba4 100644
--- a/doc/ref/r6rs.texi
+++ b/doc/ref/r6rs.texi
@@ -19,110 +19,2200 @@ their integration with Guile modules.
@node R6RS Incompatibilities
@subsection Incompatibilities with the R6RS
-There are some incompatibilities between Guile and the R6RS. Some of them are
-intentional, some of them are bugs, and some are simply unimplemented features.
-Please let the Guile developers know if you find one that is not on this list.
+There are some incompatibilities between Guile and the R6RS. Some of
+them are intentional, some of them are bugs, and some are simply
+unimplemented features. Please let the Guile developers know if you
+find one that is not on this list.
@itemize
@item
-The R6RS specifies many situations in which a conforming implementation must
-signal a specific error. Guile doesn't really care about that too much -- if a
-correct R6RS program would not hit that error, we don't bother checking for it.
+The R6RS specifies many situations in which a conforming implementation
+must signal a specific error. Guile doesn't really care about that too
+much --- if a correct R6RS program would not hit that error, we don't
+bother checking for it.
@item
-Multiple @code{library} forms in one file are not yet supported. This is
because
-the expansion of @code{library} sets the current module, but does not restore
-it. This is a bug.
+Multiple @code{library} forms in one file are not yet supported. This
+is because the expansion of @code{library} sets the current module, but
+does not restore it. This is a bug.
@item
-A @code{set!} to a variable transformer may only expand to an expression, not a
-definition -- even if the original @code{set!} expression was in definition
-context.
+A @code{set!} to a variable transformer may only expand to an
+expression, not a definition --- even if the original @code{set!}
+expression was in definition context.
@end itemize
@node R6RS Standard Libraries
@subsection R6RS Standard Libraries
-The R6RS standard defines a core language and a number of standard libraries.
-Here we briefly list the libraries that have been implemented for Guile.
-
-All of these libraries are available as Guile modules, for use in standard
Guile
-code, via @code{use-modules}, or for use in portable R6RS code, via the
address@hidden and @code{import} forms. @xref{R6RS Libraries}, for more
-information.
-
-We do not attempt to document these libraries fully here, as most of their
-functionality is already available in Guile itself. The expectation is that
most
-Guile users will use the well-known and well-documented Guile modules. These
-R6RS libraries are mostly useful to users who want to port their code to other
-R6RS systems, in which case a copy of the R6RS report itself is necessary. It
-may be found at the R6RS web page, @url{http://r6rs.org/}.
-
-First, there is the base library, defined in the base R6RS report:
-
address@hidden
-(use-modules (rnrs base))
address@hidden example
-
-One may also import it to the current module using the R6RS @code{import} form:
-
address@hidden
-(import (rnrs base))
address@hidden example
-
-All of the @code{rnrs} modules have the version of @code{(6)}, which may be
-specified when importing the module:
-
address@hidden
-(import (rnrs base (6)))
-(use-modules ((rnrs base) #:version (6)))
address@hidden example
-
address@hidden Version References}, for more information on versions.
-
-Next there is a set of libraries that collectively form the @code{(rnrs)}
-composite library. The following statements are equivalent:
-
address@hidden
-(import (rnrs))
-
-(use-modules (rnrs))
-
-(import (rnrs arithmetic bitwise (6))
- (rnrs arithmetic fixnums (6))
- (rnrs arithmetic flonums (6))
- (rnrs base (6))
- (rnrs bytevectors)
- (rnrs conditions (6))
- (rnrs control (6))
- (rnrs enums (6))
- (rnrs exceptions (6))
- (rnrs files (6))
- (rnrs hashtables (6))
- (rnrs io ports)
- (rnrs io simple (6))
- (rnrs lists (6))
- (rnrs programs (6))
- (rnrs records inspection (6))
- (rnrs records procedural (6))
- (rnrs records syntactic (6))
- (rnrs sorting (6))
- (rnrs syntax-case (6)))
address@hidden example
-
-Finally there are a number of modules that the @code{(rnrs)} module does not
-re-export:
-
address@hidden
-(import (rnrs mutable-pairs (6))
- (rnrs mutable-strings (6))
- (rnrs r5rs (6))
- (rnrs eval (6))
- (rnrs unicode (6)))
address@hidden example
-
-See the R6RS Standard Libraries specification, for more information on these
-modules.
+In contrast with earlier versions of the Revised Report, the R6RS
+organizes the procedures and syntactic forms required of conforming
+implementations into a set of ``standard libraries'' which can be
+imported as necessary by user programs and libraries. Here we briefly
+list the libraries that have been implemented for Guile.
+
+We do not attempt to document these libraries fully here, as most of
+their functionality is already available in Guile itself. The
+expectation is that most Guile users will use the well-known and
+well-documented Guile modules. These R6RS libraries are mostly useful
+to users who want to port their code to other R6RS systems.
+
+The documentation in the following sections reproduces some of the
+content of the library section of the Report, but is mostly intended to
+provide supplementary information about Guile's implementation of the
+R6RS standard libraries. For complete documentation, design rationales
+and further examples, we advise you to consult the ``Standard
+Libraries'' section of the Report (@pxref{Standard Libraries,
+R6RS Standard Libraries,, r6rs, The Revised^6 Report on the Algorithmic
+Language Scheme}).
+
address@hidden
+* Library Usage:: What to know about Guile's library support.
+* rnrs base:: The base library.
+* rnrs unicode:: Access to Unicode operations.
+* rnrs bytevectors:: Functions for working with binary data.
+* rnrs lists:: List utilities.
+* rnrs sorting:: Sorting for lists and vectors.
+* rnrs control:: Additional control structures.
+
+* R6RS Records:: A note about R6RS records.
+* rnrs records syntactic:: Syntactic API for R6RS records.
+* rnrs records procedural:: Procedural API for R6RS records.
+* rnrs records inspection:: Reflection on R6RS records.
+
+* rnrs exceptions:: Handling exceptional situations.
+* rnrs conditions:: Data structures for exceptions.
+
+* I/O Conditions:: Predefined I/O error types.
+* rnrs io ports:: Support for port-based I/O.
+* rnrs io simple:: High-level I/O API.
+
+* rnrs files:: Functions for working with files.
+* rnrs programs:: Functions for working with processes.
+* rnrs arithmetic fixnums:: Fixed-precision arithmetic operations.
+* rnrs arithmetic flonums:: Floating-point arithmetic operations.
+* rnrs arithmetic bitwise:: Exact bitwise arithmetic operations.
+* rnrs syntax-case:: Support for `syntax-case' macros.
+* rnrs hashtables:: Hashtables.
+* rnrs enums:: Enumerations.
+* rnrs:: The composite library.
+* rnrs eval:: Support for on-the-fly evaluation.
+* rnrs mutable-pairs:: Support for mutable pairs.
+* rnrs mutable-strings:: Support for mutable strings.
+* rnrs r5rs:: Compatibility layer for R5RS Scheme.
+
address@hidden menu
+
address@hidden Library Usage
address@hidden Library Usage
+
+Guile implements the R6RS `library' form as a transformation to a native
+Guile module definition. As a consequence of this, all of the libraries
+described in the following subsections, in addition to being available
+for use by R6RS libraries and top-level programs, can also be imported
+as if they were normal Guile modules --- for example, via a
address@hidden form. For example, the R6RS ``composite'' library
+can be imported by:
+
address@hidden
+ (import (rnrs (6)))
address@hidden lisp
+
address@hidden
+ (use-modules ((rnrs) :version (6)))
address@hidden lisp
+
+For more information on Guile's library implementation, see
+(@pxref{R6RS Libraries}).
+
address@hidden rnrs base
address@hidden rnrs base
+
+The @code{(rnrs base (6))} library exports the procedures and syntactic
+forms described in the main section of the Report
+(@pxref{Base library, R6RS Base library,, r6rs,
+The Revised^6 Report on the Algorithmic Language Scheme}). They are
+grouped below by the existing manual sections to which they correspond.
+
address@hidden {Scheme Procedure} boolean? obj
address@hidden {Scheme Procedure} not x
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} symbol? obj
address@hidden {Scheme Procedure} symbol->string sym
address@hidden {Scheme Procedure} string->symbol str
address@hidden Primitives}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} char? obj
address@hidden {Scheme Procedure} char=?
address@hidden {Scheme Procedure} char<?
address@hidden {Scheme Procedure} char>?
address@hidden {Scheme Procedure} char<=?
address@hidden {Scheme Procedure} char>=?
address@hidden {Scheme Procedure} integer->char n
address@hidden {Scheme Procedure} char->integer chr
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} list? x
address@hidden {Scheme Procedure} null? x
address@hidden Predicates}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} pair? x
address@hidden {Scheme Procedure} cons x y
address@hidden {Scheme Procedure} car pair
address@hidden {Scheme Procedure} cdr pair
address@hidden {Scheme Procedure} caar pair
address@hidden {Scheme Procedure} cadr pair
address@hidden {Scheme Procedure} cdar pair
address@hidden {Scheme Procedure} cddr pair
address@hidden {Scheme Procedure} caaar pair
address@hidden {Scheme Procedure} caadr pair
address@hidden {Scheme Procedure} cadar pair
address@hidden {Scheme Procedure} cdaar pair
address@hidden {Scheme Procedure} caddr pair
address@hidden {Scheme Procedure} cdadr pair
address@hidden {Scheme Procedure} cddar pair
address@hidden {Scheme Procedure} cdddr pair
address@hidden {Scheme Procedure} caaaar pair
address@hidden {Scheme Procedure} caaadr pair
address@hidden {Scheme Procedure} caadar pair
address@hidden {Scheme Procedure} cadaar pair
address@hidden {Scheme Procedure} cdaaar pair
address@hidden {Scheme Procedure} cddaar pair
address@hidden {Scheme Procedure} cdadar pair
address@hidden {Scheme Procedure} cdaadr pair
address@hidden {Scheme Procedure} cadadr pair
address@hidden {Scheme Procedure} caaddr pair
address@hidden {Scheme Procedure} caddar pair
address@hidden {Scheme Procedure} cadddr pair
address@hidden {Scheme Procedure} cdaddr pair
address@hidden {Scheme Procedure} cddadr pair
address@hidden {Scheme Procedure} cdddar pair
address@hidden {Scheme Procedure} cddddr pair
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} number? obj
address@hidden Tower}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string? obj
address@hidden Predicates}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} procedure? obj
address@hidden Properties}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} define name value
address@hidden {Scheme Syntax} set! variable-name value
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} define-syntax keyword expression
address@hidden {Scheme Syntax} let-syntax ((keyword transformer) ...) exp ...
address@hidden {Scheme Syntax} letrec-syntax ((keyword transformer) ...) exp ...
address@hidden Macros}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} identifier-syntax exp
address@hidden Macros}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} syntax-rules literals (pattern template) ...
address@hidden Rules}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} lambda formals body
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} let bindings body
address@hidden {Scheme Syntax} let* bindings body
address@hidden {Scheme Syntax} letrec bindings body
address@hidden Bindings}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} let-values bindings body
address@hidden {Scheme Syntax} let*-values bindings body
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} begin expr1 expr2 ...
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} quote expr
address@hidden {Scheme Syntax} quasiquote expr
address@hidden {Scheme Syntax} unquote expr
address@hidden {Scheme Syntax} unquote-splicing expr
address@hidden Syntax}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} if test consequence [alternate]
address@hidden {Scheme Syntax} cond clause1 clause2 ...
address@hidden {Scheme Syntax} case key clause1 clause2 ...
address@hidden cond case}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} and expr ...
address@hidden {Scheme Syntax} or expr ...
address@hidden or}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} eq? x y
address@hidden {Scheme Procedure} eqv? x y
address@hidden {Scheme Procedure} equal? x y
address@hidden {Scheme Procedure} symbol=? symbol1 symbol2 ...
address@hidden, for documentation.
+
address@hidden is identical to @code{eq?}.
address@hidden deffn
+
address@hidden {Scheme Procedure} complex? z
address@hidden Numbers}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} real-part z
address@hidden {Scheme Procedure} imag-part z
address@hidden {Scheme Procedure} make-rectangular real_part imaginary_part
address@hidden {Scheme Procedure} make-polar x y
address@hidden {Scheme Procedure} magnitude z
address@hidden {Scheme Procedure} angle z
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} sqrt z
address@hidden {Scheme Procedure} exp z
address@hidden {Scheme Procedure} expt z1 z2
address@hidden {Scheme Procedure} log z
address@hidden {Scheme Procedure} sin z
address@hidden {Scheme Procedure} cos z
address@hidden {Scheme Procedure} tan z
address@hidden {Scheme Procedure} asin z
address@hidden {Scheme Procedure} acos z
address@hidden {Scheme Procedure} atan z
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} real? x
address@hidden {Scheme Procedure} rational? x
address@hidden {Scheme Procedure} nan? x
address@hidden {Scheme Procedure} numerator x
address@hidden {Scheme Procedure} denominator x
address@hidden {Scheme Procedure} rationalize x eps
address@hidden and Rationals}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} exact? x
address@hidden {Scheme Procedure} inexact? x
address@hidden {Scheme Procedure} exact z
address@hidden {Scheme Procedure} inexact z
address@hidden, for documentation. The @code{exact} and
address@hidden procedures are identical to the @code{inexact->exact} and
address@hidden>inexact} procedures provided by Guile's code library.
address@hidden deffn
+
address@hidden {Scheme Procedure} integer? x
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} odd? n
address@hidden {Scheme Procedure} even? n
address@hidden {Scheme Procedure} gcd x ...
address@hidden {Scheme Procedure} lcm x ...
address@hidden Operations}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} =
address@hidden {Scheme Procedure} <
address@hidden {Scheme Procedure} >
address@hidden {Scheme Procedure} <=
address@hidden {Scheme Procedure} >=
address@hidden {Scheme Procedure} zero? x
address@hidden {Scheme Procedure} positive? x
address@hidden {Scheme Procedure} negative? x
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} fold f lst1 lst2 ...
address@hidden {Scheme Procedure} for-each f lst1 lst2 ...
address@hidden Fold and Map}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} list elem1 ... elemN
address@hidden Constructors}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} length lst
address@hidden {Scheme Procedure} list-ref lst k
address@hidden {Scheme Procedure} list-tail lst k
address@hidden Selection}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} append lst1 ... lstN
address@hidden {Scheme Procedure} reverse lst
address@hidden/Reverse}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} number->string n [radix]
address@hidden {Scheme Procedure} string->number str [radix]
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string char ...
address@hidden {Scheme Procedure} make-string k [chr]
address@hidden {Scheme Procedure} list->string lst
address@hidden Constructors}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string->list str [start [end]]
address@hidden/String Conversion}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string-length str
address@hidden {Scheme Procedure} string-ref str k
address@hidden {Scheme Procedure} string-copy str [start [end]]
address@hidden {Scheme Procedure} substring str start [end]
address@hidden Selection}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string<? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string>? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string<=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string>=? [s1 [s2 . rest]]
address@hidden Comparison}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string-append . args
address@hidden and Appending Strings}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string-for-each proc s [start [end]]
address@hidden Folding and Unfolding}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} + z1 ...
address@hidden {Scheme Procedure} - z1 z2 ...
address@hidden {Scheme Procedure} * z1 ...
address@hidden {Scheme Procedure} / z1 z2 ...
address@hidden {Scheme Procedure} max x1 x2 ...
address@hidden {Scheme Procedure} min x1 x2 ...
address@hidden {Scheme Procedure} abs x
address@hidden {Scheme Procedure} truncate x
address@hidden {Scheme Procedure} floor x
address@hidden {Scheme Procedure} ceiling x
address@hidden {Scheme Procedure} round x
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} div x1 x2
address@hidden {Scheme Procedure} mod x1 x2
address@hidden {Scheme Procedure} div-and-mod x1 x2
+These procedures implement number-theoretic division.
+
address@hidden returns two values, the respective results of
address@hidden(div x1 x2)} and @code{(mod x1 x2)}.
address@hidden deffn
+
address@hidden {Scheme Procedure} div0 x1 x2
address@hidden {Scheme Procedure} mod0 x1 x2
address@hidden {Scheme Procedure} div0-and-mod0 x1 x2
+These procedures are similar to @code{div}, @code{mod}, and
address@hidden, except that @code{mod0} returns values that lie
+within a half-open interval centered on zero.
address@hidden deffn
+
address@hidden {Scheme Procedure} exact-integer-sqrt k
+This procedure returns two nonnegative integer objects @code{s} and
address@hidden such that k = s^2 + r and k < (s + 1)^2.
address@hidden deffn
+
address@hidden {Scheme Procedure} real-valued? obj
address@hidden {Scheme Procedure} rational-valued? obj
address@hidden {Scheme Procedure} integer-valued? obj
+These procedures return @code{#t} if and only if their arguments can,
+respectively, be coerced to a real, rational, or integer value without a
+loss of numerical precision.
+
address@hidden will return @code{#t} for complex numbers whose
+imaginary parts are zero.
address@hidden deffn
+
address@hidden {Scheme Procedure} finite? x
address@hidden {Scheme Procedure} infinite? x
address@hidden returns @code{#t} if @var{x} is an infinite value,
address@hidden otherwise. @code{finite?} returns the negation of
address@hidden
address@hidden deffn
+
address@hidden {Scheme Syntax} assert expr
+Raises an @code{&assertion} condition if @var{expr} evaluates to
address@hidden; otherwise evaluates to the value of @var{expr}.
address@hidden deffn
+
address@hidden {Scheme Procedure} error who message irritant1 ...
address@hidden {Scheme Procedure} assertion-violation who message irritant1 ...
+These procedures raise compound conditions based on their arguments:
+If @var{who} is not @code{#f}, the condition will include a @code{&who}
+condition whose @code{who} field is set to @var{who}; a @code{&message}
+condition will be included with a @code{message} field equal to
address@hidden; an @code{&irritants} condition will be included with its
address@hidden list given by @code{irritant1 ...}.
+
address@hidden produces a compound condition with the simple conditions
+described above, as well as an @code{&error} condition;
address@hidden produces one that includes an
address@hidden&assertion} condition.
address@hidden deffn
+
address@hidden {Scheme Procedure} vector-map proc v
address@hidden {Scheme Procedure} vector-for-each proc v
+These procedures implement the @code{map} and @code{for-each} contracts
+over vectors.
address@hidden deffn
+
address@hidden {Scheme Procedure} vector . l
address@hidden {Scheme Procedure} vector? obj
address@hidden {Scheme Procedure} make-vector len
address@hidden {Scheme Procedure} make-vector len fill
address@hidden {Scheme Procedure} list->vector l
address@hidden {Scheme Procedure} vector->list v
address@hidden Creation}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} vector-length vector
address@hidden {Scheme Procedure} vector-ref vector k
address@hidden {Scheme Procedure} vector-set! vector k obj
address@hidden {Scheme Procedure} vector-fill! v fill
address@hidden Accessors}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} call-with-current-continuation proc
address@hidden {Scheme Procedure} call/cc proc
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} values arg1 ... argN
address@hidden {Scheme Procedure} call-with-values producer consumer
address@hidden Values}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} dynamic-wind in_guard thunk out_guard
address@hidden Wind}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} apply proc arg1 ... argN arglst
address@hidden Evaluation}, for documentation.
address@hidden deffn
+
address@hidden rnrs unicode
address@hidden rnrs unicode
+
+The @code{(rnrs unicode (6))} library provides procedures for
+manipulating Unicode characters and strings.
+
address@hidden {Scheme Procedure} char-upcase char
address@hidden {Scheme Procedure} char-downcase char
address@hidden {Scheme Procedure} char-titlecase char
address@hidden {Scheme Procedure} char-foldcase char
+These procedures translate their arguments from one Unicode character
+set to another. @code{char-upcase}, @code{char-downcase}, and
address@hidden are identical to their counterparts in the
+Guile core library; see (@pxref{Characters}) for documentation.
+
address@hidden returns the result of applying @code{char-upcase}
+to its argument, followed by @code{char-downcase} --- except in the case
+of the Turkic characters @code{U+0130} and @code{U+0131}, for which the
+procedure acts as the identity function.
address@hidden deffn
+
address@hidden {Scheme Procedure} char-ci=? char1 char2 char3 ...
address@hidden {Scheme Procedure} char-ci<? char1 char2 char3 ...
address@hidden {Scheme Procedure} char-ci>? char1 char2 char3 ...
address@hidden {Scheme Procedure} char-ci<=? char1 char2 char3 ...
address@hidden {Scheme Procedure} char-ci>=? char1 char2 char3 ...
+These procedures facilitate case-insensitive comparison of Unicode
+characters. They are identical to the procedures provided by Guile's
+core library. @xref{Characters}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} char-alphabetic? char
address@hidden {Scheme Procedure} char-numeric? char
address@hidden {Scheme Procedure} char-whitespace? char
address@hidden {Scheme Procedure} char-upper-case? char
address@hidden {Scheme Procedure} char-lower-case? char
address@hidden {Scheme Procedure} char-title-case? char
+These procedures implement various Unicode character set predicates.
+They are identical to the procedures provided by Guile's core library.
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} char-general-category char
address@hidden, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string-upcase string
address@hidden {Scheme Procedure} string-downcase string
address@hidden {Scheme Procedure} string-titlecase string
address@hidden {Scheme Procedure} string-foldcase string
+These procedures perform Unicode case folding operations on their input.
address@hidden Case Mapping}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string-ci=? string1 string2 string3 ...
address@hidden {Scheme Procedure} string-ci<? string1 string2 string3 ...
address@hidden {Scheme Procedure} string-ci>? string1 string2 string3 ...
address@hidden {Scheme Procedure} string-ci<=? string1 string2 string3 ...
address@hidden {Scheme Procedure} string-ci>=? string1 string2 string3 ...
+These procedures perform case-insensitive comparison on their input.
address@hidden Comparison}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string-normalize-nfd string
address@hidden {Scheme Procedure} string-normalize-nfkd string
address@hidden {Scheme Procedure} string-normalize-nfc string
address@hidden {Scheme Procedure} string-normalize-nfkc string
+These procedures perform Unicode string normalization operations on
+their input. @xref{String Comparison}, for documentation.
address@hidden deffn
+
address@hidden rnrs bytevectors
address@hidden rnrs bytevectors
+
+The @code{(rnrs bytevectors (6))} library provides procedures for
+working with blocks of binary data. This functionality is documented
+in its own section of the manual; @xref{Bytevectors}.
+
address@hidden rnrs lists
address@hidden rnrs lists
+
+The @code{(rnrs lists (6))} library provides procedures additional
+procedures for working with lists.
+
address@hidden {Scheme Procedure} find proc list
+This procedure is identical to the one defined in Guile's SRFI-1
+implementation. @xref{SRFI-1 Searching}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} for-all proc list1 list2 ...
address@hidden {Scheme Procedure} exists proc list1 list2 ...
+
+The @code{for-all} procedure is identical to the @code{every} procedure
+defined by SRFI-1; the @code{exists} procedure is identical to SRFI-1's
address@hidden @xref{SRFI-1 Searching}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} filter proc list
address@hidden {Scheme Procedure} partition proc list
+These procedures are identical to the ones provided by SRFI-1.
address@hidden Modification}, for a description of @code{filter};
+(@pxref{SRFI-1 Filtering and Partitioning}) for @code{partition}.
address@hidden deffn
+
address@hidden {Scheme Procedure} fold-left combine nil list1 list2 ... listn
address@hidden {Scheme Procedure} fold-right combine nil list1 list2 ... listn
+These procedures are identical to the @code{fold} and @code{fold-right}
+procedures provided by SRFI-1. @xref{SRFI-1 Fold and Map}, for
+documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} remp proc list
address@hidden {Scheme Procedure} remove obj list
address@hidden {Scheme Procedure} remv obj list
address@hidden {Scheme Procedure} remq obj list
address@hidden, @code{remv}, and @code{remq} are identical to the
address@hidden, @code{delv}, and @code{delq} procedures provided by
+Guile's core library; (@pxref{List Modification}) for their
+documentation. @code{remp} is identical to the alternate @code{remove}
+procedure provided by SRFI-1; @xref{SRFI-1 Deleting}.
address@hidden deffn
+
address@hidden {Scheme Procedure} memp proc list
address@hidden {Scheme Procedure} member obj list
address@hidden {Scheme Procedure} memv obj list
address@hidden {Scheme Procedure} memq obj list
address@hidden, @code{memv}, and @code{memq} are identical to the
+procedures provided by Guile's core library; (@pxref{List Searching})
+for their documentation. @code{memp} uses the specified predicate
+function @code{proc} to test elements of the list @var{list} --- it
+behaves similarly to @code{find}, except that it returns the first
+sublist of @var{list} whose @code{car} satisfies @var{proc}.
address@hidden deffn
+
address@hidden {Scheme Procedure} assp proc alist
address@hidden {Scheme Procedure} assoc obj alist
address@hidden {Scheme Procedure} assv obj alist
address@hidden {Scheme Procedure} assq obj alist
address@hidden, @code{assv}, and @code{assq} are identical to the
+procedures provided by Guile's core library;
+(@pxref{Alist Key Equality}) for their documentation. @code{assp} uses
+the specified predicate function @code{proc} to test keys in the
+association list @var{alist}.
address@hidden deffn
+
address@hidden {Scheme Procedure} cons* obj1 ... obj
address@hidden {Scheme Procedure} cons* obj
+This procedure is identical to the one exported by Guile's core
+library. @xref{List Constructors}, for documentation.
address@hidden deffn
+
address@hidden rnrs sorting
address@hidden rnrs sorting
+
+The @code{(rnrs sorting (6))} library provides procedures for sorting
+lists and vectors.
+
address@hidden {Scheme Procedure} list-sort proc list
address@hidden {Scheme Procedure} vector-sort proc vector
+These procedures return their input sorted in ascending order, without
+modifying the original data. @var{proc} must be a procedure that takes
+two elements from the input list or vector as arguments, and returns a
+true value if the first is ``less'' than the second, @code{#f}
+otherwise. @code{list-sort} returns a list; @code{vector-sort} returns
+a vector.
+
+Both @code{list-sort} and @code{vector-sort} are implemented in terms of
+the @code{stable-sort} procedure from Guile's core library.
address@hidden, for a discussion of the behavior of that procedure.
address@hidden deffn
+
address@hidden {Scheme Procedure} vector-sort! proc vector
+Performs a destructive, ``in-place'' sort of @var{vector}, using
address@hidden as described above to determine an ascending ordering of
+elements. @code{vector-sort!} returns an unspecified value.
+
+This procedure is implemented in terms of the @code{sort!} procedure
+from Guile's core library. @xref{Sorting}, for more information.
address@hidden deffn
+
address@hidden rnrs control
address@hidden rnrs control
+
+The @code{(rnrs control (6))} library provides syntactic forms useful
+for constructing conditional expressions and controlling the flow of
+execution.
+
address@hidden {Scheme Syntax} when test expression1 expression2 ...
address@hidden {Scheme Syntax} unless test expression1 expression2 ...
+The @code{when} form is evaluated by evaluating the specified @var{test}
+expression; if the result is a true value, the @var{expression}s that
+follow it are evaluated in order, and the value of the final
address@hidden becomes the value of the entire @code{when} expression.
+
+The @code{unless} form behaves similarly, with the exception that the
+specified @var{expression}s are only evaluated if the value of
address@hidden is false.
address@hidden deffn
+
address@hidden {Scheme Syntax} do ((variable init step) ...) (test expression
...) command ...
+This form is identical to the one provided by Guile's core library.
address@hidden do}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} case-lambda clause ...
+This form is identical to the one provided by Guile's core library.
address@hidden, for documentation.
address@hidden deffn
+
address@hidden R6RS Records
address@hidden R6RS Records
+
+The manual sections below describe Guile's implementation of R6RS
+records, which provide support for user-defined data types. The R6RS
+records API provides a superset of the features provided by Guile's
+``native'' records, as well as those of the SRFI-9 records API;
+(@pxref{Records}) and (@pxref{SRFI-9}) for a description of those
+interfaces.
+
+As with SRFI-9 and Guile's native records, R6RS records are constructed
+using a record-type descriptor that specifies attributes like the
+record's name, its fields, and the mutability of those fields.
+
+R6RS records extend this framework to support single inheritance via the
+specification of a ``parent'' type for a record type at definition time.
+Accessors and mutator procedures for the fields of a parent type may be
+applied to records of a subtype of this parent. A record type may be
address@hidden, in which case it cannot be used as the parent of another
+record type.
+
+The inheritance mechanism for record types also informs the process of
+initializing the fields of a record and its parents. Constructor
+procedures that generate new instances of a record type are obtained
+from a record constructor descriptor, which encapsulates the record-type
+descriptor of the record to be constructed along with a @dfn{protocol}
+procedure that defines how constructors for record subtypes delegate to
+the constructors of their parent types.
+
+A protocol is a procedure used by the record system at construction time
+to bind arguments to the fields of the record being constructed. The
+protocol procedure is passed a procedure @var{n} that accepts the
+arguments required to construct the record's parent type; this
+procedure, when invoked, will return a procedure @var{p} that accepts
+the arguments required to construct a new instance of the record type
+itself and returns a new instance of the record type.
+
+The protocol should in turn return a procedure that uses @var{n} and
address@hidden to initialize the fields of the record type and its parent
+type(s). This procedure will be the constructor returned by
+
+As a trivial example, consider the hypothetical record type
address@hidden, which encapsulates an x-y location on a screen, and
address@hidden, which has @code{pixel} as its parent type and stores an
+additional coordinate. The following protocol produces a constructor
+procedure that accepts all three coordinates, uses the first two to
+initialize the fields of @code{pixel}, and binds the third to the single
+field of @code{voxel}.
+
address@hidden
+ (lambda (n)
+ (lambda (x y z)
+ (let ((p (n x y)))
+ (p z))))
address@hidden lisp
+
+It may be helpful to think of protocols as ``constructor factories''
+that produce chains of delegating constructors glued together by the
+helper procedure @var{n}.
+
+An R6RS record type may be declared to be @dfn{nongenerative} via the
+use of a unique generated or user-supplied symbol --- or @dfn{uid} ---
+such that subsequent record type declarations with the same uid and
+attributes will return the previously-declared record-type descriptor.
+
+R6RS record types may also be declared to be @dfn{opaque}, in which case
+the various predicates and introspection procedures defined in
address@hidden(rnrs records introspection)} will behave as if records of this
+type are not records at all.
+
+Note that while the R6RS records API shares much of its namespace with
+both the SRFI-9 and native Guile records APIs, it is not currently
+compatible with either.
+
address@hidden rnrs records syntactic
address@hidden rnrs records syntactic
+
+The @code{(rnrs records syntactic (6))} library exports the syntactic
+API for working with R6RS records.
+
address@hidden {Scheme Syntax} define-record-type name-spec record-clause*
+Defines a new record type, introducing bindings for a record-type
+descriptor, a record constructor descriptor, a constructor procedure,
+a record predicate, and accessor and mutator procedures for the new
+record type's fields.
+
address@hidden must either be an identifier or must take the form
address@hidden(record-name constructor-name predicate-name)}, where
address@hidden, @var{constructor-name}, and @var{predicate-name} are
+all identifiers and specify the names to which, respectively, the
+record-type descriptor, constructor, and predicate procedures will be
+bound. If @var{name-spec} is only an identifier, it specifies the name
+to which the generated record-type descriptor will be bound.
+
+Each @var{record-clause} must be one of the following:
+
address@hidden @bullet
address@hidden
address@hidden(fields field-spec*)}, where each @var{field-spec} specifies a
+field of the new record type and takes one of the following forms:
address@hidden @bullet
address@hidden
address@hidden(immutable field-name accessor-name)}, which specifies an
+immutable field with the name @var{field-name} and binds an accessor
+procedure for it to the name given by @var{accessor-name}
address@hidden
address@hidden(mutable field-name accessor-name mutator-name)}, which specifies
+a mutable field with the name @var{field-name} and binds accessor and
+mutator procedures to @var{accessor-name} and @var{mutator-name},
+respectively
address@hidden
address@hidden(immutable field-name)}, which specifies an immutable field with
+the name @var{field-name}; an accessor procedure for it will be created
+and named by appending record name and @var{field-name} with a hyphen
+separator
address@hidden
address@hidden(mutable field-name}), which specifies a mutable field with the
+name @var{field-name}; an accessor procedure for it will be created and
+named as described above; a mutator procedure will also be created and
+named by appending @code{-set!} to the accessor name
address@hidden
address@hidden, which specifies an immutable field with the name
address@hidden; an access procedure for it will be created and named
+as described above
address@hidden itemize
address@hidden
address@hidden(parent parent-name)}, where @var{parent-name} is a symbol giving
+the name of the record type to be used as the parent of the new record
+type
address@hidden
address@hidden(protocol expression)}, where @var{expression} evaluates to a
+protocol procedure which behaves as described above, and is used to
+create a record constructor descriptor for the new record type
address@hidden
address@hidden(sealed sealed?)}, where @var{sealed?} is a boolean value that
+specifies whether or not the new record type is sealed
address@hidden
address@hidden(opaque opaque?)}, where @var{opaque?} is a boolean value that
+specifies whether or not the new record type is opaque
address@hidden
address@hidden(nongenerative [uid])}, which specifies that the record type is
+nongenerative via the optional uid @var{uid}. If @var{uid} is not
+specified, a unique uid will be generated at expansion time
address@hidden
address@hidden(parent-rtd parent-rtd parent-cd)}, a more explicit form of the
address@hidden form above; @var{parent-rtd} and @var{parent-cd} should
+evaluate to a record-type descriptor and a record constructor
+descriptor, respectively
address@hidden itemize
address@hidden deffn
+
address@hidden {Scheme Syntax} record-type-descriptor record-name
+Evaluates to the record-type descriptor associated with the type
+specified by @var{record-name}.
address@hidden deffn
+
address@hidden {Scheme Syntax} record-constructor-descriptor record-name
+Evaluates to the record-constructor descriptor associated with the type
+specified by @var{record-name}.
address@hidden deffn
+
address@hidden rnrs records procedural
address@hidden rnrs records procedural
+
+The @code{(rnrs records procedural (6))} library exports the procedural
+API for working with R6RS records.
+
address@hidden {Scheme Procedure} make-record-type-descriptor name parent uid
sealed? opaque? fields
+Returns a new record-type descriptor with the specified characteristics:
address@hidden must be a symbol giving the name of the new record type;
address@hidden must be either @code{#f} or a non-sealed record-type
+descriptor for the returned record type to extend; @var{uid} must be
+either @code{#f}, indicating that the record type is generative, or
+a symbol giving the type's nongenerative uid; @var{sealed?} and
address@hidden must be boolean values that specify the sealedness and
+opaqueness of the record type; @var{fields} must be a vector of zero or
+more field specifiers of the form @code{(mutable name)} or
address@hidden(immutable name)}, where name is a symbol giving a name for the
+field.
+
+If @var{uid} is not @code{#f}, it must be a symbol
address@hidden deffn
+
address@hidden {Scheme Procedure} record-type-descriptor? obj
+Returns @code{#t} if @var{obj} is a record-type descriptor, @code{#f}
+otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} make-record-constructor-descriptor rtd
parent-constructor-descriptor protocol
+Returns a new record constructor descriptor that can be used to produce
+constructors for the record type specified by the record-type descriptor
address@hidden and whose delegation and binding behavior are specified by the
+protocol procedure @var{protocol}.
+
address@hidden specifies a record constructor
+descriptor for the parent type of @var{rtd}, if one exists. If
address@hidden represents a base type, then
address@hidden must be @code{#f}. If @var{rtd}
+is an extension of another type, @var{parent-constructor-descriptor} may
+still be @code{#f}, but protocol must also be @code{#f} in this case.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-constructor rcd
+Returns a record constructor procedure by invoking the protocol
+defined by the record-constructor descriptor @var{rcd}.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-predicate rtd
+Returns the record predicate procedure for the record-type descriptor
address@hidden
address@hidden deffn
+
address@hidden {Scheme Procedure} record-accessor rtd k
+Returns the record field accessor procedure for the @var{k}th field of
+the record-type descriptor @var{rtd}.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-mutator rtd k
+Returns the record field mutator procedure for the @var{k}th field of
+the record-type descriptor @var{rtd}. An @code{&assertion} condition
+will be raised if this field is not mutable.
address@hidden deffn
+
address@hidden rnrs records inspection
address@hidden rnrs records inspection
+
+The @code{(rnrs records inspection (6))} library provides procedures
+useful for accessing metadata about R6RS records.
+
address@hidden {Scheme Procedure} record? obj
+Return @code{#t} if the specified object is a non-opaque R6RS record,
address@hidden otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-rtd record
+Returns the record-type descriptor for @var{record}. An
address@hidden&assertion} is raised if @var{record} is opaque.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-type-name rtd
+Returns the name of the record-type descriptor @var{rtd}.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-type-parent rtd
+Returns the parent of the record-type descriptor @var{rtd}, or @code{#f}
+if it has none.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-type-uid rtd
+Returns the uid of the record-type descriptor @var{rtd}, or @code{#f} if
+it has none.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-type-generative? rtd
+Returns @code{#t} if the record-type descriptor @var{rtd} is generative,
address@hidden otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-type-sealed? rtd
+Returns @code{#t} if the record-type descriptor @var{rtd} is sealed,
address@hidden otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-type-opaque? rtd
+Returns @code{#t} if the record-type descriptor @var{rtd} is opaque,
address@hidden otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} record-type-field-names rtd
+Returns a vector of symbols giving the names of the fields defined by
+the record-type descriptor @var{rtd} (and not any of its sub- or
+supertypes).
address@hidden deffn
+
address@hidden {Scheme Procedure} record-field-mutable? rtd k
+Returns @code{#t} if the field at index @var{k} of the record-type
+descriptor @var{rtd} (and not any of its sub- or supertypes) is mutable.
address@hidden deffn
+
address@hidden rnrs exceptions
address@hidden rnrs exceptions
+
+The @code{(rnrs exceptions (6))} library provides functionality related
+to signaling and handling exceptional situations. This functionality is
+similar to the exception handling systems provided by Guile's core
+library (@pxref{Exceptions}) and by the SRFI-18 and SRFI-34
+modules --- (@pxref{SRFI-18 Exceptions}) and (@pxref{SRFI-34}),
+respectively --- but there are some key differences in concepts and
+behavior.
+
+A raised exception may be @dfn{continuable} or @dfn{non-continuable}.
+When an exception is raised non-continuably, another exception, with the
+condition type @code{&non-continuable}, will be raised when the
+exception handler returns locally. Raising an exception continuably
+captures the current continuation and invokes it after a local return
+from the exception handler.
+
+Like SRFI-18 and SRFI-34, R6RS exceptions are implemented on top of
+Guile's native @code{throw} and @code{catch} forms, and use custom
+``throw keys'' to identify their exception types. As a consequence,
+Guile's @code{catch} form can handle exceptions thrown by these APIs,
+but the reverse is not true: Handlers registered by the
address@hidden procedure described below will only be
+called on exceptions thrown by the corresponding @code{raise} procedure.
+
address@hidden {Scheme Procedure} with-exception-handler handler thunk
+Installs @var{handler}, which must be a procedure taking one argument,
+as the current exception handler during the invokation of @var{thunk}, a
+procedure taking zero arguments. The handler in place at the time
address@hidden is called is made current again once
+either @var{thunk} returns or @var{handler} is invoked after an
+exception is thrown from within @var{thunk}.
+
+This procedure is similar to the @code{with-throw-handler} procedure
+provided by Guile's code library; (@pxref{Throw Handlers}).
address@hidden deffn
+
address@hidden {Scheme Syntax} guard (variable clause1 clause2 ...) body
+Evaluates the expression given by @var{body}, first creating an ad hoc
+exception handler that binds a raised exception to @var{variable} and
+then evaluates the specified @var{clause}s as if they were part of a
address@hidden expression (@pxref{if cond case}), with the value of the
+first matching clause becoming the value of the @code{guard} expression.
+If none of the clause's test expressions evaluates to @code{#t}, the
+exception is re-raised, with the exception handler that was current
+before the evaluation of the @code{guard} form.
+
+For example, the expression
+
address@hidden
+(guard (ex ((eq? ex 'foo) 'bar) ((eq? ex 'bar) 'baz))
+ (raise 'bar))
address@hidden lisp
+
+evaluates to @code{baz}.
address@hidden deffn
+
address@hidden {Scheme Procedure} raise obj
+Raises a non-continuable exception by invoking the currently-installed
+exception handler on @var{obj}. If the handler returns, a
address@hidden&non-continuable} exception will be raised in the dynamic context
+in which the handler was installed.
address@hidden deffn
+
address@hidden {Scheme Procedure} raise-continuable obj
+Raises a continuable exception by invoking currently-installed exception
+handler on @var{obj}.
address@hidden deffn
+
address@hidden rnrs conditions
address@hidden rnrs conditions
+
+The @code{(rnrs condition (6))} library provides forms and procedures
+for constructing new condition types, as well as a library of
+pre-defined condition types that represent a variety of common
+exceptional situations. Conditions are records of a subtype of the
address@hidden&condition} record type, which is neither sealed nor opaque.
address@hidden Records}.
+
+Conditions may be manipulated singly, as @dfn{simple conditions}, or
+when composed with other conditions to form @dfn{compound conditions}.
+Compound conditions do not ``nest'' --- constructing a new compound
+condition out of existing compound conditions will ``flatten'' them
+into their component simple conditions. For example, making a new
+condition out of a @code{&message} condition and a compound condition
+that contains an @code{&assertion} condition and another @code{&message}
+condition will produce a compound condition that contains two
address@hidden&message} conditions and one @code{&assertion} condition.
+
+The record type predicates and field accessors described below can
+operate on either simple or compound conditions. In the latter case,
+the predicate returns @code{#t} if the compound condition contains a
+component simple condition of the appropriate type; the field accessors
+return the requisite fields from the first component simple condition
+found to be of the appropriate type.
+
address@hidden &condition
address@hidden condition? obj
+The base record type for conditions.
address@hidden deffn
+
address@hidden {Scheme Procedure} condition condition1 ...
address@hidden {Scheme Procedure} simple-conditions condition
+The @code{condition} procedure creates a new compound condition out of
+its condition arguments, flattening any specified compound conditions
+into their component simple conditions as described above.
+
address@hidden returns a list of the component simple
+conditions of the compound condition @code{condition}, in the order in
+which they were specified at construction time.
address@hidden deffn
+
address@hidden {Scheme Procedure} condition-predicate rtd
address@hidden {Scheme Procedure} condition-accessor rtd proc
+These procedures return condition predicate and accessor procedures for
+the specified condition record type @var{rtd}.
address@hidden deffn
+
address@hidden {Scheme Syntax} define-condition-type condition-type supertype
constructor predicate field-spec ...
+Evaluates to a new record type definition for a condition type with the
+name @var{condition-type} that has the condition type @var{supertype} as
+its parent. A default constructor, which binds its arguments to the
+fields of this type and its parent types, will be bound to the
+identifier @var{constructor}; a condition predicate will be bound to
address@hidden The fields of the new type, which are immutable, are
+specified by the @var{field-spec}s, each of which must be of the form:
address@hidden
+(field accessor)
address@hidden lisp
+where @var{field} gives the name of the field and @var{accessor} gives
+the name for a binding to an accessor procedure created for this field.
address@hidden deffn
+
address@hidden &message
address@hidden {Scheme Procedure} make-message-condition message
address@hidden {Scheme Procedure} message-condition? obj
address@hidden {Scheme Procedure} condition-message condition
+A type that includes a message describing the condition that occurred.
address@hidden deffn
+
address@hidden &warning
address@hidden {Scheme Procedure} make-warning
address@hidden {Scheme Procedure} warning? obj
+A base type for representing non-fatal conditions during execution.
address@hidden deffn
+
address@hidden &serious
address@hidden {Scheme Procedure} make-serious-condition
address@hidden {Scheme Procedure} serious-condition? obj
+A base type for conditions representing errors serious enough that
+cannot be ignored.
address@hidden deffn
+
address@hidden &error
address@hidden {Scheme Procedure} make-error
address@hidden {Scheme Procedure} error? obj
+A base type for conditions representing errors.
address@hidden deffn
+
address@hidden &violation
address@hidden {Scheme Procedure} make-violation
address@hidden {Scheme Procedure} violation?
+A subtype of @code{&serious} that can be used to represent violations
+of a language or library standard.
address@hidden deffn
+
address@hidden &assertion
address@hidden {Scheme Procedure} make-assertion-violation
address@hidden {Scheme Procedure} assertion-violation? obj
+A subtype of @code{&violation} that indicates an invalid call to a
+procedure.
address@hidden deffn
+
address@hidden &irritants
address@hidden {Scheme Procedure} make-irritants-condition irritants
address@hidden {Scheme Procedure} irritants-condition? obj
address@hidden {Scheme Procedure} condition-irritants condition
+A base type used for storing information about the causes of another
+condition in a compound condition.
address@hidden deffn
+
address@hidden &who
address@hidden {Scheme Procedure} make-who-condition who
address@hidden {Scheme Procedure} who-condition? obj
address@hidden {Scheme Procedure} condiction-who condition
+A base type used for storing the identity, a string or symbol, of the
+entity responsible for another condition in a compound condition.
address@hidden deffn
+
address@hidden &non-continuable
address@hidden {Scheme Procedure} make-non-continuable-violation
address@hidden {Scheme Procedure} non-continuable-violation? obj
+A subtype of @code{&violation} used to indicate that an exception
+handler invoked by @code{raise} has returned locally.
address@hidden deffn
+
address@hidden &implementation-restriction
address@hidden {Scheme Procedure} make-implementation-restriction-violation
address@hidden {Scheme Procedure} implementation-restriction-violation? obj
+A subtype of @code{&violation} used to indicate a violation of an
+implementation restriction.
address@hidden deffn
+
address@hidden &lexical
address@hidden {Scheme Procedure} make-lexical-violation
address@hidden {Scheme Procedure} lexical-violation? obj
+A subtype of @code{&violation} used to indicate a syntax violation at
+the level of the datum syntax.
address@hidden deffn
+
address@hidden &syntax
address@hidden {Scheme Procedure} make-syntax-violation form subform
address@hidden {Scheme Procedure} syntax-violation? obj
address@hidden {Scheme Procedure} syntax-violation-form condition
address@hidden {Scheme Procedure} syntax-violation-subform condition
+A subtype of @code{&violation} that indicates a syntax violation. The
address@hidden and @var{subform} fields, which must be datum values,
+indicate the syntactic form responsible for the condition.
address@hidden deffn
+
address@hidden &undefined
address@hidden {Scheme Procedure} make-undefined-violation
address@hidden {Scheme Procedure} undefined-violation? obj
+A subtype of @code{&violation} that indicates a reference to an unbound
+identifier.
address@hidden deffn
+
address@hidden I/O Conditions
address@hidden I/O Conditions
+
+These condition types are exported by both the
address@hidden(rnrs io ports (6))} and @code{(rnrs io simple (6))} libraries.
+
address@hidden &i/o
address@hidden {Scheme Procedure} make-i/o-error
address@hidden {Scheme Procedure} i/o-error? obj
+A condition supertype for more specific I/O errors.
address@hidden deffn
+
address@hidden &i/o-read
address@hidden {Scheme Procedure} make-i/o-read-error
address@hidden {Scheme Procedure} i/o-read-error? obj
+A subtype of @code{&i/o}; represents read-related I/O errors.
address@hidden deffn
+
address@hidden &i/o-write
address@hidden {Scheme Procedure} make-i/o-write-error
address@hidden {Scheme Procedure} i/o-write-error? obj
+A subtype of @code{&i/o}; represents write-related I/O errors.
address@hidden deffn
+
address@hidden &i/o-invalid-position
address@hidden {Scheme Procedure} make-i/o-invalid-position-error position
address@hidden {Scheme Procedure} i/o-invalid-position-error? obj
address@hidden {Scheme Procedure} i/o-error-position condition
+A subtype of @code{&i/o}; represents an error related to an attempt to
+set the file position to an invalid position.
address@hidden deffn
+
address@hidden &i/o-filename
address@hidden {Scheme Procedure} make-io-filename-error filename
address@hidden {Scheme Procedure} i/o-filename-error? obj
address@hidden {Scheme Procedure} i/o-error-filename condition
+A subtype of @code{&i/o}; represents an error related to an operation on
+a named file.
address@hidden deffn
+
address@hidden &i/o-file-protection
address@hidden {Scheme Procedure} make-i/o-file-protection-error filename
address@hidden {Scheme Procedure} i/o-file-protection-error? obj
+A subtype of @code{&i/o-filename}; represents an error resulting from an
+attempt to access a named file for which the caller had insufficient
+permissions.
address@hidden deffn
+
address@hidden &i/o-file-is-read-only
address@hidden {Scheme Procedure} make-i/o-file-is-read-only-error filename
address@hidden {Scheme Procedure} i/o-file-is-read-only-error? obj
+A subtype of @code{&i/o-file-protection}; represents an error related to
+an attempt to write to a read-only file.
address@hidden deffn
+
address@hidden &i/o-file-already-exists
address@hidden {Scheme Procedure} make-i/o-file-already-exists-error filename
address@hidden {Scheme Procedure} i/o-file-already-exists-error? obj
+A subtype of @code{&i/o-filename}; represents an error related to an
+operation on an existing file that was assumed not to exist.
address@hidden deffn
+
address@hidden &i/o-file-does-not-exist
address@hidden {Scheme Procedure} make-i/o-file-does-not-exist-error
address@hidden {Scheme Procedure} i/o-file-does-not-exist-error? obj
+A subtype of @code{&i/o-filename}; represents an error related to an
+operation on a non-existent file that was assumed to exist.
address@hidden deffn
+
address@hidden &i/o-port
address@hidden {Scheme Procedure} make-i/o-port-error port
address@hidden {Scheme Procedure} i/o-port-error? obj
address@hidden {Scheme Procedure} i/o-error-port condition
+A subtype of @code{&i/o}; represents an error related to an operation on
+the port @var{port}.
address@hidden deffn
+
address@hidden rnrs io ports
address@hidden rnrs io ports
+
+The @code{(rnrs io ports (6))} library provides various procedures and
+syntactic forms for use in writing to and reading from ports. This
+functionality is documented in its own section of the manual;
+(@pxref{R6RS I/O Ports}).
+
address@hidden rnrs io simple
address@hidden rnrs io simple
+
+The @code{(rnrs io simple (6))} library provides convenience functions
+for performing textual I/O on ports. This library also exports all of
+the condition types and associated procedures described in
+(@pxref{I/O Conditions}).
+
address@hidden {Scheme Procedure} eof-object
address@hidden {Scheme Procedure} eof-object? obj
+These procedures are identical to the ones provided by the
address@hidden(rnrs io ports (6))} library. @xref{R6RS I/O Ports}, for
+documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} input-port? obj
address@hidden {Scheme Procedure} output-port? obj
+These procedures are identical to the ones provided by Guile's core
+library. @xref{Ports}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} call-with-input-file filename proc
address@hidden {Scheme Procedure} call-with-output-file filename proc
address@hidden {Scheme Procedure} open-input-file filename
address@hidden {Scheme Procedure} open-output-file filename
address@hidden {Scheme Procedure} with-input-from-file filename thunk
address@hidden {Scheme Procedure} with-output-to-file filename thunk
+These procedures are identical to the ones provided by Guile's core
+library. @xref{File Ports}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} close-input-port input-port
address@hidden {Scheme Procedure} close-output-port output-port
+These procedures are identical to the ones provided by Guile's core
+library. @xref{Closing}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} peek-char
address@hidden {Scheme Procedure} peek-char textual-input-port
address@hidden {Scheme Procedure} read-char
address@hidden {Scheme Procedure} read-char textual-input-port
+These procedures are identical to the ones provided by Guile's core
+library. @xref{Reading}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} read
address@hidden {Scheme Procedure} read textual-input-port
+This procedure is identical to the one provided by Guile's core library.
address@hidden Read}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} display obj
address@hidden {Scheme Procedure} display obj textual-output-port
address@hidden {Scheme Procedure} newline
address@hidden {Scheme Procedure} newline textual-output-port
address@hidden {Scheme Procedure} write obj
address@hidden {Scheme Procedure} write obj textual-output-port
address@hidden {Scheme Procedure} write-char char
address@hidden {Scheme Procedure} write-char char textual-output-port
+These procedures are identical to the ones provided by Guile's core
+library. @xref{Writing}, for documentation.
address@hidden deffn
+
address@hidden rnrs files
address@hidden rnrs files
+
+The @code{(rnrs files (6))} library provides the @code{file-exists?} and
address@hidden procedures, which test for the existence of a file
+and allow the deletion of files from the filesystem, respectively.
+
+These procedures are identical to the ones provided by Guile's core
+library. @xref{File System}, for documentation.
+
address@hidden rnrs programs
address@hidden rnrs programs
+
+The @code{(rnrs programs (6))} library provides procedures for
+process management and introspection.
+
address@hidden {Scheme Procedure} command-line
+This procedure is identical to the one provided by Guile's core library.
address@hidden Environment}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} exit
address@hidden {Scheme Procedure} exit obj
+This procedure is identical to the one provided by Guile's core library.
address@hidden deffn
+
address@hidden rnrs arithmetic fixnums
address@hidden rnrs arithmetic fixnums
+
+The @code{(rnrs arithmetic fixnums (6))} library provides procedures for
+performing arithmetic operations on an implementation-dependent range of
+exact integer values, which R6RS refers to as @dfn{fixnums}. In Guile,
+the size of a fixnum is determined by the size of the @code{SCM} type; a
+single SCM struct is guaranteed to be able to hold an entire fixnum,
+making fixnum computations particularly efficient ---
+(@pxref{The SCM Type}). On 32-bit systems, the most negative and most
+positive fixnum values are, respectively, -536870912 and 536870911.
+
+Unless otherwise specified, all of the procedures below take fixnums as
+arguments, and will raise an @code{&assertion} condition if passed a
+non-fixnum argument or an @code{&implementation-restriction} condition
+if their result is not itself a fixnum.
+
address@hidden {Scheme Procedure} fixnum? obj
+Returns @code{#t} if @var{obj} is a fixnum, @code{#f} otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} fixnum-width
address@hidden {Scheme Procedure} least-fixnum
address@hidden {Scheme Procedure} greatest-fixnum
+These procedures return, respectively, the maximum number of bits
+necessary to represent a fixnum value in Guile, the minimum fixnum
+value, and the maximum fixnum value.
address@hidden deffn
+
address@hidden {Scheme Procedure} fx=? fx1 fx2 fx3 ...
address@hidden {Scheme Procedure} fx>? fx1 fx2 fx3 ...
address@hidden {Scheme Procedure} fx<? fx1 fx2 fx3 ...
address@hidden {Scheme Procedure} fx>=? fx1 fx2 fx3 ...
address@hidden {Scheme Procedure} fx<=? fx1 fx2 fx3 ...
+These procedures return @code{#t} if their fixnum arguments are
+(respectively): equal, monotonically increasing, monotonically
+decreasing, monotonically nondecreasing, or monotonically nonincrasing;
address@hidden otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxzero? fx
address@hidden {Scheme Procedure} fxpositive? fx
address@hidden {Scheme Procedure} fxnegative? fx
address@hidden {Scheme Procedure} fxodd? fx
address@hidden {Scheme Procedure} fxeven? fx
+These numerical predicates return @code{#t} if @var{fx} is,
+respectively, zero, greater than zero, less than zero, odd, or even;
address@hidden otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxmax fx1 fx2 ...
address@hidden {Scheme Procedure} fxmin fx1 fx2 ...
+These procedures return the maximum or minimum of their arguments.
address@hidden deffn
+
address@hidden {Scheme Procedure} fx+ fx1 fx2
address@hidden {Scheme Procedure} fx* fx1 fx2
+These procedures return the sum or product of their arguments.
address@hidden deffn
+
address@hidden {Scheme Procedure} fx- fx1 fx2
address@hidden {Scheme Procedure} fx- fx
+Returns the difference of @var{fx1} and @var{fx2}, or the negation of
address@hidden, if called with a single argument.
+
+An @code{&assertion} condition is raised if the result is not itself a
+fixnum.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxdiv-and-mod fx1 fx2
address@hidden {Scheme Procedure} fxdiv fx1 fx2
address@hidden {Scheme Procedure} fxmod fx1 fx2
address@hidden {Scheme Procedure} fxdiv0-and-mod0 fx1 fx2
address@hidden {Scheme Procedure} fxdiv0 fx1 fx2
address@hidden {Scheme Procedure} fxmod0 fx1 fx2
+These procedures implement number-theoretic division on fixnums;
+(@pxref{(rnrs base)}) for a description for their semantics.
address@hidden deffn
+
address@hidden {Scheme Procedure} fx+/carry fx1 fx2 fx3
+Returns the two fixnum results of the following computation:
address@hidden
+(let* ((s (+ fx1 fx2 fx3))
+ (s0 (mod0 s (expt 2 (fixnum-width))))
+ (s1 (div0 s (expt 2 (fixnum-width)))))
+ (values s0 s1))
address@hidden lisp
address@hidden deffn
+
address@hidden {Scheme Procedure} fx-/carry fx1 fx2 fx3
+Returns the two fixnum results of the following computation:
address@hidden
+(let* ((d (- fx1 fx2 fx3))
+ (d0 (mod0 d (expt 2 (fixnum-width))))
+ (d1 (div0 d (expt 2 (fixnum-width)))))
+ (values d0 d1))
address@hidden lisp
address@hidden deffn
+
address@hidden {Scheme Procedure} fx*/carry fx1 fx2 fx3
address@hidden
+Returns the two fixnum results of the following computation:
+(let* ((s (+ (* fx1 fx2) fx3))
+ (s0 (mod0 s (expt 2 (fixnum-width))))
+ (s1 (div0 s (expt 2 (fixnum-width)))))
+ (values s0 s1))
address@hidden lisp
address@hidden deffn
+
address@hidden {Scheme Procedure} fxnot fx
address@hidden {Scheme Procedure} fxand fx1 ...
address@hidden {Scheme Procedure} fxior fx1 ...
address@hidden {Scheme Procedure} fxxor fx1 ...
+These procedures are identical to the @code{lognot}, @code{logand},
address@hidden, and @code{logxor} procedures provided by Guile's core
+library. @xref{Bitwise Operations}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxif fx1 fx2 fx3
+Returns the bitwise ``if'' of its fixnum arguments. The bit at position
address@hidden in the return value will be the @code{i}th bit from @var{fx2}
+if the @code{i}th bit of @var{fx1} is 1, the @code{i}th bit from
address@hidden
address@hidden deffn
+
address@hidden {Scheme Procedure} fxbit-count fx
+Returns the number of 1 bits in the two's complement representation of
address@hidden
address@hidden deffn
+
address@hidden {Scheme Procedure} fxlength fx
+Returns the number of bits necessary to represent @var{fx}.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxfirst-bit-set fx
+Returns the index of the least significant 1 bit in the two's complement
+representation of @var{fx}.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxbit-set? fx1 fx2
+Returns @code{#t} if the @var{fx2}th bit in the two's complement
+representation of @var{fx1} is 1, @code{#f} otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxcopy-bit fx1 fx2 fx3
+Returns the result of setting the @var{fx2}th bit of @var{fx1} to the
address@hidden bit of @var{fx3}.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxbit-field fx1 fx2 fx3
+Returns the integer representation of the contiguous sequence of bits in
address@hidden that starts at position @var{fx2} (inclusive) and ends at
+position @var{fx3} (exclusive).
address@hidden deffn
+
address@hidden {Scheme Procedure} fxcopy-bit-field fx1 fx2 fx3 fx4
+Returns the result of replacing the bit field in @var{fx1} with start
+and end positions @var{fx2} and @var{fx3} with the corresponding bit
+field from @var{fx4}.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxarithmetic-shift fx1 fx2
address@hidden {Scheme Procedure} fxarithmetic-shift-left fx1 fx2
address@hidden {Scheme Procedure} fxarithmetic-shift-right fx1 fx2
+Returns the result of shifting the bits of @var{fx1} right or left by
+the @var{fx2} positions. @code{fxarithmetic-shift} is identical
+to @code{fxarithmetic-shift-left}.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxrotate-bit-field fx1 fx2 fx3 fx4
+Returns the result of cyclically permuting the bit field in @var{fx1}
+with start and end positions @var{fx2} and @var{fx3} by @var{fx4} bits
+in the direction of more significant bits.
address@hidden deffn
+
address@hidden {Scheme Procedure} fxreverse-bit-field fx1 fx2 fx3
+Returns the result of reversing the order of the bits of @var{fx1}
+between position @var{fx2} (inclusive) and position @var{fx3}
+(exclusive).
address@hidden deffn
+
address@hidden rnrs arithmetic flonums
address@hidden rnrs arithmetic flonums
+
+The @code{(rnrs arithmetic flonums (6))} library provides procedures for
+performing arithmetic operations on inexact representations of real
+numbers, which R6RS refers to as @dfn{flonums}.
+
+Unless otherwise specified, all of the procedures below take flonums as
+arguments, and will raise an @code{&assertion} condition if passed a
+non-flonum argument.
+
address@hidden {Scheme Procedure} flonum? obj
+Returns @code{#t} if @var{obj} is a flonum, @code{#f} otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} real->flonum x
+Returns the flonum that is numerically closest to the real number
address@hidden
address@hidden deffn
+
address@hidden {Scheme Procedure} fl=? fl1 fl2 fl3 ...
address@hidden {Scheme Procedure} fl<? fl1 fl2 fl3 ...
address@hidden {Scheme Procedure} fl<=? fl1 fl2 fl3 ...
address@hidden {Scheme Procedure} fl>? fl1 fl2 fl3 ...
address@hidden {Scheme Procedure} fl>=? fl1 fl2 fl3 ...
+These procedures return @code{#t} if their flonum arguments are
+(respectively): equal, monotonically increasing, monotonically
+decreasing, monotonically nondecreasing, or monotonically nonincrasing;
address@hidden otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} flinteger? fl
address@hidden {Scheme Procedure} flzero? fl
address@hidden {Scheme Procedure} flpositive? fl
address@hidden {Scheme Procedure} flnegative? fl
address@hidden {Scheme Procedure} flodd? fl
address@hidden {Scheme Procedure} fleven? fl
+These numerical predicates return @code{#t} if @var{fl} is,
+respectively, an integer, zero, greater than zero, less than zero, odd,
+even, @code{#f} otherwise. In the case of @code{flodd?} and
address@hidden, @var{fl} must be an integer-valued flonum.
address@hidden deffn
+
address@hidden {Scheme Procedure} flfinite? fl
address@hidden {Scheme Procedure} flinfinite? fl
address@hidden {Scheme Procedure} flnan? fl
+These numerical predicates return @code{#t} if @var{fl} is,
+respectively, not infinite, infinite, or a @code{NaN} value.
address@hidden deffn
+
address@hidden {Scheme Procedure} flmax fl1 fl2 ...
address@hidden {Scheme Procedure} flmin fl1 fl2 ...
+These procedures return the maximum or minimum of their arguments.
address@hidden deffn
+
address@hidden {Scheme Procedure} fl+ fl1 ...
address@hidden {Scheme Procedure} fl* fl ...
+These procedures return the sum or product of their arguments.
address@hidden deffn
+
address@hidden {Scheme Procedure} fl- fl1 fl2 ...
address@hidden {Scheme Procedure} fl- fl
address@hidden {Scheme Procedure} fl/ fl1 fl2 ...
address@hidden {Scheme Procedure} fl/ fl
+These procedures return, respectively, the difference or quotient of
+their arguments when called with two arguments; when called with a
+single argument, they return the additive or multiplicative inverse of
address@hidden
address@hidden deffn
+
address@hidden {Scheme Procedure} flabs fl
+Returns the absolute value of @var{fl}.
address@hidden deffn
+
address@hidden {Scheme Procedure} fldiv-and-mod fl1 fl2
address@hidden {Scheme Procedure} fldiv fl1 fl2
address@hidden {Scheme Procedure} fldmod fl1 fl2
address@hidden {Scheme Procedure} fldiv0-and-mod0 fl1 fl2
address@hidden {Scheme Procedure} fldiv0 fl1 fl2
address@hidden {Scheme Procedure} flmod0 fl1 fl2
+These procedures implement number-theoretic division on flonums;
+(@pxref{(rnrs base)}) for a description for their semantics.
address@hidden deffn
+
address@hidden {Scheme Procedure} flnumerator fl
address@hidden {Scheme Procedure} fldenominator fl
+These procedures return the numerator or denominator of @var{fl} as a
+flonum.
address@hidden deffn
+
address@hidden {Scheme Procedure} flfloor fl1
address@hidden {Scheme Procedure} flceiling fl
address@hidden {Scheme Procedure} fltruncate fl
address@hidden {Scheme Procedure} flround fl
+These procedures are identical to the @code{floor}, @code{ceiling},
address@hidden, and @code{round} procedures provided by Guile's core
+library. @xref{Arithmetic}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} flexp fl
address@hidden {Scheme Procedure} fllog fl
address@hidden {Scheme Procedure} fllog fl1 fl2
address@hidden {Scheme Procedure} flsin fl
address@hidden {Scheme Procedure} flcos fl
address@hidden {Scheme Procedure} fltan fl
address@hidden {Scheme Procedure} flasin fl
address@hidden {Scheme Procedure} flacos fl
address@hidden {Scheme Procedure} flatan fl
address@hidden {Scheme Procedure} flatan fl1 fl2
+These procedures, which compute the usual transcendental functions, are
+the flonum variants of the procedures provided by the R6RS base library
+(@pxref{(rnrs base)}).
address@hidden deffn
+
address@hidden {Scheme Procedure} flsqrt fl
+Returns the square root of @var{fl}. If @var{fl} is @code{-0.0},
address@hidden is returned; for other negative values, a @code{NaN} value
+is returned.
address@hidden deffn
+
address@hidden {Scheme Procedure} flexpt fl1 fl2
+Returns the value of @var{fl1} raised to the power of @var{fl2}.
address@hidden deffn
+
+The following condition types are provided to allow Scheme
+implementations that do not support infinities or @code{NaN} values
+to indicate that a computation resulted in such a value. Guile supports
+both of these, so these conditions will never be raised by Guile's
+standard libraries implementation.
+
address@hidden &no-infinities
address@hidden {Scheme Procedure} make-no-infinities-violation obj
address@hidden {Scheme Procedure} no-infinities-violation?
+A condition type indicating that a computation resulted in an infinite
+value on a Scheme implementation incapable of representing infinities.
address@hidden deffn
+
address@hidden &no-nans
address@hidden {Scheme Procedure} make-no-nans-violation obj
address@hidden {Scheme Procedure} no-nans-violation? obj
+A condition type indicating that a computation resulted in a @code{NaN}
+value on a Scheme implementation incapable of representing @code{NaN}s.
address@hidden deffn
+
address@hidden {Scheme Procedure} fixnum->flonum fx
+Returns the flonum that is numerically closest to the fixnum @var{fx}.
address@hidden deffn
+
address@hidden rnrs arithmetic bitwise
address@hidden rnrs arithmetic bitwise
+
+The @code{(rnrs arithmetic bitwise (6))} library provides procedures for
+performing bitwise arithmetic operations on the two's complement
+representations of fixnums.
+
address@hidden {Scheme Procedure} bitwise-not ei
address@hidden {Scheme Procedure} bitwise-and ei1 ...
address@hidden {Scheme Procedure} bitwise-ior ei1 ...
address@hidden {Scheme Procedure} bitwise-xor ei1 ...
+These procedures are identical to the @code{lognot}, @code{logand},
address@hidden, and @code{logxor} procedures provided by Guile's core
+library. @xref{Bitwise Operations}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-if ei1 ei2 ei3
+Returns the bitwise ``if'' of its arguments. The bit at position
address@hidden in the return value will be the @code{i}th bit from @var{ei2}
+if the @code{i}th bit of @var{ei1} is 1, the @code{i}th bit from
address@hidden
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-bit-count ei
+Returns the number of 1 bits in the two's complement representation of
address@hidden
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-length ei
+Returns the number of bits necessary to represent @var{ei}.
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-first-bit-set ei
+Returns the index of the least significant 1 bit in the two's complement
+representation of @var{ei}.
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-bit-set? ei1 ei2
+Returns @code{#t} if the @var{ei2}th bit in the two's complement
+representation of @var{ei1} is 1, @code{#f} otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-copy-bit ei1 ei2 ei3
+Returns the result of setting the @var{ei2}th bit of @var{ei1} to the
address@hidden bit of @var{ei3}.
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-bit-field ei1 ei2 ei3
+Returns the integer representation of the contiguous sequence of bits in
address@hidden that starts at position @var{ei2} (inclusive) and ends at
+position @var{ei3} (exclusive).
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-copy-bit-field ei1 ei2 ei3 ei4
+Returns the result of replacing the bit field in @var{ei1} with start
+and end positions @var{ei2} and @var{ei3} with the corresponding bit
+field from @var{ei4}.
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-arithmetic-shift ei1 ei2
address@hidden {Scheme Procedure} bitwise-arithmetic-shift-left ei1 ei2
address@hidden {Scheme Procedure} bitwise-arithmetic-shift-right ei1 ei2
+Returns the result of shifting the bits of @var{ei1} right or left by
+the @var{ei2} positions. @code{bitwise-arithmetic-shift} is identical
+to @code{bitwise-arithmetic-shift-left}.
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-rotate-bit-field ei1 ei2 ei3 ei4
+Returns the result of cyclically permuting the bit field in @var{ei1}
+with start and end positions @var{ei2} and @var{ei3} by @var{ei4} bits
+in the direction of more significant bits.
address@hidden deffn
+
address@hidden {Scheme Procedure} bitwise-reverse-bit-field ei1 ei2 ei3
+Returns the result of reversing the order of the bits of @var{e1}
+between position @var{ei2} (inclusive) and position @var{ei3}
+(exclusive).
address@hidden deffn
+
address@hidden rnrs syntax-case
address@hidden rnrs syntax-case
+
+The @code{(rnrs syntax-case (6))} library provides access to the
address@hidden system for writing hygienic macros. With one
+exception, all of the forms and procedures exported by this library
+are ``re-exports'' of Guile's native support for @code{syntax-case};
+(@pxref{Syntax Case}) for documentation, examples, and rationale.
+
address@hidden {Scheme Procedure} make-variable-transformer proc
+Creates a new variable transformer out of @var{proc}, a procedure that
+takes a syntax object as input and returns a syntax object. If an
+identifier to which the result of this procedure is bound appears on the
+left-hand side of a @code{set!} expression, @var{proc} will be called
+with a syntax object representing the entire @code{set!} expression,
+and its return value will replace that @code{set!} expression.
address@hidden deffn
+
address@hidden {Scheme Syntax} syntax-case expression (literal ...) clause ...
+The @code{syntax-case} pattern matching form.
address@hidden deffn
+
address@hidden {Scheme Syntax} syntax template
address@hidden {Scheme Syntax} quasisyntax template
address@hidden {Scheme Syntax} unsyntax template
address@hidden {Scheme Syntax} unsyntax-splicing template
+These forms allow references to be made in the body of a syntax-case
+output expression subform to datum and non-datum values. They are
+identical to the forms provided by Guile's core library;
+(@pxref{Syntax Case}) for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} identifier? obj
address@hidden {Scheme Procedure} bound-identifier=? id1 id2
address@hidden {Scheme Procedure} free-identifier=? id1 id2
+These predicate procedures operate on syntax objects representing
+Scheme identifiers. @code{identifier?} returns @code{#t} if @var{obj}
+represents an identifier, @code{#f} otherwise.
address@hidden returns @code{#t} if and only if a binding for
address@hidden would capture a reference to @var{id2} in the transformer's
+output, or vice-versa. @code{free-identifier=?} returns @code{#t} if
+and only @var{id1} and @var{id2} would refer to the same binding in the
+output of the transformer, independent of any bindings introduced by the
+transformer.
address@hidden deffn
+
address@hidden {Scheme Procedure} generate-temporaries l
+Returns a list, of the same length as @var{l}, which must be a list or
+a syntax object representing a list, of globally unique symbols.
address@hidden deffn
+
address@hidden {Scheme Procedure} syntax->datum syntax-object
address@hidden {Scheme Procedure} datum->syntax template-id datum
+These procedures convert wrapped syntax objects to and from Scheme datum
+values. The syntax object returned by @code{datum->syntax} shares
+contextual information with the syntax object @var{template-id}.
address@hidden deffn
+
address@hidden {Scheme Procedure} syntax-violation whom message form
address@hidden {Scheme Procedure} syntax-violation whom message form subform
+Constructs a new compound condition that includes the following
+simple conditions:
address@hidden @bullet
address@hidden
+If @var{whom} is not @code{#f}, a @code{&who} condition with the
address@hidden as its field
address@hidden
+A @code{&message} condition with the specified @var{message}
address@hidden
+A @code{&syntax} condition with the specified @var{form} and optional
address@hidden fields
address@hidden itemize
address@hidden deffn
+
address@hidden rnrs hashtables
address@hidden rnrs hashtables
+
+The @code{(rnrs hashtables (6))} library provides structures and
+procedures for creating and accessing hash tables. The hash tables API
+defined by R6RS is substantially similar to both Guile's native hash
+tables implementation (@pxref{Hash Tables}) as well as the one
+provided by SRFI-69 (@pxref{SRFI-69}). Note that you can write
+portable R6RS library code that manipulates SRFI-69 hash tables (by
+importing the @code{(srfi :69)} library); however, hash tables created
+by one API cannot be used by another.
+
+Like SRFI-69 hash tables --- and unlike Guile's native ones --- R6RS
+hash tables associate hash and equality functions with a hash table at
+the time of its creation. Additionally, R6RS allows for the creation
+(via @code{hashtable-copy}; see below) of immutable hash tables.
+
address@hidden {Scheme Procedure} make-eq-hashtable
address@hidden {Scheme Procedure} make-eq-hashtable k
+Returns a new hash table that uses @code{eq?} to compare keys and
+Guile's @code{hashq} procedure as a hash function. If @var{k} is given,
+it specifies the initial capacity of the hash table.
address@hidden deffn
+
address@hidden {Scheme Procedure} make-eqv-hashtable
address@hidden {Scheme Procedure} make-eqv-hashtable k
+Returns a new hash table that uses @code{eqv?} to compare keys and
+Guile's @code{hashv} procedure as a hash function. If @var{k} is given,
+it specifies the initial capacity of the hash table.
address@hidden deffn
+
address@hidden {Scheme Procedure} make-hashtable hash-function equiv
address@hidden {Scheme Procedure} make-hashtable hash-function equiv k
+Returns a new hash table that uses @var{equiv} to compare keys and
address@hidden as a hash function. @var{equiv} must be a procedure
+that accepts two arguments and returns a true value if they are
+equivalent, @code{#f} otherwise; @var{hash-function} must be a procedure
+that accepts one argument and returns a non-negative integer.
+
+If @var{k} is given, it specifies the initial capacity of the hash
+table.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable? obj
+Returns @code{#t} if @var{obj} is an R6RS hash table, @code{#f}
+otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-size hashtable
+Returns the number of keys currently in the hash table @var{hashtable}.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-ref hashtable key default
+Returns the value associated with @var{key} in the hash table
address@hidden, or @var{default} if none is found.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-set! hashtable key obj
+Associates the key @var{key} with the value @var{obj} in the hash table
address@hidden, and returns an unspecified value. An @code{&assertion}
+condition is raised if @var{hashtable} is immutable.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-delete! hashtable key
+Removes any association found for the key @var{key} in the hash table
address@hidden, and returns an unspecified value. An @code{&assertion}
+condition is raised if @var{hashtable} is immutable.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-contains? hashtable key
+Returns @code{#t} if the hash table @var{hashtable} contains an
+association for the key @var{key}, @code{#f} otherwise.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-update! hashtable key proc default
+Associates with @var{key} in the hash table @var{hashtable} the result
+of calling @var{proc}, which must be a procedure that takes one
+argument, on the value currently associated @var{key} in
address@hidden --- or on @var{default} if no such association exists.
+An @code{&assertion} condition is raised if @var{hashtable} is
+immutable.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-copy hashtable
address@hidden {Scheme Procedure} hashtable-copy hashtable mutable
+Returns a copy of the hash table @var{hashtable}. If the optional
+argument @var{mutable} is a true value, the new hash table will be
+immutable.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-clear! hashtable
address@hidden {Scheme Procedure} hashtable-clear! hashtable k
+Removes all of the associations from the hash table @var{hashtable}.
+The optional argument @var{k}, which specifies a new capacity for the
+hash table, is accepted by Guile's @code{(rnrs hashtables)}
+implementation, but is ignored.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-keys hashtable
+Returns a vector of the keys with associations in the hash table
address@hidden, in an unspecified order.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-entries hashtable
+Return two values --- a vector of the keys with associations in the
+hash table @var{hashtable}, and a vector of the values to which these
+keys are mapped, in corresponding but unspecified order.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-equivalence-function hashtable
+Returns the equivalence predicated use by @var{hashtable}. This
+procedure returns @code{eq?} and @code{eqv?}, respectively, for hash
+tables created by @code{make-eq-hashtable} and
address@hidden
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-hash-function hashtable
+Returns the hash function used by @var{hashtable}. For hash tables
+created by @code{make-eq-hashtable} or @code{make-eqv-hashtable},
address@hidden is returned.
address@hidden deffn
+
address@hidden {Scheme Procedure} hashtable-mutable? hashtable
+Returns @code{#t} if @var{hashtable} is mutable, @code{#f} otherwise.
address@hidden deffn
+
+A number of hash functions are provided for convenience:
+
address@hidden {Scheme Procedure} equal-hash obj
+Returns an integer hash value for @var{obj}, based on its structure and
+current contents. This hash function is suitable for use with
address@hidden as an equivalence function.
address@hidden deffn
+
address@hidden {Scheme Procedure} string-hash string
address@hidden {Scheme Procedure} symbol-hash symbol
+These procedures are identical to the ones provided by Guile's core
+library. @xref{Hash Table Reference}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} string-ci-hash string
+Returns an integer hash value for @var{string} based on its contents,
+ignoring case. This hash function is suitable for use with
address@hidden as an equivalence function.
address@hidden deffn
+
address@hidden rnrs enums
address@hidden rnrs enums
+
+The @code{(rnrs enums (6))} library provides structures and procedures
+for working with enumerable sets of symbols. Guile's implementation
+defines an @dfn{enum-set} record type that encapsulates a finite set of
+distinct symbols, the @dfn{universe}, and a subset of these symbols,
+which define the enumeration set.
+
+The SRFI-1 list library provides a number of procedures for performing
+set operations on lists; Guile's @code{(rnrs enums)} implementation
+makes use of several of them. @xref{SRFI-1 Set Operations}, for
+more information.
+
address@hidden {Scheme Procedure} make-enumeration symbol-list
+Returns a new enum-set whose universe and enumeration set are both equal
+to @var{symbol-list}, a list of symbols.
address@hidden deffn
+
address@hidden {Scheme Procedure} enum-set-universe enum-set
+Returns an enum-set representing the universe of @var{enum-set},
+an enum-set.
address@hidden deffn
+
address@hidden {Scheme Procedure} enum-set-indexer enum-set
+Returns a procedure that takes a single argument and returns the
+zero-indexed position of that argument in the universe of
address@hidden, or @code{#f} if its argument is not a member of that
+universe.
address@hidden deffn
+
address@hidden {Scheme Procedure} enum-set-constructor enum-set
+Returns a procedure that takes a single argument, a list of symbols
+from the universe of @var{enum-set}, an enum-set, and returns a new
+enum-set with the same universe that represents a subset containing the
+specified symbols.
address@hidden deffn
+
address@hidden {Scheme Procedure} enum-set->list enum-set
+Returns a list containing the symbols of the set represented by
address@hidden, an enum-set, in the order that they appear in the
+universe of @var{enum-set}.
address@hidden deffn
+
address@hidden {Scheme Procedure} enum-set-member? symbol enum-set
address@hidden {Scheme Procedure} enum-set-subset? enum-set1 enum-set2
address@hidden {Scheme Procedure} enum-set=? enum-set1 enum-set2
+These procedures test for membership of symbols and enum-sets in other
+enum-sets. @code{enum-set-member?} returns @code{#t} if and only if
address@hidden is a member of the subset specified by @var{enum-set}.
address@hidden returns @code{#t} if and only if the universe of
address@hidden is a subset of the universe of @var{enum-set2} and
+every symbol in @var{enum-set1} is present in @var{enum-set2}.
address@hidden returns @code{#t} if and only if @var{enum-set1} is a
+subset, as per @code{enum-set-subset?} of @var{enum-set2} and vice
+versa.
address@hidden deffn
+
address@hidden {Scheme Procedure} enum-set-union enum-set1 enum-set2
address@hidden {Scheme Procedure} enum-set-intersection enum-set1 enum-set2
address@hidden {Scheme Procedure} enum-set-difference enum-set1 enum-set2
+These procedures return, respectively, the union, intersection, and
+difference of their enum-set arguments.
address@hidden deffn
+
address@hidden {Scheme Procedure} enum-set-complement enum-set
+Returns @var{enum-set}'s complement (an enum-set), with regard to its
+universe.
address@hidden deffn
+
address@hidden {Scheme Procedure} enum-set-projection enum-set1 enum-set2
+Returns the projection of the enum-set @var{enum-set1} onto the universe
+of the enum-set @var{enum-set2}.
address@hidden deffn
+
address@hidden {Scheme Syntax} define-enumeration type-name (symbol ...)
constructor-syntax
+Evaluates to two new definitions: A constructor bound to
address@hidden that behaves similarly to constructors created
+by @code{enum-set-constructor}, above, and creates new @var{enum-set}s
+in the universe specified by @code{(symbol ...)}; and a ``predicate
+macro'' bound to @var{type-name}, which has the following form:
+
address@hidden
+(@var{type-name} sym)
address@hidden lisp
+
+If @var{sym} is a member of the universe specified by the @var{symbol}s
+above, this form evaluates to @var{sym}. Otherwise, a @code{&syntax}
+condition is raised.
address@hidden deffn
+
address@hidden rnrs
address@hidden rnrs
+
+The @code{(rnrs (6))} library is a composite of all of the other R6RS
+standard libraries --- it imports and re-exports all of their exported
+procedures and syntactic forms --- with the exception of the following
+libraries:
+
address@hidden @bullet
address@hidden @code{(rnrs eval (6))}
address@hidden @code{(rnrs mutable-pairs (6))}
address@hidden @code{(rnrs mutable-strings (6))}
address@hidden @code{(rnrs r5rs (6))}
address@hidden itemize
+
address@hidden rnrs eval
address@hidden rnrs eval
+
+The @code{(rnrs eval (6)} library provides procedures for performing
+``on-the-fly'' evaluation of expressions.
+
address@hidden {Scheme Procedure} eval expression environment
+Evaluates @var{expression}, which must be a datum representation of a
+valid Scheme expression, in the environment specified by
address@hidden This procedure is identical to the one provided by
+Guile's code library; (@pxref{Fly Evaluation}) for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} environment import-spec ...
+Constructs and returns a new environment based on the specified
address@hidden, which must be datum representations of the import
+specifications used with the @code{import} form. @xref{R6RS Libraries},
+for documentation.
address@hidden deffn
+
address@hidden rnrs mutable-pairs
address@hidden rnrs mutable-pairs
+
+The @code{(rnrs mutable-pairs (6))} library provides the @code{set-car!}
+and @code{set-cdr!} procedures, which allow the @code{car} and
address@hidden fields of a pair to be modified.
+
+These procedures are identical to the ones provide by Guile's core
+library. @xref{Pairs}, for documentation. All pairs in Guile are
+mutable; consequently, these procedures will never throw the
address@hidden&assertion} condition described in the R6RS libraries
+specification.
+
address@hidden rnrs mutable-strings
address@hidden rnrs mutable-strings
+
+The @code{(rnrs mutable-strings (6))} library provides the
address@hidden and @code{string-fill!} procedures, which allow the
+content of strings to be modified ``in-place.''
+
+These procedures are identical to the ones provided by Guile's core
+library. @xref{String Modification}, for documentation. All strings in
+Guile are mutable; consequently, these procedures will never throw the
address@hidden&assertion} condition described in the R6RS libraries
+specification.
+
address@hidden rnrs r5rs
address@hidden rnrs r5rs
+
+The @code{(rnrs r5rs (6))} library exports bindings for some procedures
+present in R5RS but omitted from the R6RS base library specification.
+
address@hidden {Scheme Procedure} exact->inexact z
address@hidden {Scheme Procedure} inexact->exact z
+These procedures are identical to the ones provided by Guile's core
+library. @xref{Exactness}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} quotient n1 n2
address@hidden {Scheme Procedure} remainder n1 n2
address@hidden {Scheme Procedure} modulo n1 n2
+These procedures are identical to the ones provided by Guile's core
+library. @xref{Integer Operations}, for documentation.
address@hidden deffn
+
address@hidden {Scheme Syntax} delay expr
address@hidden {Scheme Procedure} force promise
+The @code{delay} form and the @code{force} procedure are identical to
+their counterparts in Guile's core library. @xref{Delayed Evaluation},
+for documentation.
address@hidden deffn
+
address@hidden {Scheme Procedure} null-environment n
address@hidden {Scheme Procedure} scheme-report-environment n
+These procedures are identical to the ones provided by the
address@hidden(ice-9 r5rs)} Guile module. @xref{Environments}, for
+documentation.
address@hidden deffn
@c r6rs.texi ends here
hooks/post-receive
--
GNU Guile
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Guile-commits] GNU Guile branch, master, updated. release_1-9-11-132-gea28e98,
Julian Graham <=