mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-28 16:00:22 +02:00
Code Activity

Make notation for Scheme repeated arguments more consistent in manual.

Browse source 
* doc/ref/api-compound.texi
* doc/ref/api-control.texi
* doc/ref/api-data.texi
* doc/ref/api-debug.texi
* doc/ref/api-evaluation.texi
* doc/ref/api-macros.texi
* doc/ref/api-memory.texi
* doc/ref/api-modules.texi
* doc/ref/api-procedures.texi
* doc/ref/api-regex.texi
* doc/ref/api-scheduling.texi
* doc/ref/api-utility.texi
* doc/ref/goops.texi
* doc/ref/match.texi
* doc/ref/misc-modules.texi
* doc/ref/posix.texi
* doc/ref/r6rs.texi
* doc/ref/scheme-using.texi
* doc/ref/srfi-modules.texi
* doc/ref/sxml-match.texi: Make notation for Scheme repeated arguments more
  consistent in manual.
This commit is contained in:
Bake Timmons 2012-01-15 10:56:53 -05:00 • committed by Andy Wingo
parent e7f7691f5f
commit df0a100250
20 changed files with 368 additions and 346 deletions
Download patch file Download diff file Expand all files Collapse all files

42
doc/ref/api-compound.texi
View file

@ -326,7 +326,7 @@ the last pair of the list.
@c no-op since it does nothing but return the list the caller must
@c have already created.
@c
@deffn {Scheme Procedure} list elem1 @dots{} elemN
@deffn {Scheme Procedure} list elem @dots{}
@deffnx {C Function} scm_list_1 (elem1)
@deffnx {C Function} scm_list_2 (elem1, elem2)
@deffnx {C Function} scm_list_3 (elem1, elem2, elem3)
@ -334,11 +334,11 @@ the last pair of the list.
@deffnx {C Function} scm_list_5 (elem1, elem2, elem3, elem4, elem5)
@deffnx {C Function} scm_list_n (elem1, @dots{}, elemN, @nicode{SCM_UNDEFINED})
@rnindex list
Return a new list containing elements @var{elem1} to @var{elemN}.
Return a new list containing elements @var{elem} @enddots{}.
@code{scm_list_n} takes a variable number of arguments, terminated by
the special @code{SCM_UNDEFINED}. That final @code{SCM_UNDEFINED} is
not included in the list. None of @var{elem1} to @var{elemN} can
not included in the list. None of @var{elem} @dots{} can
themselves be @code{SCM_UNDEFINED}, or @code{scm_list_n} will
terminate at that point.
@end deffn
@ -430,12 +430,14 @@ pairs. This is why you should be careful when using the side-effecting
variants.
@rnindex append
@deffn {Scheme Procedure} append lst1 @dots{} lstN
@deffnx {Scheme Procedure} append! lst1 @dots{} lstN
@deffn {Scheme Procedure} append lst @dots{} obj
@deffnx {Scheme Procedure} append
@deffnx {Scheme Procedure} append! lst @dots{} obj
@deffnx {Scheme Procedure} append!
@deffnx {C Function} scm_append (lstlst)
@deffnx {C Function} scm_append_x (lstlst)
Return a list comprising all the elements of lists @var{lst1} to
@var{lstN}.
Return a list comprising all the elements of lists @var{lst} @dots{}
@var{obj}. If called with no arguments, return the empty list.
@lisp
(append '(x) '(y)) @result{} (x y)
@ -443,7 +445,7 @@ Return a list comprising all the elements of lists @var{lst1} to
(append '(a (b)) '((c))) @result{} (a (b) (c))
@end lisp
The last argument @var{lstN} may actually be any object; an improper
The last argument @var{obj} may actually be any object; an improper
list results if the last argument is not a proper list.
@lisp
@ -452,11 +454,11 @@ list results if the last argument is not a proper list.
@end lisp
@code{append} doesn't modify the given lists, but the return may share
structure with the final @var{lstN}. @code{append!} modifies the
structure with the final @var{obj}. @code{append!} modifies the
given lists to form its return.
For @code{scm_append} and @code{scm_append_x}, @var{lstlst} is a list
of the list operands @var{lst1} @dots{} @var{lstN}. That @var{lstlst}
of the list operands @var{lst} @dots{} @var{obj}. That @var{lstlst}
itself is not modified or used in the return.
@end deffn
@ -709,7 +711,7 @@ thus created is determined implicitly by the number of arguments given.
@rnindex vector
@rnindex list->vector
@deffn {Scheme Procedure} vector . l
@deffn {Scheme Procedure} vector arg @dots{}
@deffnx {Scheme Procedure} list->vector l
@deffnx {C Function} scm_vector (l)
Return a newly allocated vector composed of the
@ -1010,7 +1012,7 @@ Like @code{scm_make_bitvector}, but the length is given as a
@code{size_t}.
@end deftypefn
@deffn {Scheme Procedure} bitvector . bits
@deffn {Scheme Procedure} bitvector bit @dots{}
@deffnx {C Function} scm_bitvector (bits)
Create a new bitvector with the arguments as elements.
@end deffn
@ -1546,7 +1548,7 @@ is unspecified.
@end deffn
@c begin (texi-doc-string "guile" "array-equal?")
@deffn {Scheme Procedure} array-equal? array1 array2 @dots{}
@deffn {Scheme Procedure} array-equal? array @dots{}
Return @code{#t} if all arguments are arrays with the same shape, the
same type, and have corresponding elements which are either
@code{equal?} or @code{array-equal?}. This function differs from
@ -1563,7 +1565,7 @@ same type, and have corresponding elements which are either
@c at least vaguely matches array-map!, but is it meant to be a
@c documented feature?
@deffn {Scheme Procedure} array-map! dst proc src1 @dots{} srcN
@deffn {Scheme Procedure} array-map! dst proc src @dots{}
@deffnx {Scheme Procedure} array-map-in-order! dst proc src1 @dots{} srcN
@deffnx {C Function} scm_array_map_x (dst, proc, srclist)
Set each element of the @var{dst} array to values obtained from calls
@ -1580,10 +1582,10 @@ range in @var{dst}. This ensures all @var{dst} indices are valid in
each @var{src}.
@end deffn
@deffn {Scheme Procedure} array-for-each proc src1 @dots{} srcN
@deffn {Scheme Procedure} array-for-each proc src1 src2 @dots{}
@deffnx {C Function} scm_array_for_each (proc, src1, srclist)
Apply @var{proc} to each tuple of elements of @var{src1} @dots{}
@var{srcN}, in row-major order. The value returned is unspecified.
Apply @var{proc} to each tuple of elements of @var{src1} @var{src2}
@dots{}, in row-major order. The value returned is unspecified.
@end deffn
@deffn {Scheme Procedure} array-index-map! dst proc
@ -1793,7 +1795,7 @@ be returned only if its elements are stored internally contiguous in
memory.
@end deffn
@deffn {Scheme Procedure} transpose-array array dim1 @dots{}
@deffn {Scheme Procedure} transpose-array array dim1 dim2 @dots{}
@deffnx {C Function} scm_transpose_array (array, dimlist)
Return an array sharing contents with @var{array}, but with
dimensions arranged in a different order. There must be one
@ -2235,7 +2237,7 @@ Return a new vlist, as for SRFI-1 @code{unfold} and @code{unfold-right}
(@pxref{SRFI-1, @code{unfold}}).
@end deffn
@deffn {Scheme Procedure} vlist-append vlists ...
@deffn {Scheme Procedure} vlist-append vlist @dots{}
Append the given vlists and return the resulting vlist.
@end deffn
@ -2465,7 +2467,7 @@ This section describes the basic procedures for working with
structures. @code{make-struct} creates a structure, and
@code{struct-ref} and @code{struct-set!} access write fields.
@deffn {Scheme Procedure} make-struct vtable tail-size [init...]
@deffn {Scheme Procedure} make-struct vtable tail-size init @dots{}
@deffnx {C Function} scm_make_struct (vtable, tail_size, init_list)
Create a new structure, with layout per the given @var{vtable}
(@pxref{Vtables}).

42
doc/ref/api-control.texi
View file

@ -44,7 +44,7 @@ If the test is true, we want to display ``greater'' to the current
output port, then display a newline. We use @code{begin} to form a
compound expression out of this sequence of sub-expressions.
@deffn syntax begin expr1 expr2 @dots{}
@deffn syntax begin expr @dots{}
The expression(s) are evaluated in left-to-right order and the value of
the last expression is returned as the value of the
@code{begin}-expression. This expression type is used when the
@ -277,7 +277,7 @@ Scheme programs is normally expressed using recursion. Nevertheless,
R5RS defines a construct for programming loops, calling @code{do}. In
addition, Guile has an explicit looping syntax called @code{while}.
@deffn syntax do ((variable init [step]) @dots{}) (test [expr @dots{}]) body @dots{}
@deffn syntax do ((variable init [step]) @dots{}) (test expr @dots{}) body @dots{}
Bind @var{variable}s and evaluate @var{body} until @var{test} is true.
The return value is the last @var{expr} after @var{test}, if given. A
simple example will illustrate the basic form,
@ -348,7 +348,7 @@ Run a loop executing the @var{body} forms while @var{cond} is true.
Within @code{while}, two extra bindings are provided, they can be used
from both @var{cond} and @var{body}.
@deffn {Scheme Procedure} break break-arg...
@deffn {Scheme Procedure} break break-arg @dots{}
Break out of the @code{while} form.
@end deffn
@ -487,7 +487,7 @@ tag allows some useful prompt and abort idioms, discussed in the next
section.
@end deffn
@deffn {Scheme Procedure} abort-to-prompt tag val ...
@deffn {Scheme Procedure} abort-to-prompt tag val1 val2 @dots{}
Unwind the dynamic and control context to the nearest prompt named @var{tag},
also passing the given values.
@end deffn
@ -599,8 +599,9 @@ The @code{%} symbol is chosen because it looks like a prompt.
Likewise there is an abbreviation for @code{abort-to-prompt}, which
assumes the default prompt tag:
@deffn {Scheme Procedure} abort val...
Abort to the default prompt tag, passing @var{val...} to the handler.
@deffn {Scheme Procedure} abort val1 val2 @dots{}
Abort to the default prompt tag, passing @var{val1} @var{val2} @dots{}
to the handler.
@end deffn
As mentioned before, @code{(ice-9 control)} also provides other
@ -627,19 +628,22 @@ If both continuation and handler implicitly add prompts, then the
operator is @dfn{+F+}. @code{shift} and @code{reset} are such
operators.
@deffn {Scheme Syntax} reset body...
Establish a prompt, and evaluate @var{body...} within that prompt.
@deffn {Scheme Syntax} reset body1 body2 @dots{}
Establish a prompt, and evaluate @var{body1} @var{body2} @dots{} within
that prompt.
The prompt handler is designed to work with @code{shift}, described
below.
@end deffn
@deffn {Scheme Syntax} shift cont body...
Abort to the nearest @code{reset}, and evaluate @var{body...} in a
context in which the captured continuation is bound to @var{cont}.
@deffn {Scheme Syntax} shift cont body1 body2 @dots{}
Abort to the nearest @code{reset}, and evaluate @var{body1} @var{body2}
@dots{} in a context in which the captured continuation is bound to
@var{cont}.
As mentioned above, both the @var{body...} expression and invocations of
@var{cont} implicitly establish a prompt.
As mentioned above, taken together, the @var{body1} @var{body2} @dots{}
expressions and the invocations of @var{cont} implicitly establish a
prompt.
@end deffn
Interested readers are invited to explore Oleg Kiselyov's wonderful web
@ -803,7 +807,7 @@ multiple values with a procedure which accepts these values as
parameters.
@rnindex values
@deffn {Scheme Procedure} values arg1 @dots{} argN
@deffn {Scheme Procedure} values arg @dots{}
@deffnx {C Function} scm_values (args)
Delivers all of its arguments to its continuation. Except for
continuations created by the @code{call-with-values} procedure,
@ -1220,10 +1224,10 @@ depends on the exception type. The documentation for each possible type
of exception should specify the additional arguments that are expected
for that kind of exception.
@deffn {Scheme Procedure} throw key . args
@deffn {Scheme Procedure} throw key arg @dots{}
@deffnx {C Function} scm_throw (key, args)
Invoke the catch form matching @var{key}, passing @var{args} to the
@var{handler}.
Invoke the catch form matching @var{key}, passing @var{arg} @dots{} to
the @var{handler}.
@var{key} is a symbol. It will match catches of the same symbol or of
@code{#t}.
@ -1312,9 +1316,9 @@ Guile provides a set of convenience procedures for signaling error
conditions that are implemented on top of the exception primitives just
described.
@deffn {Scheme Procedure} error msg args @dots{}
@deffn {Scheme Procedure} error msg arg @dots{}
Raise an error with key @code{misc-error} and a message constructed by
displaying @var{msg} and writing @var{args}.
displaying @var{msg} and writing @var{arg} @enddots{}.
@end deffn
@deffn {Scheme Procedure} scm-error key subr message args data

157
doc/ref/api-data.texi
View file

@ -2324,12 +2324,12 @@ Return @code{#t} if @var{obj} is a character set, @code{#f}
otherwise.
@end deffn
@deffn {Scheme Procedure} char-set= . char_sets
@deffn {Scheme Procedure} char-set= char_set @dots{}
@deffnx {C Function} scm_char_set_eq (char_sets)
Return @code{#t} if all given character sets are equal.
@end deffn
@deffn {Scheme Procedure} char-set<= . char_sets
@deffn {Scheme Procedure} char-set<= char_set @dots{}
@deffnx {C Function} scm_char_set_leq (char_sets)
Return @code{#t} if every character set @var{char_set}i is a subset
of character set @var{char_set}i+1.
@ -2339,7 +2339,7 @@ of character set @var{char_set}i+1.
@deffnx {C Function} scm_char_set_hash (cs, bound)
Compute a hash value for the character set @var{cs}. If
@var{bound} is given and non-zero, it restricts the
returned value to the range 0 @dots{} @var{bound - 1}.
returned value to the range 0 @dots{} @var{bound} - 1.
@end deffn
@c ===================================================================
@ -2443,8 +2443,8 @@ Return a newly allocated character set containing all
characters in @var{cs}.
@end deffn
@deffn {Scheme Procedure} char-set . rest
@deffnx {C Function} scm_char_set (rest)
@deffn {Scheme Procedure} char-set chr @dots{}
@deffnx {C Function} scm_char_set (chrs)
Return a character set containing all given characters.
@end deffn
@ -2607,26 +2607,26 @@ such as union, complement, intersection etc. All of these procedures
provide side-effecting variants, which modify their character set
argument(s).
@deffn {Scheme Procedure} char-set-adjoin cs . rest
@deffnx {C Function} scm_char_set_adjoin (cs, rest)
@deffn {Scheme Procedure} char-set-adjoin cs chr @dots{}
@deffnx {C Function} scm_char_set_adjoin (cs, chrs)
Add all character arguments to the first argument, which must
be a character set.
@end deffn
@deffn {Scheme Procedure} char-set-delete cs . rest
@deffnx {C Function} scm_char_set_delete (cs, rest)
@deffn {Scheme Procedure} char-set-delete cs chr @dots{}
@deffnx {C Function} scm_char_set_delete (cs, chrs)
Delete all character arguments from the first argument, which
must be a character set.
@end deffn
@deffn {Scheme Procedure} char-set-adjoin! cs . rest
@deffnx {C Function} scm_char_set_adjoin_x (cs, rest)
@deffn {Scheme Procedure} char-set-adjoin! cs chr @dots{}
@deffnx {C Function} scm_char_set_adjoin_x (cs, chrs)
Add all character arguments to the first argument, which must
be a character set.
@end deffn
@deffn {Scheme Procedure} char-set-delete! cs . rest
@deffnx {C Function} scm_char_set_delete_x (cs, rest)
@deffn {Scheme Procedure} char-set-delete! cs chr @dots{}
@deffnx {C Function} scm_char_set_delete_x (cs, chrs)
Delete all character arguments from the first argument, which
must be a character set.
@end deffn
@ -2642,28 +2642,28 @@ characters). It may be helpful to modify the output of
@code{char-set-complement} by computing its intersection with the set
of designated code points, @code{char-set:designated}.
@deffn {Scheme Procedure} char-set-union . rest
@deffnx {C Function} scm_char_set_union (rest)
@deffn {Scheme Procedure} char-set-union cs @dots{}
@deffnx {C Function} scm_char_set_union (char_sets)
Return the union of all argument character sets.
@end deffn
@deffn {Scheme Procedure} char-set-intersection . rest
@deffnx {C Function} scm_char_set_intersection (rest)
@deffn {Scheme Procedure} char-set-intersection cs @dots{}
@deffnx {C Function} scm_char_set_intersection (char_sets)
Return the intersection of all argument character sets.
@end deffn
@deffn {Scheme Procedure} char-set-difference cs1 . rest
@deffnx {C Function} scm_char_set_difference (cs1, rest)
@deffn {Scheme Procedure} char-set-difference cs1 cs @dots{}
@deffnx {C Function} scm_char_set_difference (cs1, char_sets)
Return the difference of all argument character sets.
@end deffn
@deffn {Scheme Procedure} char-set-xor . rest
@deffnx {C Function} scm_char_set_xor (rest)
@deffn {Scheme Procedure} char-set-xor cs @dots{}
@deffnx {C Function} scm_char_set_xor (char_sets)
Return the exclusive-or of all argument character sets.
@end deffn
@deffn {Scheme Procedure} char-set-diff+intersection cs1 . rest
@deffnx {C Function} scm_char_set_diff_plus_intersection (cs1, rest)
@deffn {Scheme Procedure} char-set-diff+intersection cs1 cs @dots{}
@deffnx {C Function} scm_char_set_diff_plus_intersection (cs1, char_sets)
Return the difference and the intersection of all argument
character sets.
@end deffn
@ -2673,28 +2673,28 @@ character sets.
Return the complement of the character set @var{cs}.
@end deffn
@deffn {Scheme Procedure} char-set-union! cs1 . rest
@deffnx {C Function} scm_char_set_union_x (cs1, rest)
@deffn {Scheme Procedure} char-set-union! cs1 cs @dots{}
@deffnx {C Function} scm_char_set_union_x (cs1, char_sets)
Return the union of all argument character sets.
@end deffn
@deffn {Scheme Procedure} char-set-intersection! cs1 . rest
@deffnx {C Function} scm_char_set_intersection_x (cs1, rest)
@deffn {Scheme Procedure} char-set-intersection! cs1 cs @dots{}
@deffnx {C Function} scm_char_set_intersection_x (cs1, char_sets)
Return the intersection of all argument character sets.
@end deffn
@deffn {Scheme Procedure} char-set-difference! cs1 . rest
@deffnx {C Function} scm_char_set_difference_x (cs1, rest)
@deffn {Scheme Procedure} char-set-difference! cs1 cs @dots{}
@deffnx {C Function} scm_char_set_difference_x (cs1, char_sets)
Return the difference of all argument character sets.
@end deffn
@deffn {Scheme Procedure} char-set-xor! cs1 . rest
@deffnx {C Function} scm_char_set_xor_x (cs1, rest)
@deffn {Scheme Procedure} char-set-xor! cs1 cs @dots{}
@deffnx {C Function} scm_char_set_xor_x (cs1, char_sets)
Return the exclusive-or of all argument character sets.
@end deffn
@deffn {Scheme Procedure} char-set-diff+intersection! cs1 cs2 . rest
@deffnx {C Function} scm_char_set_diff_plus_intersection_x (cs1, cs2, rest)
@deffn {Scheme Procedure} char-set-diff+intersection! cs1 cs2 cs @dots{}
@deffnx {C Function} scm_char_set_diff_plus_intersection_x (cs1, cs2, char_sets)
Return the difference and the intersection of all argument
character sets.
@end deffn
@ -3404,11 +3404,11 @@ comparison. See @xref{Text Collation, the @code{(ice-9
i18n)} module}, for locale-dependent string comparison.
@rnindex string=?
@deffn {Scheme Procedure} string=? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_equal_p (s1, s2, rest)
Lexicographic equality predicate; return @code{#t} if the two
strings are the same length and contain the same characters in
the same positions, otherwise return @code{#f}.
Lexicographic equality predicate; return @code{#t} if all strings are
the same length and contain the same characters in the same positions,
otherwise return @code{#f}.
The procedure @code{string-ci=?} treats upper and lower case
letters as though they were the same character, but
@ -3417,72 +3417,80 @@ characters.
@end deffn
@rnindex string<?
@deffn {Scheme Procedure} string<? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string<? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_less_p (s1, s2, rest)
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically less than @var{s2}.
Lexicographic ordering predicate; return @code{#t} if, for every pair of
consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
lexicographically less than @var{str_i+1}.
@end deffn
@rnindex string<=?
@deffn {Scheme Procedure} string<=? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string<=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_leq_p (s1, s2, rest)
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically less than or equal to @var{s2}.
Lexicographic ordering predicate; return @code{#t} if, for every pair of
consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
lexicographically less than or equal to @var{str_i+1}.
@end deffn
@rnindex string>?
@deffn {Scheme Procedure} string>? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string>? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_gr_p (s1, s2, rest)
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically greater than @var{s2}.
Lexicographic ordering predicate; return @code{#t} if, for every pair of
consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
lexicographically greater than @var{str_i+1}.
@end deffn
@rnindex string>=?
@deffn {Scheme Procedure} string>=? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string>=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_geq_p (s1, s2, rest)
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically greater than or equal to @var{s2}.
Lexicographic ordering predicate; return @code{#t} if, for every pair of
consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
lexicographically greater than or equal to @var{str_i+1}.
@end deffn
@rnindex string-ci=?
@deffn {Scheme Procedure} string-ci=? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string-ci=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_equal_p (s1, s2, rest)
Case-insensitive string equality predicate; return @code{#t} if
the two strings are the same length and their component
all strings are the same length and their component
characters match (ignoring case) at each position; otherwise
return @code{#f}.
@end deffn
@rnindex string-ci<?
@deffn {Scheme Procedure} string-ci<? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string-ci<? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_less_p (s1, s2, rest)
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically less than @var{s2}
Case insensitive lexicographic ordering predicate; return @code{#t} if,
for every pair of consecutive string arguments @var{str_i} and
@var{str_i+1}, @var{str_i} is lexicographically less than @var{str_i+1}
regardless of case.
@end deffn
@rnindex string<=?
@deffn {Scheme Procedure} string-ci<=? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string-ci<=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_leq_p (s1, s2, rest)
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically less than or equal
to @var{s2} regardless of case.
Case insensitive lexicographic ordering predicate; return @code{#t} if,
for every pair of consecutive string arguments @var{str_i} and
@var{str_i+1}, @var{str_i} is lexicographically less than or equal to
@var{str_i+1} regardless of case.
@end deffn
@rnindex string-ci>?
@deffn {Scheme Procedure} string-ci>? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string-ci>? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_gr_p (s1, s2, rest)
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically greater than
@var{s2} regardless of case.
Case insensitive lexicographic ordering predicate; return @code{#t} if,
for every pair of consecutive string arguments @var{str_i} and
@var{str_i+1}, @var{str_i} is lexicographically greater than
@var{str_i+1} regardless of case.
@end deffn
@rnindex string-ci>=?
@deffn {Scheme Procedure} string-ci>=? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string-ci>=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_geq_p (s1, s2, rest)
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically greater than or
equal to @var{s2} regardless of case.
Case insensitive lexicographic ordering predicate; return @code{#t} if,
for every pair of consecutive string arguments @var{str_i} and
@var{str_i+1}, @var{str_i} is lexicographically greater than or equal to
@var{str_i+1} regardless of case.
@end deffn
@deffn {Scheme Procedure} string-compare s1 s2 proc_lt proc_eq proc_gt [start1 [end1 [start2 [end2]]]]
@ -3934,10 +3942,10 @@ operate on. The return value is unspecified.
@end deffn
@rnindex string-append
@deffn {Scheme Procedure} string-append . args
@deffn {Scheme Procedure} string-append arg @dots{}
@deffnx {C Function} scm_string_append (args)
Return a newly allocated string whose characters form the
concatenation of the given strings, @var{args}.
concatenation of the given strings, @var{arg} @enddots{}.
@example
(let ((h "hello "))
@ -3946,17 +3954,16 @@ concatenation of the given strings, @var{args}.
@end example
@end deffn
@deffn {Scheme Procedure} string-append/shared . rest
@deffnx {C Function} scm_string_append_shared (rest)
@deffn {Scheme Procedure} string-append/shared arg @dots{}
@deffnx {C Function} scm_string_append_shared (args)
Like @code{string-append}, but the result may share memory
with the argument strings.
@end deffn
@deffn {Scheme Procedure} string-concatenate ls
@deffnx {C Function} scm_string_concatenate (ls)
Append the elements of @var{ls} (which must be strings)
together into a single string. Guaranteed to return a freshly
allocated string.
Append the elements (which must be strings) of @var{ls} together into a
single string. Guaranteed to return a freshly allocated string.
@end deffn
@deffn {Scheme Procedure} string-concatenate-reverse ls [final_string [end]]
@ -5181,9 +5188,9 @@ Return a newly allocated symbol made from a list of characters.
@end deffn
@rnindex symbol-append
@deffn {Scheme Procedure} symbol-append . args
@deffn {Scheme Procedure} symbol-append arg @dots{}
Return a newly allocated symbol whose characters form the
concatenation of the given symbols, @var{args}.
concatenation of the given symbols, @var{arg} @enddots{}.
@example
(let ((h 'hello))

6
doc/ref/api-debug.texi
View file

@ -80,15 +80,15 @@ describes the Scheme stack at that point.
Use @code{start-stack} to limit the stack extent captured by future
@code{make-stack} calls.
@deffn {Scheme Procedure} make-stack obj . args
@deffn {Scheme Procedure} make-stack obj arg @dots{}
@deffnx {C Function} scm_make_stack (obj, args)
Create a new stack. If @var{obj} is @code{#t}, the current
evaluation stack is used for creating the stack frames,
otherwise the frames are taken from @var{obj} (which must be
a continuation or a frame object).
@var{args} should be a list containing any combination of
integer, procedure, prompt tag and @code{#t} values.
@var{arg} @dots{} can be any combination of integer, procedure, prompt
tag and @code{#t} values.
These values specify various ways of cutting away uninteresting
stack frames from the top and bottom of the stack that

15
doc/ref/api-evaluation.texi
View file

@ -504,23 +504,22 @@ eval-string)}, evaluating within @var{module} or the current module.
of an @code{SCM}.
@end deftypefn
@deffn {Scheme Procedure} apply proc arg1 @dots{} argN arglst
@deffn {Scheme Procedure} apply proc arg @dots{} arglst
@deffnx {C Function} scm_apply_0 (proc, arglst)
@deffnx {C Function} scm_apply_1 (proc, arg1, arglst)
@deffnx {C Function} scm_apply_2 (proc, arg1, arg2, arglst)
@deffnx {C Function} scm_apply_3 (proc, arg1, arg2, arg3, arglst)
@deffnx {C Function} scm_apply (proc, arg, rest)
@rnindex apply
Call @var{proc} with arguments @var{arg1} @dots{} @var{argN} plus the
Call @var{proc} with arguments @var{arg} @dots{} and the
elements of the @var{arglst} list.
@code{scm_apply} takes parameters corresponding to a Scheme level
@code{(lambda (proc arg . rest) ...)}. So @var{arg} and all but the
last element of the @var{rest} list make up
@var{arg1}@dots{}@var{argN} and the last element of @var{rest} is the
@var{arglst} list. Or if @var{rest} is the empty list @code{SCM_EOL}
then there's no @var{arg1}@dots{}@var{argN} and @var{arg} is the
@var{arglst}.
@code{(lambda (proc arg1 . rest) ...)}. So @var{arg1} and all but the
last element of the @var{rest} list make up @var{arg} @dots{}, and the
last element of @var{rest} is the @var{arglst} list. Or if @var{rest}
is the empty list @code{SCM_EOL} then there's no @var{arg} @dots{}, and
(@var{arg1}) is the @var{arglst}.
@var{arglst} is not modified, but the @var{rest} list passed to
@code{scm_apply} is modified.

10
doc/ref/api-macros.texi
View file

@ -81,8 +81,9 @@ source code will invoke the syntax transformer defined by @var{transformer}.
One can also establish local syntactic bindings with @code{let-syntax}.
@deffn {Syntax} let-syntax ((keyword transformer) ...) exp...
Bind @var{keyword...} to @var{transformer...} while expanding @var{exp...}.
@deffn {Syntax} let-syntax ((keyword transformer) @dots{}) exp1 exp2 @dots{}
Bind each @var{keyword} to its corresponding @var{transformer} while
expanding @var{exp1} @var{exp2} @enddots{}.
A @code{let-syntax} binding only exists at expansion-time.
@ -104,8 +105,9 @@ top-level, or locally. Just as a local @code{define} expands out to an instance
of @code{letrec}, a local @code{define-syntax} expands out to
@code{letrec-syntax}.
@deffn {Syntax} letrec-syntax ((keyword transformer) ...) exp...
Bind @var{keyword...} to @var{transformer...} while expanding @var{exp...}.
@deffn {Syntax} letrec-syntax ((keyword transformer) @dots{}) exp1 exp2 @dots{}
Bind each @var{keyword} to its corresponding @var{transformer} while
expanding @var{exp1} @var{exp2} @enddots{}.
In the spirit of @code{letrec} versus @code{let}, an expansion produced by
@var{transformer} may reference a @var{keyword} bound by the

2
doc/ref/api-memory.texi
View file

@ -398,7 +398,7 @@ set to @var{fill}. The default value for @var{fill} is the
empty list.
@end deffn
@deffn {Scheme Procedure} weak-vector . l
@deffn {Scheme Procedure} weak-vector elem @dots{}
@deffnx {Scheme Procedure} list->weak-vector l
@deffnx {C Function} scm_weak_vector (l)
Construct a weak vector from a list: @code{weak-vector} uses

6
doc/ref/api-modules.texi
View file

@ -250,7 +250,7 @@ Export all bindings which should be in the public interface, either
by using @code{define-public} or @code{export} (both documented below).
@end itemize
@deffn syntax define-module module-name [options @dots{}]
@deffn syntax define-module module-name option @dots{}
@var{module-name} is a list of one or more symbols.
@lisp
@ -260,8 +260,8 @@ by using @code{define-public} or @code{export} (both documented below).
@code{define-module} makes this module available to Guile programs under
the given @var{module-name}.
The @var{options} are keyword/value pairs which specify more about the
defined module. The recognized options and their meaning is shown in
@var{option} @dots{} are keyword/value pairs which specify more about the
defined module. The recognized options and their meaning are shown in
the following table.
@table @code

39
doc/ref/api-procedures.texi
View file

@ -418,8 +418,8 @@ elements. @code{let-optional} binds all variables simultaneously, while
@code{let-optional*} binds them sequentially, consistent with @code{let}
and @code{let*} (@pxref{Local Bindings}).
@deffn {library syntax} let-optional rest-arg (binding @dots{}) expr @dots{}
@deffnx {library syntax} let-optional* rest-arg (binding @dots{}) expr @dots{}
@deffn {library syntax} let-optional rest-arg (binding @dots{}) body1 body2 @dots{}
@deffnx {library syntax} let-optional* rest-arg (binding @dots{}) body1 body2 @dots{}
These two macros give you an optional argument interface that is very
@dfn{Schemey} and introduces no fancy syntax. They are compatible with
the scsh macros of the same name, but are slightly extended. Each of
@ -431,22 +431,22 @@ runs out, the remaining vars are bound either to the default values or
@code{#f} if no default value was specified. @var{rest-arg} remains
bound to whatever may have been left of @var{rest-arg}.
After binding the variables, the expressions @var{expr} @dots{} are
evaluated in order.
After binding the variables, the expressions @var{body1} @var{body2} @dots{}
are evaluated in order.
@end deffn
Similarly, @code{let-keywords} and @code{let-keywords*} extract values
from keyword style argument lists, binding local variables to those
values or to defaults.
@deffn {library syntax} let-keywords args allow-other-keys? (binding @dots{}) body @dots{}
@deffnx {library syntax} let-keywords* args allow-other-keys? (binding @dots{}) body @dots{}
@deffn {library syntax} let-keywords args allow-other-keys? (binding @dots{}) body1 body2 @dots{}
@deffnx {library syntax} let-keywords* args allow-other-keys? (binding @dots{}) body1 body2 @dots{}
@var{args} is evaluated and should give a list of the form
@code{(#:keyword1 value1 #:keyword2 value2 @dots{})}. The
@var{binding}s are variables and default expressions, with the
variables to be set (by name) from the keyword values. The @var{body}
forms are then evaluated and the last is the result. An example will
make the syntax clearest,
@var{binding}s are variables and default expressions, with the variables
to be set (by name) from the keyword values. The @var{body1}
@var{body2} @dots{} forms are then evaluated and the last is the
result. An example will make the syntax clearest,
@example
(define args '(#:xyzzy "hello" #:foo "world"))
@ -478,12 +478,12 @@ exist for defining macros with the improved argument list handling
possibilities. The @code{-public} versions not only define the
procedures/macros, but also export them from the current module.
@deffn {library syntax} define*-public formals body
@deffn {library syntax} define*-public formals body1 body2 @dots{}
Like a mix of @code{define*} and @code{define-public}.
@end deffn
@deffn {library syntax} defmacro* name formals body
@deffnx {library syntax} defmacro*-public name formals body
@deffn {library syntax} defmacro* name formals body1 body2 @dots{}
@deffnx {library syntax} defmacro*-public name formals body1 body2 @dots{}
These are just like @code{defmacro} and @code{defmacro-public} except that they
take @code{lambda*}-style extended parameter lists, where @code{#:optional},
@code{#:key}, @code{#:allow-other-keys} and @code{#:rest} are allowed with the usual
@ -611,10 +611,11 @@ Return a procedure with the same arity as @var{proc} that returns the
@end lisp
@end deffn
@deffn {Scheme Procedure} compose proc rest ...
Compose @var{proc} with the procedures in @var{rest}, such that the last
one in @var{rest} is applied first and @var{proc} last, and return the
resulting procedure. The given procedures must have compatible arity.
@deffn {Scheme Procedure} compose proc1 proc2 @dots{}
Compose @var{proc1} with the procedures @var{proc2} @dots{} such that
the last @var{proc} argument is applied first and @var{proc1} last, and
return the resulting procedure. The given procedures must have
compatible arity.
@lisp
(procedure? (compose 1+ 1-)) @result{} #t
@ -835,9 +836,9 @@ making large procedures inlinable will probably result in an increase in
code size. Additionally, the elimination of the call overhead rarely
matters for large procedures.
@deffn {Scheme Syntax} define-inlinable (name parameter ...) body ...
@deffn {Scheme Syntax} define-inlinable (name parameter @dots{}) body1 body2 @dots{}
Define @var{name} as a procedure with parameters @var{parameter}s and
body @var{body}.
bodies @var{body1}, @var{body2}, @enddots{}.
@end deffn
@c Local Variables:

4
doc/ref/api-regex.texi
View file

@ -228,7 +228,7 @@ and replace them with the contents of another string. The following
functions are convenient ways to do this.
@c begin (scm-doc-string "regex.scm" "regexp-substitute")
@deffn {Scheme Procedure} regexp-substitute port match [item@dots{}]
@deffn {Scheme Procedure} regexp-substitute port match item @dots{}
Write to @var{port} selected parts of the match structure @var{match}.
Or if @var{port} is @code{#f} then form a string from those parts and
return that.
@ -276,7 +276,7 @@ re-ordering and hyphenating the fields.
@c begin (scm-doc-string "regex.scm" "regexp-substitute")
@deffn {Scheme Procedure} regexp-substitute/global port regexp target [item@dots{}]
@deffn {Scheme Procedure} regexp-substitute/global port regexp target item@dots{}
@cindex search and replace
Write to @var{port} selected parts of matches of @var{regexp} in
@var{target}. If @var{port} is @code{#f} then form a string from

48
doc/ref/api-scheduling.texi
View file

@ -323,8 +323,8 @@ the error to the current error port. The @var{arg} @dots{}
expressions are evaluated in the new thread.
@end deffn
@deffn macro begin-thread first [rest@dots{}]
Evaluate forms @var{first} and @var{rest} in a new thread formed by
@deffn macro begin-thread expr1 expr2 @dots{}
Evaluate forms @var{expr1} @var{expr2} @dots{} in a new thread formed by
@code{call-with-new-thread} using a default error handler that display
the error to the current error port.
@end deffn
@ -353,10 +353,10 @@ Acquiring requisite mutexes in a fixed order (like always A before B)
in all threads is one way to avoid such problems.
@sp 1
@deffn {Scheme Procedure} make-mutex . flags
@deffn {Scheme Procedure} make-mutex flag @dots{}
@deffnx {C Function} scm_make_mutex ()
@deffnx {C Function} scm_make_mutex_with_flags (SCM flags)
Return a new mutex. It is initially unlocked. If @var{flags} is
Return a new mutex. It is initially unlocked. If @var{flag} @dots{} is
specified, it must be a list of symbols specifying configuration flags
for the newly-created mutex. The supported flags are:
@table @code
@ -523,25 +523,25 @@ available from
(use-modules (ice-9 threads))
@end example
@deffn macro with-mutex mutex [body@dots{}]
Lock @var{mutex}, evaluate the @var{body} forms, then unlock
@var{mutex}. The return value is the return from the last @var{body}
form.
@deffn macro with-mutex mutex body1 body2 @dots{}
Lock @var{mutex}, evaluate the body @var{body1} @var{body2} @dots{},
then unlock @var{mutex}. The return value is that returned by the last
body form.
The lock, body and unlock form the branches of a @code{dynamic-wind}
(@pxref{Dynamic Wind}), so @var{mutex} is automatically unlocked if an
error or new continuation exits @var{body}, and is re-locked if
@var{body} is re-entered by a captured continuation.
error or new continuation exits the body, and is re-locked if
the body is re-entered by a captured continuation.
@end deffn
@deffn macro monitor body@dots{}
Evaluate the @var{body} forms, with a mutex locked so only one thread
can execute that code at any one time. The return value is the return
from the last @var{body} form.
@deffn macro monitor body1 body2 @dots{}
Evaluate the body form @var{body1} @var{body2} @dots{} with a mutex
locked so only one thread can execute that code at any one time. The
return value is the return from the last body form.
Each @code{monitor} form has its own private mutex and the locking and
evaluation is as per @code{with-mutex} above. A standard mutex
(@code{make-mutex}) is used, which means @var{body} must not
(@code{make-mutex}) is used, which means the body must not
recursively re-enter the @code{monitor} form.
The term ``monitor'' comes from operating system theory, where it
@ -890,11 +890,11 @@ canonical form. For example,
@end example
@end defun
@deffn {Scheme Syntax} parameterize ((param value) @dots{}) body @dots{}
@deffn {library syntax} parameterize ((param value) @dots{}) body1 body2 @dots{}
Establish a new dynamic scope with the given @var{param}s bound to new
locations and set to the given @var{value}s. @var{body} is evaluated
in that environment, the result is the return from the last form in
@var{body}.
locations and set to the given @var{value}s. @var{body1} @var{body2}
@dots{} is evaluated in that environment. The value returned is that of
last body form.
Each @var{param} is an expression which is evaluated to get the
parameter object. Often this will just be the name of a variable
@ -1058,8 +1058,8 @@ the results to the corresponding @var{var} variables, and then evaluate
expressions for the bindings are evaluated in parallel.
@end deffn
@deffn {Scheme Procedure} par-map proc lst1 @dots{} lstN
@deffnx {Scheme Procedure} par-for-each proc lst1 @dots{} lstN
@deffn {Scheme Procedure} par-map proc lst1 lst2 @dots{}
@deffnx {Scheme Procedure} par-for-each proc lst1 lst2 @dots{}
Call @var{proc} on the elements of the given lists. @code{par-map}
returns a list comprising the return values from @var{proc}.
@code{par-for-each} returns an unspecified value, but waits for all
@ -1084,8 +1084,8 @@ completion, which makes them quite expensive.
Therefore, they should be avoided.
@deffn {Scheme Procedure} n-par-map n proc lst1 @dots{} lstN
@deffnx {Scheme Procedure} n-par-for-each n proc lst1 @dots{} lstN
@deffn {Scheme Procedure} n-par-map n proc lst1 lst2 @dots{}
@deffnx {Scheme Procedure} n-par-for-each n proc lst1 lst2 @dots{}
Call @var{proc} on the elements of the given lists, in the same way as
@code{par-map} and @code{par-for-each} above, but use no more than
@var{n} threads at any one time. The order in which calls are
@ -1097,7 +1097,7 @@ a dual-CPU system for instance @math{@var{n}=4} might be enough to
keep the CPUs utilized, and not consume too much memory.
@end deffn
@deffn {Scheme Procedure} n-for-each-par-map n sproc pproc lst1 @dots{} lstN
@deffn {Scheme Procedure} n-for-each-par-map n sproc pproc lst1 lst2 @dots{}
Apply @var{pproc} to the elements of the given lists, and apply
@var{sproc} to each result returned by @var{pproc}. The final return
value is unspecified, but all calls will have been completed before

8
doc/ref/api-utility.texi
View file

@ -583,11 +583,11 @@ value of this procedure is not specified.
Convert the procedure list of @var{hook} to a list.
@end deffn
@deffn {Scheme Procedure} run-hook hook . args
@deffn {Scheme Procedure} run-hook hook arg @dots{}
@deffnx {C Function} scm_run_hook (hook, args)
Apply all procedures from the hook @var{hook} to the arguments
@var{args}. The order of the procedure application is first to
last. The return value of this procedure is not specified.
Apply all procedures from the hook @var{hook} to the arguments @var{arg}
@enddots{}. The order of the procedure application is first to last.
The return value of this procedure is not specified.
@end deffn
If, in C code, you are certain that you have a hook object and well

71
doc/ref/goops.texi
View file

@ -97,11 +97,12 @@ Class options, slot descriptions and inheritance are discussed more
below.
@cindex slot
@deffn syntax define-class name (super @dots{}) slot-definition @dots{} . options
@deffn syntax define-class name (super @dots{}) @
slot-definition @dots{} class-option @dots{}
Define a class called @var{name} that inherits from @var{super}s, with
direct slots defined by @var{slot-definition}s and class options
@var{options}. The newly created class is bound to the variable name
@var{name} in the current environment.
direct slots defined by @var{slot-definition}s and @var{class-option}s.
The newly created class is bound to the variable name @var{name} in the
current environment.
Each @var{slot-definition} is either a symbol that names the slot or a
list,
@ -115,8 +116,7 @@ list with an even number of elements. The even-numbered elements of
@var{slot-options} (counting from zero) are slot option keywords; the
odd-numbered elements are the corresponding values for those keywords.
@var{options} is a similarly structured list containing class option
keywords and corresponding values.
Each @var{class-option} is an option keyword and corresponding value.
@end deffn
As an example, let us define a type for representing a complex number
@ -183,13 +183,13 @@ creates a new @code{<my-complex>} object and binds it to the Scheme
variable @code{c}.
@deffn generic make
@deffnx method make (class <class>) . initargs
@deffnx method make (class <class>) initarg @dots{}
Create and return a new instance of class @var{class}, initialized using
@var{initargs}.
@var{initarg} @enddots{}.
In theory, @var{initargs} can have any structure that is understood by
whatever methods get applied when the @code{initialize} generic function
is applied to the newly allocated instance.
In theory, @var{initarg} @dots{} can have any structure that is
understood by whatever methods get applied when the @code{initialize}
generic function is applied to the newly allocated instance.
In practice, specialized @code{initialize} methods would normally call
@code{(next-method)}, and so eventually the standard GOOPS
@ -206,7 +206,7 @@ instance's class. Any unprocessed keyword value pairs are ignored.
@end deffn
@deffn generic make-instance
@deffnx method make-instance (class <class>) . initargs
@deffnx method make-instance (class <class>) initarg @dots{}
@code{make-instance} is an alias for @code{make}.
@end deffn
@ -674,9 +674,9 @@ setter). Any other previous value, including an existing generic
function, is discarded and replaced by a new, empty generic function.
@end deffn
@deffn syntax define-method (generic parameter @dots{}) . body
@deffn syntax define-method (generic parameter @dots{}) body @dots{}
Define a method for the generic function or accessor @var{generic} with
parameters @var{parameter}s and body @var{body}.
parameters @var{parameter}s and body @var{body} @enddots{}.
@var{generic} is a generic function. If @var{generic} is a variable
which is not yet bound to a generic function object, the expansion of
@ -688,12 +688,12 @@ generic-with-setter object, the expansion will include a call to
Each @var{parameter} must be either a symbol or a two-element list
@code{(@var{symbol} @var{class})}. The symbols refer to variables in
the @var{body} that will be bound to the parameters supplied by the
the body forms that will be bound to the parameters supplied by the
caller when calling this method. The @var{class}es, if present,
specify the possible combinations of parameters to which this method
can be applied.
@var{body} is the body of the method definition.
@var{body} @dots{} are the bodies of the method definition.
@end deffn
@code{define-method} expressions look a little like Scheme procedure
@ -1698,10 +1698,10 @@ If you customize these functions for particular classes or metaclasses,
you may still want to use @code{goops-error} to signal any error
conditions that you detect.
@deffn procedure goops-error format-string . args
@deffn procedure goops-error format-string arg @dots{}
Raise an error with key @code{goops-error} and error message constructed
from @var{format-string} and @var{args}. Error message formatting is
as done by @code{scm-error}.
from @var{format-string} and @var{arg} @enddots{}. Error message
formatting is as done by @code{scm-error}.
@end deffn
@ -2228,11 +2228,12 @@ handles the redefinition by invoking @code{class-redefinition}
(@pxref{Redefining a Class}).
@end itemize
@deffn syntax class name (super @dots{}) slot-definition @dots{} . options
@deffn syntax class name (super @dots{}) @
slot-definition @dots{} class-option @dots{}
Return a newly created class that inherits from @var{super}s, with
direct slots defined by @var{slot-definition}s and class options
@var{options}. For the format of @var{slot-definition}s and
@var{options}, see @ref{Class Definition,, define-class}.
direct slots defined by @var{slot-definition}s and @var{class-option}s.
For the format of @var{slot-definition}s and @var{class-option}s, see
@ref{Class Definition,, define-class}.
@end deffn
@noindent @code{class} expands to an expression which
@ -2250,13 +2251,12 @@ calls @code{make-class} to create the class with the processed and
evaluated parameters.
@end itemize
@deffn procedure make-class supers slots . options
@deffn procedure make-class supers slots class-option @dots{}
Return a newly created class that inherits from @var{supers}, with
direct slots defined by @var{slots} and class options @var{options}.
For the format of @var{slots} and @var{options}, see @ref{Class
direct slots defined by @var{slots} and @var{class-option}s. For the
format of @var{slots} and @var{class-option}s, see @ref{Class
Definition,, define-class}, except note that for @code{make-class},
@var{slots} and @var{options} are separate list parameters: @var{slots}
here is a list of slot definitions.
@var{slots} is a separate list of slot definitions.
@end deffn
@noindent @code{make-class}
@ -2307,18 +2307,19 @@ has to be created once.
The @code{env} parameter is ignored.
@end deffn
@deffn generic make metaclass @dots{}
@deffn generic make metaclass initarg @dots{}
@var{metaclass} is the metaclass of the class being defined, either
taken from the @code{#:metaclass} class option or computed by
@code{ensure-metaclass}. The applied method must create and return the
fully initialized class metaobject for the new class definition.
@end deffn
The @code{(make @var{metaclass} @dots{})} invocation is a particular
case of the instance creation protocol covered in the previous section.
It will create an class metaobject with metaclass @var{metaclass}. By
default, this metaobject will be initialized by the @code{initialize}
method that is specialized for instances of type @code{<class>}.
The @code{(make @var{metaclass} @var{initarg} @dots{})} invocation is a
particular case of the instance creation protocol covered in the
previous section. It will create an class metaobject with metaclass
@var{metaclass}. By default, this metaobject will be initialized by the
@code{initialize} method that is specialized for instances of type
@code{<class>}.
The @code{initialize} method for classes (signature @code{(initialize
<class> initargs)}) calls the following generic functions.
@ -2565,7 +2566,7 @@ calls @code{add-method!} to add this method to the relevant generic
function.
@end itemize
@deffn syntax method (parameter @dots{}) . body
@deffn syntax method (parameter @dots{}) body @dots{}
Make a method whose specializers are defined by the classes in
@var{parameter}s and whose procedure definition is constructed from the
@var{parameter} symbols and @var{body} forms.

18
doc/ref/match.texi
View file

@ -64,16 +64,16 @@ bound to, respectively, the first and second element of @var{l}.
The pattern matcher is defined as follows:
@deffn {Scheme Syntax} match exp clause ...
Match object @var{exp} against the patterns in the given @var{clause}s,
in the order in which they appear. Return the value produced by the
first matching clause. If no @var{clause} matches, throw an exception
with key @code{match-error}.
@deffn {Scheme Syntax} match exp clause1 clause2 @dots{}
Match object @var{exp} against the patterns in @var{clause1}
@var{clause2} @dots{} in the order in which they appear. Return the
value produced by the first matching clause. If no clause matches,
throw an exception with key @code{match-error}.
Each @var{clause} has the form @code{(pattern body)}. Each
@var{pattern} must follow the syntax described below. Each @var{body}
is an arbitrary Scheme expression, possibly referring to pattern
variables of @var{pattern}.
Each clause has the form @code{(pattern body1 body2 @dots{})}. Each
@var{pattern} must follow the syntax described below. Each body is an
arbitrary Scheme expression, possibly referring to pattern variables of
@var{pattern}.
@end deffn
@c FIXME: Document other forms:

20
doc/ref/misc-modules.texi
View file

@ -156,7 +156,7 @@ C programmers will note the similarity between @code{format} and
instead of @nicode{%}, and are more powerful.
@sp 1
@deffn {Scheme Procedure} format dest fmt [args@dots{}]
@deffn {Scheme Procedure} format dest fmt arg @dots{}
Write output specified by the @var{fmt} string to @var{dest}.
@var{dest} can be an output port, @code{#t} for
@code{current-output-port} (@pxref{Default Ports}), or @code{#f} to
@ -1695,35 +1695,35 @@ secondly the number of elements in that list.
Return a vector which is the entire contents of @var{stream}.
@end deffn
@deffn {Scheme Procedure} stream-fold proc init stream0 @dots{} streamN
@defun stream-fold proc init stream1 stream2 @dots{}
Apply @var{proc} successively over the elements of the given streams,
from first to last until the end of the shortest stream is reached.
Return the result from the last @var{proc} call.
Each call is @code{(@var{proc} elem0 @dots{} elemN prev)}, where each
Each call is @code{(@var{proc} elem1 elem2 @dots{} prev)}, where each
@var{elem} is from the corresponding @var{stream}. @var{prev} is the
return from the previous @var{proc} call, or the given @var{init} for
the first call.
@end deffn
@end defun
@deffn {Scheme Procedure} stream-for-each proc stream0 @dots{} streamN
@defun stream-for-each proc stream1 stream2 @dots{}
Call @var{proc} on the elements from the given @var{stream}s. The
return value is unspecified.
Each call is @code{(@var{proc} elem0 @dots{} elemN)}, where each
Each call is @code{(@var{proc} elem1 elem2 @dots{})}, where each
@var{elem} is from the corresponding @var{stream}.
@code{stream-for-each} stops when it reaches the end of the shortest
@var{stream}.
@end deffn
@end defun
@deffn {Scheme Procedure} stream-map proc stream0 @dots{} streamN
@defun stream-map proc stream1 stream2 @dots{}
Return a new stream which is the results of applying @var{proc} to the
elements of the given @var{stream}s.
Each call is @code{(@var{proc} elem0 @dots{} elemN)}, where each
Each call is @code{(@var{proc} elem1 elem2 @dots{})}, where each
@var{elem} is from the corresponding @var{stream}. The new stream
ends when the end of the shortest given @var{stream} is reached.
@end deffn
@end defun
@node Buffered Input

16
doc/ref/posix.texi
View file

@ -1698,12 +1698,12 @@ If @code{system} is called without arguments, return a boolean
indicating whether the command processor is available.
@end deffn
@deffn {Scheme Procedure} system* . args
@deffn {Scheme Procedure} system* arg1 arg2 @dots{}
@deffnx {C Function} scm_system_star (args)
Execute the command indicated by @var{args}. The first element must
be a string indicating the command to be executed, and the remaining
items must be strings representing each of the arguments to that
command.
Execute the command indicated by @var{arg1} @var{arg2} @enddots{}. The
first element must be a string indicating the command to be executed,
and the remaining items must be strings representing each of the
arguments to that command.
This function returns the exit status of the command as provided by
@code{waitpid}. This value can be handled with @code{status:exit-val}
@ -1743,7 +1743,7 @@ in the child would upset the protocol in the parent, so
@code{primitive-_exit} should be used to exit without that.
@end deffn
@deffn {Scheme Procedure} execl filename . args
@deffn {Scheme Procedure} execl filename arg @dots{}
@deffnx {C Function} scm_execl (filename, args)
Executes the file named by @var{filename} as a new process image.
The remaining arguments are supplied to the process; from a C program
@ -1758,7 +1758,7 @@ This procedure is currently implemented using the @code{execv} system
call, but we call it @code{execl} because of its Scheme calling interface.
@end deffn
@deffn {Scheme Procedure} execlp filename . args
@deffn {Scheme Procedure} execlp filename arg @dots{}
@deffnx {C Function} scm_execlp (filename, args)
Similar to @code{execl}, however if
@var{filename} does not contain a slash
@ -1769,7 +1769,7 @@ This procedure is currently implemented using the @code{execvp} system
call, but we call it @code{execlp} because of its Scheme calling interface.
@end deffn
@deffn {Scheme Procedure} execle filename env . args
@deffn {Scheme Procedure} execle filename env arg @dots{}
@deffnx {C Function} scm_execle (filename, env, args)
Similar to @code{execl}, but the environment of the new process is
specified by @var{env}, which must be a list of strings as returned by the

35
doc/ref/r6rs.texi
View file

@ -273,8 +273,10 @@ grouped below by the existing manual sections to which they correspond.
@end deffn
@deffn {Scheme Syntax} define-syntax keyword expression
@deffnx {Scheme Syntax} let-syntax ((keyword transformer) ...) exp ...
@deffnx {Scheme Syntax} letrec-syntax ((keyword transformer) ...) exp ...
@deffnx {Scheme Syntax} let-syntax ((keyword transformer) @dots{})
exp1 exp2 @dots{}
@deffnx {Scheme Syntax} letrec-syntax ((keyword transformer) @dots{})
exp1 exp2 @dots{}
@xref{Defining Macros}, for documentation.
@end deffn
@ -403,7 +405,7 @@ grouped below by the existing manual sections to which they correspond.
@xref{SRFI-1 Fold and Map}, for documentation.
@end deffn
@deffn {Scheme Procedure} list elem1 ... elemN
@deffn {Scheme Procedure} list elem @dots{}
@xref{List Constructors}, for documentation.
@end deffn
@ -413,7 +415,8 @@ grouped below by the existing manual sections to which they correspond.
@xref{List Selection}, for documentation.
@end deffn
@deffn {Scheme Procedure} append lst1 ... lstN
@deffn {Scheme Procedure} append lst @dots{} obj
@deffnx {Scheme Procedure} append
@deffnx {Scheme Procedure} reverse lst
@xref{Append/Reverse}, for documentation.
@end deffn
@ -440,15 +443,15 @@ grouped below by the existing manual sections to which they correspond.
@xref{String Selection}, for documentation.
@end deffn
@deffn {Scheme Procedure} string=? [s1 [s2 . rest]]
@deffnx {Scheme Procedure} string<? [s1 [s2 . rest]]
@deffnx {Scheme Procedure} string>? [s1 [s2 . rest]]
@deffnx {Scheme Procedure} string<=? [s1 [s2 . rest]]
@deffnx {Scheme Procedure} string>=? [s1 [s2 . rest]]
@deffn {Scheme Procedure} string=? s1 s2 s3 @dots{}
@deffnx {Scheme Procedure} string<? s1 s2 s3 @dots{}
@deffnx {Scheme Procedure} string>? s1 s2 s3 @dots{}
@deffnx {Scheme Procedure} string<=? s1 s2 s3 @dots{}
@deffnx {Scheme Procedure} string>=? s1 s2 s3 @dots{}
@xref{String Comparison}, for documentation.
@end deffn
@deffn {Scheme Procedure} string-append . args
@deffn {Scheme Procedure} string-append arg @dots{}
@xref{Reversing and Appending Strings}, for documentation.
@end deffn
@ -579,7 +582,7 @@ These procedures implement the @code{map} and @code{for-each} contracts
over vectors.
@end deffn
@deffn {Scheme Procedure} vector . l
@deffn {Scheme Procedure} vector arg @dots{}
@deffnx {Scheme Procedure} vector? obj
@deffnx {Scheme Procedure} make-vector len
@deffnx {Scheme Procedure} make-vector len fill
@ -600,7 +603,7 @@ over vectors.
@xref{Continuations}, for documentation.
@end deffn
@deffn {Scheme Procedure} values arg1 ... argN
@deffn {Scheme Procedure} values arg @dots{}
@deffnx {Scheme Procedure} call-with-values producer consumer
@xref{Multiple Values}, for documentation.
@end deffn
@ -609,7 +612,7 @@ over vectors.
@xref{Dynamic Wind}, for documentation.
@end deffn
@deffn {Scheme Procedure} apply proc arg1 ... argN arglst
@deffn {Scheme Procedure} apply proc arg @dots{} arglst
@xref{Fly Evaluation}, for documentation.
@end deffn
@ -717,8 +720,8 @@ These procedures are identical to the ones provided by SRFI-1.
@xref{SRFI-1 Filtering and Partitioning}, for @code{partition}.
@end deffn
@deffn {Scheme Procedure} fold-left combine nil list1 list2 ... listn
@deffnx {Scheme Procedure} fold-right combine nil list1 list2 ... listn
@deffn {Scheme Procedure} fold-left combine nil list1 list2 @dots{}
@deffnx {Scheme Procedure} fold-right combine nil list1 list2 @dots{}
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.
@ -903,7 +906,7 @@ compatible with either.
The @code{(rnrs records syntactic (6))} library exports the syntactic
API for working with R6RS records.
@deffn {Scheme Syntax} define-record-type name-spec record-clause*
@deffn {Scheme Syntax} define-record-type name-spec record-clause @dots{}
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

4
doc/ref/scheme-using.texi
View file

@ -230,7 +230,7 @@ Show description/documentation.
Change modules / Show current module.
@end deffn
@deffn {REPL Command} import [module ...]
@deffn {REPL Command} import module @dots{}
Import modules / List those imported.
@end deffn
@ -247,7 +247,7 @@ List current bindings.
@end deffn
@deffn {REPL Command} in module expression
@deffnx {REPL Command} in module command [args ...]
@deffnx {REPL Command} in module command arg @dots{}
Evaluate an expression, or alternatively, execute another meta-command
in the context of a module. For example, @samp{,in (foo bar) ,binding}
will show the bindings in the module @code{(foo bar)}.

169
doc/ref/srfi-modules.texi
View file

@ -475,15 +475,14 @@ first containing the first elements of each lists and the second
containing the second elements of each lists, and so on.
@end deffn
@deffn {Scheme Procedure} count pred lst1 @dots{} lstN
@deffn {Scheme Procedure} count pred lst1 lst2 @dots{}
Return a count of the number of times @var{pred} returns true when
called on elements from the given lists.
@var{pred} is called with @var{N} parameters @code{(@var{pred}
@var{elem1} @dots{} @var{elemN})}, each element being from the
corresponding @var{lst1} @dots{} @var{lstN}. The first call is with
the first element of each list, the second with the second element
from each, and so on.
@var{elem1} @dots{} @var{elemN} )}, each element being from the
corresponding list. The first call is with the first element of each
list, the second with the second element from each, and so on.
Counting stops when the end of the shortest list is reached. At least
one list must be non-circular.
@ -497,14 +496,14 @@ one list must be non-circular.
@c FIXME::martin: Review me!
@deffn {Scheme Procedure} fold proc init lst1 @dots{} lstN
@deffnx {Scheme Procedure} fold-right proc init lst1 @dots{} lstN
Apply @var{proc} to the elements of @var{lst1} @dots{} @var{lstN} to
@deffn {Scheme Procedure} fold proc init lst1 lst2 @dots{}
@deffnx {Scheme Procedure} fold-right proc init lst1 lst2 @dots{}
Apply @var{proc} to the elements of @var{lst1} @var{lst2} @dots{} to
build a result, and return that result.
Each @var{proc} call is @code{(@var{proc} @var{elem1} @dots{}
@var{elemN} @var{previous})}, where @var{elem1} is from @var{lst1},
through @var{elemN} from @var{lstN}. @var{previous} is the return
Each @var{proc} call is @code{(@var{proc} @var{elem1} @var{elem2}
@dots{} @var{previous})}, where @var{elem1} is from @var{lst1},
@var{elem2} is from @var{lst2}, and so on. @var{previous} is the return
from the previous call to @var{proc}, or the given @var{init} for the
first call. If any list is empty, just @var{init} is returned.
@ -534,11 +533,11 @@ string, and the last among equal longest,
@result{} "xyz"
@end example
If @var{lst1} through @var{lstN} have different lengths, @code{fold}
If @var{lst1} @var{lst2} @dots{} have different lengths, @code{fold}
stops when the end of the shortest is reached; @code{fold-right}
commences at the last element of the shortest. Ie.@: elements past
the length of the shortest are ignored in the other @var{lst}s. At
least one @var{lst} must be non-circular.
commences at the last element of the shortest. Ie.@: elements past the
length of the shortest are ignored in the other @var{lst}s. At least
one @var{lst} must be non-circular.
@code{fold} should be preferred over @code{fold-right} if the order of
processing doesn't matter, or can be arranged either way, since
@ -567,8 +566,8 @@ a variable in which to build the result, but a self-contained
@code{for-each} would have to be written out each time.
@end deffn
@deffn {Scheme Procedure} pair-fold proc init lst1 @dots{} lstN
@deffnx {Scheme Procedure} pair-fold-right proc init lst1 @dots{} lstN
@deffn {Scheme Procedure} pair-fold proc init lst1 lst2 @dots{}
@deffnx {Scheme Procedure} pair-fold-right proc init lst1 lst2 @dots{}
The same as @code{fold} and @code{fold-right}, but apply @var{proc} to
the pairs of the lists instead of the list elements.
@end deffn
@ -839,48 +838,51 @@ wanting to use @code{break} from within a @code{while} loop will need
to make a new define under a different name.
@end deffn
@deffn {Scheme Procedure} any pred lst1 lst2 @dots{} lstN
Test whether any set of elements from @var{lst1} @dots{} lstN
satisfies @var{pred}. If so the return value is the return from the
successful @var{pred} call, or if not the return is @code{#f}.
@deffn {Scheme Procedure} any pred lst1 lst2 @dots{}
Test whether any set of elements from @var{lst1} @var{lst2} @dots{}
satisfies @var{pred}. If so, the return value is the return value from
the successful @var{pred} call, or if not, the return value is
@code{#f}.
Each @var{pred} call is @code{(@var{pred} @var{elem1} @dots{}
@var{elemN})} taking an element from each @var{lst}. The calls are
made successively for the first, second, etc elements of the lists,
stopping when @var{pred} returns non-@code{#f}, or when the end of the
shortest list is reached.
If there are n list arguments, then @var{pred} must be a predicate
taking n arguments. Each @var{pred} call is @code{(@var{pred}
@var{elem1} @var{elem2} @dots{} )} taking an element from each
@var{lst}. The calls are made successively for the first, second, etc.
elements of the lists, stopping when @var{pred} returns non-@code{#f},
or when the end of the shortest list is reached.
The @var{pred} call on the last set of elements (ie.@: when the end of
The @var{pred} call on the last set of elements (i.e., when the end of
the shortest list has been reached), if that point is reached, is a
tail call.
@end deffn
@deffn {Scheme Procedure} every pred lst1 lst2 @dots{} lstN
Test whether every set of elements from @var{lst1} @dots{} lstN
satisfies @var{pred}. If so the return value is the return from the
final @var{pred} call, or if not the return is @code{#f}.
@deffn {Scheme Procedure} every pred lst1 lst2 @dots{}
Test whether every set of elements from @var{lst1} @var{lst2} @dots{}
satisfies @var{pred}. If so, the return value is the return from the
final @var{pred} call, or if not, the return value is @code{#f}.
Each @var{pred} call is @code{(@var{pred} @var{elem1} @dots{}
@var{elemN})} taking an element from each @var{lst}. The calls are
made successively for the first, second, etc elements of the lists,
stopping if @var{pred} returns @code{#f}, or when the end of any of
the lists is reached.
If there are n list arguments, then @var{pred} must be a predicate
taking n arguments. Each @var{pred} call is @code{(@var{pred}
@var{elem1} @var{elem2 @dots{}})} taking an element from each
@var{lst}. The calls are made successively for the first, second, etc.
elements of the lists, stopping if @var{pred} returns @code{#f}, or when
the end of any of the lists is reached.
The @var{pred} call on the last set of elements (ie.@: when the end of
The @var{pred} call on the last set of elements (i.e., when the end of
the shortest list has been reached) is a tail call.
If one of @var{lst1} @dots{} @var{lstN} is empty then no calls to
@var{pred} are made, and the return is @code{#t}.
If one of @var{lst1} @var{lst2} @dots{}is empty then no calls to
@var{pred} are made, and the return value is @code{#t}.
@end deffn
@deffn {Scheme Procedure} list-index pred lst1 @dots{} lstN
@deffn {Scheme Procedure} list-index pred lst1 lst2 @dots{}
Return the index of the first set of elements, one from each of
@var{lst1}@dots{}@var{lstN}, which satisfies @var{pred}.
@var{lst1} @var{lst2} @dots{}, which satisfies @var{pred}.
@var{pred} is called as @code{(@var{pred} elem1 @dots{} elemN)}.
@var{pred} is called as @code{(@var{elem1} @var{elem2 @dots{}})}.
Searching stops when the end of the shortest @var{lst} is reached.
The return index starts from 0 for the first set of elements. If no
set of elements pass then the return is @code{#f}.
set of elements pass, then the return value is @code{#f}.
@example
(list-index odd? '(2 4 6 9)) @result{} 3
@ -1045,11 +1047,11 @@ sameness. This predicate must be consistent with @code{eq?}
@code{eq?} then they must also be equal under the predicate. This
simply means a given object must be equal to itself.
@deffn {Scheme Procedure} lset<= = list1 list2 @dots{}
@deffn {Scheme Procedure} lset<= = list @dots{}
Return @code{#t} if each list is a subset of the one following it.
Ie.@: @var{list1} a subset of @var{list2}, @var{list2} a subset of
@var{list3}, etc, for as many lists as given. If only one list or no
lists are given then the return is @code{#t}.
I.e., @var{list1} is a subset of @var{list2}, @var{list2} is a subset of
@var{list3}, etc., for as many lists as given. If only one list or no
lists are given, the return value is @code{#t}.
A list @var{x} is a subset of @var{y} if each element of @var{x} is
equal to some element in @var{y}. Elements are compared using the
@ -1062,11 +1064,11 @@ given @var{=} procedure, called as @code{(@var{=} xelem yelem)}.
@end example
@end deffn
@deffn {Scheme Procedure} lset= = list1 list2 @dots{}
@deffn {Scheme Procedure} lset= = list @dots{}
Return @code{#t} if all argument lists are set-equal. @var{list1} is
compared to @var{list2}, @var{list2} to @var{list3}, etc, for as many
lists as given. If only one list or no lists are given then the
return is @code{#t}.
compared to @var{list2}, @var{list2} to @var{list3}, etc., for as many
lists as given. If only one list or no lists are given, the return
value is @code{#t}.
Two lists @var{x} and @var{y} are set-equal if each element of @var{x}
is equal to some element of @var{y} and conversely each element of
@ -1082,14 +1084,14 @@ yelem)}, but exactly which calls are made is unspecified.
@end example
@end deffn
@deffn {Scheme Procedure} lset-adjoin = list elem1 @dots{}
Add to @var{list} any of the given @var{elem}s not already in the
list. @var{elem}s are @code{cons}ed onto the start of @var{list} (so
the return shares a common tail with @var{list}), but the order
they're added is unspecified.
@deffn {Scheme Procedure} lset-adjoin = list elem @dots{}
Add to @var{list} any of the given @var{elem}s not already in the list.
@var{elem}s are @code{cons}ed onto the start of @var{list} (so the
return value shares a common tail with @var{list}), but the order that
the @var{elem}s are added is unspecified.
The given @var{=} procedure is used for comparing elements, called as
@code{(@var{=} listelem elem)}, ie.@: the second argument is one of
@code{(@var{=} listelem elem)}, i.e., the second argument is one of
the given @var{elem} parameters.
@example
@ -1097,11 +1099,11 @@ the given @var{elem} parameters.
@end example
@end deffn
@deffn {Scheme Procedure} lset-union = list1 list2 @dots{}
@deffnx {Scheme Procedure} lset-union! = list1 list2 @dots{}
@deffn {Scheme Procedure} lset-union = list @dots{}
@deffnx {Scheme Procedure} lset-union! = list @dots{}
Return the union of the argument list sets. The result is built by
taking the union of @var{list1} and @var{list2}, then the union of
that with @var{list3}, etc, for as many lists as given. For one list
that with @var{list3}, etc., for as many lists as given. For one list
argument that list itself is the result, for no list arguments the
result is the empty list.
@ -1197,8 +1199,8 @@ a tail with @var{list1}. @code{lset-diff+intersection!} may modify
@var{list1} to form its results.
@end deffn
@deffn {Scheme Procedure} lset-xor = list1 list2 @dots{}
@deffnx {Scheme Procedure} lset-xor! = list1 list2 @dots{}
@deffn {Scheme Procedure} lset-xor = list @dots{}
@deffnx {Scheme Procedure} lset-xor! = list @dots{}
Return an XOR of the argument lists. For two lists this means those
elements which are in exactly one of the lists. For more than two
lists it means those elements which appear in an odd number of the
@ -3156,10 +3158,10 @@ parameters of a function. It can be used with,
(use-modules (srfi srfi-26))
@end example
@deffn {library syntax} cut slot @dots{}
@deffnx {library syntax} cute slot @dots{}
Return a new procedure which will make a call (@var{slot} @dots{}) but
with selected parameters specialized to given expressions.
@deffn {library syntax} cut slot1 slot2 @dots{}
@deffnx {library syntax} cute slot1 slot2 @dots{}
Return a new procedure which will make a call (@var{slot1} @var{slot2}
@dots{}) but with selected parameters specialized to given expressions.
An example will illustrate the idea. The following is a
specialization of @code{write}, sending output to
@ -3517,7 +3519,7 @@ values as in the following example:
Note that all fields of @var{type} and its supertypes must be specified.
@end deffn
@deffn {Scheme Procedure} make-compound-condition . conditions
@deffn {Scheme Procedure} make-compound-condition condition1 condition2 @dots{}
Return a new compound condition composed of @var{conditions}. The
returned condition has the type of each condition of @var{conditions}
(per @code{condition-has-type?}).
@ -3569,13 +3571,14 @@ The example below defines condition type @code{&foo}, inheriting from
@end lisp
@end deffn
@deffn {library syntax} condition type-field-bindings...
Return a new condition, or compound condition, initialized according to
@var{type-field-bindings}. Each @var{type-field-binding} must have the
form @code{(type field-specs...)}, where @var{type} is the name of a
variable bound to condition type; each @var{field-spec} must have the
form @code{(field-name value)} where @var{field-name} is a symbol
denoting the field being initialized to @var{value}. As for
@deffn {library syntax} condition type-field-binding1 type-field-binding2 @dots{}
Return a new condition or compound condition, initialized according to
@var{type-field-binding1} @var{type-field-binding2} @enddots{}. Each
@var{type-field-binding} must have the form @code{(type
field-specs...)}, where @var{type} is the name of a variable bound to a
condition type; each @var{field-spec} must have the form
@code{(field-name value)} where @var{field-name} is a symbol denoting
the field being initialized to @var{value}. As for
@code{make-condition}, all fields must be specified.
The following example returns a simple condition:
@ -3703,12 +3706,12 @@ Return the specified field of @var{opt}, an option object, as
described above for @code{option}.
@end deffn
@deffn {Scheme Procedure} args-fold args options unrecognized-option-proc operand-proc seeds @dots{}
Process @var{args}, a list of program arguments such as that returned
by @code{(cdr (program-arguments))}, in order against @var{options}, a
list of option objects as described above. All functions called take
the ``seeds'', or the last multiple-values as multiple arguments,
starting with @var{seeds}, and must return the new seeds. Return the
@deffn {Scheme Procedure} args-fold args options unrecognized-option-proc operand-proc seed @dots{}
Process @var{args}, a list of program arguments such as that returned by
@code{(cdr (program-arguments))}, in order against @var{options}, a list
of option objects as described above. All functions called take the
``seeds'', or the last multiple-values as multiple arguments, starting
with @var{seed} @dots{}, and must return the new seeds. Return the
final seeds.
Call @code{unrecognized-option-proc}, which is like an option object's
@ -4021,9 +4024,9 @@ SRFI-55 provides @code{require-extension} which is a portable
mechanism to load selected SRFI modules. This is implemented in the
Guile core, there's no module needed to get SRFI-55 itself.
@deffn {library syntax} require-extension clause@dots{}
Require each of the given @var{clause} features, throwing an error if
any are unavailable.
@deffn {library syntax} require-extension clause1 clause2 @dots{}
Require the features of @var{clause1} @var{clause2} @dots{} , throwing
an error if any are unavailable.
A @var{clause} is of the form @code{(@var{identifier} arg...)}. The
only @var{identifier} currently supported is @code{srfi} and the

2
doc/ref/sxml-match.texi
View file

@ -64,7 +64,7 @@ Dybvig at Indiana University.
@code{sxml-match} provides @code{case}-like form for pattern matching of XML
nodes.
@deffn {Scheme Syntax} sxml-match input-expression clause ...
@deffn {Scheme Syntax} sxml-match input-expression clause1 clause2 @dots{}
Match @var{input-expression}, an SXML tree, according to the given @var{clause}s
(one or more), each consisting of a pattern and one or more expressions to be
evaluated if the pattern match succeeds. Optionally, each @var{clause} within