mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-30 00:40:20 +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 no-op since it does nothing but return the list the caller must
@c have already created. @c have already created.
@c @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_1 (elem1)
@deffnx {C Function} scm_list_2 (elem1, elem2) @deffnx {C Function} scm_list_2 (elem1, elem2)
@deffnx {C Function} scm_list_3 (elem1, elem2, elem3) @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_5 (elem1, elem2, elem3, elem4, elem5)
@deffnx {C Function} scm_list_n (elem1, @dots{}, elemN, @nicode{SCM_UNDEFINED}) @deffnx {C Function} scm_list_n (elem1, @dots{}, elemN, @nicode{SCM_UNDEFINED})
@rnindex list @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 @code{scm_list_n} takes a variable number of arguments, terminated by
the special @code{SCM_UNDEFINED}. That final @code{SCM_UNDEFINED} is 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 themselves be @code{SCM_UNDEFINED}, or @code{scm_list_n} will
terminate at that point. terminate at that point.
@end deffn @end deffn
@ -430,12 +430,14 @@ pairs. This is why you should be careful when using the side-effecting
variants. variants.
@rnindex append @rnindex append
@deffn {Scheme Procedure} append lst1 @dots{} lstN @deffn {Scheme Procedure} append lst @dots{} obj
@deffnx {Scheme Procedure} append! lst1 @dots{} lstN @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 (lstlst)
@deffnx {C Function} scm_append_x (lstlst) @deffnx {C Function} scm_append_x (lstlst)
Return a list comprising all the elements of lists @var{lst1} to Return a list comprising all the elements of lists @var{lst} @dots{}
@var{lstN}. @var{obj}. If called with no arguments, return the empty list.
@lisp @lisp
(append '(x) '(y)) @result{} (x y) (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)) (append '(a (b)) '((c))) @result{} (a (b) (c))
@end lisp @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. list results if the last argument is not a proper list.
@lisp @lisp
@ -452,11 +454,11 @@ list results if the last argument is not a proper list.
@end lisp @end lisp
@code{append} doesn't modify the given lists, but the return may share @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. given lists to form its return.
For @code{scm_append} and @code{scm_append_x}, @var{lstlst} is a list 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. itself is not modified or used in the return.
@end deffn @end deffn
@ -709,7 +711,7 @@ thus created is determined implicitly by the number of arguments given.
@rnindex vector @rnindex vector
@rnindex list->vector @rnindex list->vector
@deffn {Scheme Procedure} vector . l @deffn {Scheme Procedure} vector arg @dots{}
@deffnx {Scheme Procedure} list->vector l @deffnx {Scheme Procedure} list->vector l
@deffnx {C Function} scm_vector (l) @deffnx {C Function} scm_vector (l)
Return a newly allocated vector composed of the 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}. @code{size_t}.
@end deftypefn @end deftypefn
@deffn {Scheme Procedure} bitvector . bits @deffn {Scheme Procedure} bitvector bit @dots{}
@deffnx {C Function} scm_bitvector (bits) @deffnx {C Function} scm_bitvector (bits)
Create a new bitvector with the arguments as elements. Create a new bitvector with the arguments as elements.
@end deffn @end deffn
@ -1546,7 +1548,7 @@ is unspecified.
@end deffn @end deffn
@c begin (texi-doc-string "guile" "array-equal?") @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 Return @code{#t} if all arguments are arrays with the same shape, the
same type, and have corresponding elements which are either same type, and have corresponding elements which are either
@code{equal?} or @code{array-equal?}. This function differs from @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 at least vaguely matches array-map!, but is it meant to be a
@c documented feature? @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 {Scheme Procedure} array-map-in-order! dst proc src1 @dots{} srcN
@deffnx {C Function} scm_array_map_x (dst, proc, srclist) @deffnx {C Function} scm_array_map_x (dst, proc, srclist)
Set each element of the @var{dst} array to values obtained from calls 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}. each @var{src}.
@end deffn @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) @deffnx {C Function} scm_array_for_each (proc, src1, srclist)
Apply @var{proc} to each tuple of elements of @var{src1} @dots{} Apply @var{proc} to each tuple of elements of @var{src1} @var{src2}
@var{srcN}, in row-major order. The value returned is unspecified. @dots{}, in row-major order. The value returned is unspecified.
@end deffn @end deffn
@deffn {Scheme Procedure} array-index-map! dst proc @deffn {Scheme Procedure} array-index-map! dst proc
@ -1793,7 +1795,7 @@ be returned only if its elements are stored internally contiguous in
memory. memory.
@end deffn @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) @deffnx {C Function} scm_transpose_array (array, dimlist)
Return an array sharing contents with @var{array}, but with Return an array sharing contents with @var{array}, but with
dimensions arranged in a different order. There must be one 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}}). (@pxref{SRFI-1, @code{unfold}}).
@end deffn @end deffn
@deffn {Scheme Procedure} vlist-append vlists ... @deffn {Scheme Procedure} vlist-append vlist @dots{}
Append the given vlists and return the resulting vlist. Append the given vlists and return the resulting vlist.
@end deffn @end deffn
@ -2465,7 +2467,7 @@ This section describes the basic procedures for working with
structures. @code{make-struct} creates a structure, and structures. @code{make-struct} creates a structure, and
@code{struct-ref} and @code{struct-set!} access write fields. @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) @deffnx {C Function} scm_make_struct (vtable, tail_size, init_list)
Create a new structure, with layout per the given @var{vtable} Create a new structure, with layout per the given @var{vtable}
(@pxref{Vtables}). (@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 output port, then display a newline. We use @code{begin} to form a
compound expression out of this sequence of sub-expressions. 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 expression(s) are evaluated in left-to-right order and the value of
the last expression is returned as the value of the the last expression is returned as the value of the
@code{begin}-expression. This expression type is used when 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 R5RS defines a construct for programming loops, calling @code{do}. In
addition, Guile has an explicit looping syntax called @code{while}. 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. 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 The return value is the last @var{expr} after @var{test}, if given. A
simple example will illustrate the basic form, 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 Within @code{while}, two extra bindings are provided, they can be used
from both @var{cond} and @var{body}. 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. Break out of the @code{while} form.
@end deffn @end deffn
@ -487,7 +487,7 @@ tag allows some useful prompt and abort idioms, discussed in the next
section. section.
@end deffn @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}, Unwind the dynamic and control context to the nearest prompt named @var{tag},
also passing the given values. also passing the given values.
@end deffn @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 Likewise there is an abbreviation for @code{abort-to-prompt}, which
assumes the default prompt tag: assumes the default prompt tag:
@deffn {Scheme Procedure} abort val... @deffn {Scheme Procedure} abort val1 val2 @dots{}
Abort to the default prompt tag, passing @var{val...} to the handler. Abort to the default prompt tag, passing @var{val1} @var{val2} @dots{}
to the handler.
@end deffn @end deffn
As mentioned before, @code{(ice-9 control)} also provides other 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 operator is @dfn{+F+}. @code{shift} and @code{reset} are such
operators. operators.
@deffn {Scheme Syntax} reset body... @deffn {Scheme Syntax} reset body1 body2 @dots{}
Establish a prompt, and evaluate @var{body...} within that prompt. Establish a prompt, and evaluate @var{body1} @var{body2} @dots{} within
that prompt.
The prompt handler is designed to work with @code{shift}, described The prompt handler is designed to work with @code{shift}, described
below. below.
@end deffn @end deffn
@deffn {Scheme Syntax} shift cont body... @deffn {Scheme Syntax} shift cont body1 body2 @dots{}
Abort to the nearest @code{reset}, and evaluate @var{body...} in a Abort to the nearest @code{reset}, and evaluate @var{body1} @var{body2}
context in which the captured continuation is bound to @var{cont}. @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 As mentioned above, taken together, the @var{body1} @var{body2} @dots{}
@var{cont} implicitly establish a prompt. expressions and the invocations of @var{cont} implicitly establish a
prompt.
@end deffn @end deffn
Interested readers are invited to explore Oleg Kiselyov's wonderful web 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. parameters.
@rnindex values @rnindex values
@deffn {Scheme Procedure} values arg1 @dots{} argN @deffn {Scheme Procedure} values arg @dots{}
@deffnx {C Function} scm_values (args) @deffnx {C Function} scm_values (args)
Delivers all of its arguments to its continuation. Except for Delivers all of its arguments to its continuation. Except for
continuations created by the @code{call-with-values} procedure, 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 of exception should specify the additional arguments that are expected
for that kind of exception. 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) @deffnx {C Function} scm_throw (key, args)
Invoke the catch form matching @var{key}, passing @var{args} to the Invoke the catch form matching @var{key}, passing @var{arg} @dots{} to
@var{handler}. the @var{handler}.
@var{key} is a symbol. It will match catches of the same symbol or of @var{key} is a symbol. It will match catches of the same symbol or of
@code{#t}. @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 conditions that are implemented on top of the exception primitives just
described. 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 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 @end deffn
@deffn {Scheme Procedure} scm-error key subr message args data @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. otherwise.
@end deffn @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) @deffnx {C Function} scm_char_set_eq (char_sets)
Return @code{#t} if all given character sets are equal. Return @code{#t} if all given character sets are equal.
@end deffn @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) @deffnx {C Function} scm_char_set_leq (char_sets)
Return @code{#t} if every character set @var{char_set}i is a subset Return @code{#t} if every character set @var{char_set}i is a subset
of character set @var{char_set}i+1. 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) @deffnx {C Function} scm_char_set_hash (cs, bound)
Compute a hash value for the character set @var{cs}. If Compute a hash value for the character set @var{cs}. If
@var{bound} is given and non-zero, it restricts the @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 @end deffn
@c =================================================================== @c ===================================================================
@ -2443,8 +2443,8 @@ Return a newly allocated character set containing all
characters in @var{cs}. characters in @var{cs}.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set . rest @deffn {Scheme Procedure} char-set chr @dots{}
@deffnx {C Function} scm_char_set (rest) @deffnx {C Function} scm_char_set (chrs)
Return a character set containing all given characters. Return a character set containing all given characters.
@end deffn @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 provide side-effecting variants, which modify their character set
argument(s). argument(s).
@deffn {Scheme Procedure} char-set-adjoin cs . rest @deffn {Scheme Procedure} char-set-adjoin cs chr @dots{}
@deffnx {C Function} scm_char_set_adjoin (cs, rest) @deffnx {C Function} scm_char_set_adjoin (cs, chrs)
Add all character arguments to the first argument, which must Add all character arguments to the first argument, which must
be a character set. be a character set.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-delete cs . rest @deffn {Scheme Procedure} char-set-delete cs chr @dots{}
@deffnx {C Function} scm_char_set_delete (cs, rest) @deffnx {C Function} scm_char_set_delete (cs, chrs)
Delete all character arguments from the first argument, which Delete all character arguments from the first argument, which
must be a character set. must be a character set.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-adjoin! cs . rest @deffn {Scheme Procedure} char-set-adjoin! cs chr @dots{}
@deffnx {C Function} scm_char_set_adjoin_x (cs, rest) @deffnx {C Function} scm_char_set_adjoin_x (cs, chrs)
Add all character arguments to the first argument, which must Add all character arguments to the first argument, which must
be a character set. be a character set.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-delete! cs . rest @deffn {Scheme Procedure} char-set-delete! cs chr @dots{}
@deffnx {C Function} scm_char_set_delete_x (cs, rest) @deffnx {C Function} scm_char_set_delete_x (cs, chrs)
Delete all character arguments from the first argument, which Delete all character arguments from the first argument, which
must be a character set. must be a character set.
@end deffn @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 @code{char-set-complement} by computing its intersection with the set
of designated code points, @code{char-set:designated}. of designated code points, @code{char-set:designated}.
@deffn {Scheme Procedure} char-set-union . rest @deffn {Scheme Procedure} char-set-union cs @dots{}
@deffnx {C Function} scm_char_set_union (rest) @deffnx {C Function} scm_char_set_union (char_sets)
Return the union of all argument character sets. Return the union of all argument character sets.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-intersection . rest @deffn {Scheme Procedure} char-set-intersection cs @dots{}
@deffnx {C Function} scm_char_set_intersection (rest) @deffnx {C Function} scm_char_set_intersection (char_sets)
Return the intersection of all argument character sets. Return the intersection of all argument character sets.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-difference cs1 . rest @deffn {Scheme Procedure} char-set-difference cs1 cs @dots{}
@deffnx {C Function} scm_char_set_difference (cs1, rest) @deffnx {C Function} scm_char_set_difference (cs1, char_sets)
Return the difference of all argument character sets. Return the difference of all argument character sets.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-xor . rest @deffn {Scheme Procedure} char-set-xor cs @dots{}
@deffnx {C Function} scm_char_set_xor (rest) @deffnx {C Function} scm_char_set_xor (char_sets)
Return the exclusive-or of all argument character sets. Return the exclusive-or of all argument character sets.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-diff+intersection cs1 . rest @deffn {Scheme Procedure} char-set-diff+intersection cs1 cs @dots{}
@deffnx {C Function} scm_char_set_diff_plus_intersection (cs1, rest) @deffnx {C Function} scm_char_set_diff_plus_intersection (cs1, char_sets)
Return the difference and the intersection of all argument Return the difference and the intersection of all argument
character sets. character sets.
@end deffn @end deffn
@ -2673,28 +2673,28 @@ character sets.
Return the complement of the character set @var{cs}. Return the complement of the character set @var{cs}.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-union! cs1 . rest @deffn {Scheme Procedure} char-set-union! cs1 cs @dots{}
@deffnx {C Function} scm_char_set_union_x (cs1, rest) @deffnx {C Function} scm_char_set_union_x (cs1, char_sets)
Return the union of all argument character sets. Return the union of all argument character sets.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-intersection! cs1 . rest @deffn {Scheme Procedure} char-set-intersection! cs1 cs @dots{}
@deffnx {C Function} scm_char_set_intersection_x (cs1, rest) @deffnx {C Function} scm_char_set_intersection_x (cs1, char_sets)
Return the intersection of all argument character sets. Return the intersection of all argument character sets.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-difference! cs1 . rest @deffn {Scheme Procedure} char-set-difference! cs1 cs @dots{}
@deffnx {C Function} scm_char_set_difference_x (cs1, rest) @deffnx {C Function} scm_char_set_difference_x (cs1, char_sets)
Return the difference of all argument character sets. Return the difference of all argument character sets.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-xor! cs1 . rest @deffn {Scheme Procedure} char-set-xor! cs1 cs @dots{}
@deffnx {C Function} scm_char_set_xor_x (cs1, rest) @deffnx {C Function} scm_char_set_xor_x (cs1, char_sets)
Return the exclusive-or of all argument character sets. Return the exclusive-or of all argument character sets.
@end deffn @end deffn
@deffn {Scheme Procedure} char-set-diff+intersection! 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, rest) @deffnx {C Function} scm_char_set_diff_plus_intersection_x (cs1, cs2, char_sets)
Return the difference and the intersection of all argument Return the difference and the intersection of all argument
character sets. character sets.
@end deffn @end deffn
@ -3404,11 +3404,11 @@ comparison. See @xref{Text Collation, the @code{(ice-9
i18n)} module}, for locale-dependent string comparison. i18n)} module}, for locale-dependent string comparison.
@rnindex string=? @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) @deffnx {C Function} scm_i_string_equal_p (s1, s2, rest)
Lexicographic equality predicate; return @code{#t} if the two Lexicographic equality predicate; return @code{#t} if all strings are
strings are the same length and contain the same characters in the same length and contain the same characters in the same positions,
the same positions, otherwise return @code{#f}. otherwise return @code{#f}.
The procedure @code{string-ci=?} treats upper and lower case The procedure @code{string-ci=?} treats upper and lower case
letters as though they were the same character, but letters as though they were the same character, but
@ -3417,72 +3417,80 @@ characters.
@end deffn @end deffn
@rnindex string<? @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) @deffnx {C Function} scm_i_string_less_p (s1, s2, rest)
Lexicographic ordering predicate; return @code{#t} if @var{s1} Lexicographic ordering predicate; return @code{#t} if, for every pair of
is lexicographically less than @var{s2}. consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
lexicographically less than @var{str_i+1}.
@end deffn @end deffn
@rnindex string<=? @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) @deffnx {C Function} scm_i_string_leq_p (s1, s2, rest)
Lexicographic ordering predicate; return @code{#t} if @var{s1} Lexicographic ordering predicate; return @code{#t} if, for every pair of
is lexicographically less than or equal to @var{s2}. 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 @end deffn
@rnindex string>? @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) @deffnx {C Function} scm_i_string_gr_p (s1, s2, rest)
Lexicographic ordering predicate; return @code{#t} if @var{s1} Lexicographic ordering predicate; return @code{#t} if, for every pair of
is lexicographically greater than @var{s2}. consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
lexicographically greater than @var{str_i+1}.
@end deffn @end deffn
@rnindex string>=? @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) @deffnx {C Function} scm_i_string_geq_p (s1, s2, rest)
Lexicographic ordering predicate; return @code{#t} if @var{s1} Lexicographic ordering predicate; return @code{#t} if, for every pair of
is lexicographically greater than or equal to @var{s2}. 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 @end deffn
@rnindex string-ci=? @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) @deffnx {C Function} scm_i_string_ci_equal_p (s1, s2, rest)
Case-insensitive string equality predicate; return @code{#t} if 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 characters match (ignoring case) at each position; otherwise
return @code{#f}. return @code{#f}.
@end deffn @end deffn
@rnindex string-ci<? @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) @deffnx {C Function} scm_i_string_ci_less_p (s1, s2, rest)
Case insensitive lexicographic ordering predicate; return Case insensitive lexicographic ordering predicate; return @code{#t} if,
@code{#t} if @var{s1} is lexicographically less than @var{s2} 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. regardless of case.
@end deffn @end deffn
@rnindex string<=? @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) @deffnx {C Function} scm_i_string_ci_leq_p (s1, s2, rest)
Case insensitive lexicographic ordering predicate; return Case insensitive lexicographic ordering predicate; return @code{#t} if,
@code{#t} if @var{s1} is lexicographically less than or equal for every pair of consecutive string arguments @var{str_i} and
to @var{s2} regardless of case. @var{str_i+1}, @var{str_i} is lexicographically less than or equal to
@var{str_i+1} regardless of case.
@end deffn @end deffn
@rnindex string-ci>? @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) @deffnx {C Function} scm_i_string_ci_gr_p (s1, s2, rest)
Case insensitive lexicographic ordering predicate; return Case insensitive lexicographic ordering predicate; return @code{#t} if,
@code{#t} if @var{s1} is lexicographically greater than for every pair of consecutive string arguments @var{str_i} and
@var{s2} regardless of case. @var{str_i+1}, @var{str_i} is lexicographically greater than
@var{str_i+1} regardless of case.
@end deffn @end deffn
@rnindex string-ci>=? @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) @deffnx {C Function} scm_i_string_ci_geq_p (s1, s2, rest)
Case insensitive lexicographic ordering predicate; return Case insensitive lexicographic ordering predicate; return @code{#t} if,
@code{#t} if @var{s1} is lexicographically greater than or for every pair of consecutive string arguments @var{str_i} and
equal to @var{s2} regardless of case. @var{str_i+1}, @var{str_i} is lexicographically greater than or equal to
@var{str_i+1} regardless of case.
@end deffn @end deffn
@deffn {Scheme Procedure} string-compare s1 s2 proc_lt proc_eq proc_gt [start1 [end1 [start2 [end2]]]] @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 @end deffn
@rnindex string-append @rnindex string-append
@deffn {Scheme Procedure} string-append . args @deffn {Scheme Procedure} string-append arg @dots{}
@deffnx {C Function} scm_string_append (args) @deffnx {C Function} scm_string_append (args)
Return a newly allocated string whose characters form the 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 @example
(let ((h "hello ")) (let ((h "hello "))
@ -3946,17 +3954,16 @@ concatenation of the given strings, @var{args}.
@end example @end example
@end deffn @end deffn
@deffn {Scheme Procedure} string-append/shared . rest @deffn {Scheme Procedure} string-append/shared arg @dots{}
@deffnx {C Function} scm_string_append_shared (rest) @deffnx {C Function} scm_string_append_shared (args)
Like @code{string-append}, but the result may share memory Like @code{string-append}, but the result may share memory
with the argument strings. with the argument strings.
@end deffn @end deffn
@deffn {Scheme Procedure} string-concatenate ls @deffn {Scheme Procedure} string-concatenate ls
@deffnx {C Function} scm_string_concatenate (ls) @deffnx {C Function} scm_string_concatenate (ls)
Append the elements of @var{ls} (which must be strings) Append the elements (which must be strings) of @var{ls} together into a
together into a single string. Guaranteed to return a freshly single string. Guaranteed to return a freshly allocated string.
allocated string.
@end deffn @end deffn
@deffn {Scheme Procedure} string-concatenate-reverse ls [final_string [end]] @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 @end deffn
@rnindex symbol-append @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 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 @example
(let ((h 'hello)) (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 Use @code{start-stack} to limit the stack extent captured by future
@code{make-stack} calls. @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) @deffnx {C Function} scm_make_stack (obj, args)
Create a new stack. If @var{obj} is @code{#t}, the current Create a new stack. If @var{obj} is @code{#t}, the current
evaluation stack is used for creating the stack frames, evaluation stack is used for creating the stack frames,
otherwise the frames are taken from @var{obj} (which must be otherwise the frames are taken from @var{obj} (which must be
a continuation or a frame object). a continuation or a frame object).
@var{args} should be a list containing any combination of @var{arg} @dots{} can be any combination of integer, procedure, prompt
integer, procedure, prompt tag and @code{#t} values. tag and @code{#t} values.
These values specify various ways of cutting away uninteresting These values specify various ways of cutting away uninteresting
stack frames from the top and bottom of the stack that 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}. of an @code{SCM}.
@end deftypefn @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_0 (proc, arglst)
@deffnx {C Function} scm_apply_1 (proc, arg1, 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_2 (proc, arg1, arg2, arglst)
@deffnx {C Function} scm_apply_3 (proc, arg1, arg2, arg3, arglst) @deffnx {C Function} scm_apply_3 (proc, arg1, arg2, arg3, arglst)
@deffnx {C Function} scm_apply (proc, arg, rest) @deffnx {C Function} scm_apply (proc, arg, rest)
@rnindex apply @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. elements of the @var{arglst} list.
@code{scm_apply} takes parameters corresponding to a Scheme level @code{scm_apply} takes parameters corresponding to a Scheme level
@code{(lambda (proc arg . rest) ...)}. So @var{arg} and all but the @code{(lambda (proc arg1 . rest) ...)}. So @var{arg1} and all but the
last element of the @var{rest} list make up last element of the @var{rest} list make up @var{arg} @dots{}, and the
@var{arg1}@dots{}@var{argN} and the last element of @var{rest} is the last element of @var{rest} is the @var{arglst} list. Or if @var{rest}
@var{arglst} list. Or if @var{rest} is the empty list @code{SCM_EOL} is the empty list @code{SCM_EOL} then there's no @var{arg} @dots{}, and
then there's no @var{arg1}@dots{}@var{argN} and @var{arg} is the (@var{arg1}) is the @var{arglst}.
@var{arglst}.
@var{arglst} is not modified, but the @var{rest} list passed to @var{arglst} is not modified, but the @var{rest} list passed to
@code{scm_apply} is modified. @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}. One can also establish local syntactic bindings with @code{let-syntax}.
@deffn {Syntax} let-syntax ((keyword transformer) ...) exp... @deffn {Syntax} let-syntax ((keyword transformer) @dots{}) exp1 exp2 @dots{}
Bind @var{keyword...} to @var{transformer...} while expanding @var{exp...}. 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. 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 of @code{letrec}, a local @code{define-syntax} expands out to
@code{letrec-syntax}. @code{letrec-syntax}.
@deffn {Syntax} letrec-syntax ((keyword transformer) ...) exp... @deffn {Syntax} letrec-syntax ((keyword transformer) @dots{}) exp1 exp2 @dots{}
Bind @var{keyword...} to @var{transformer...} while expanding @var{exp...}. 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 In the spirit of @code{letrec} versus @code{let}, an expansion produced by
@var{transformer} may reference a @var{keyword} bound by the @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. empty list.
@end deffn @end deffn
@deffn {Scheme Procedure} weak-vector . l @deffn {Scheme Procedure} weak-vector elem @dots{}
@deffnx {Scheme Procedure} list->weak-vector l @deffnx {Scheme Procedure} list->weak-vector l
@deffnx {C Function} scm_weak_vector (l) @deffnx {C Function} scm_weak_vector (l)
Construct a weak vector from a list: @code{weak-vector} uses 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). by using @code{define-public} or @code{export} (both documented below).
@end itemize @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. @var{module-name} is a list of one or more symbols.
@lisp @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 @code{define-module} makes this module available to Guile programs under
the given @var{module-name}. the given @var{module-name}.
The @var{options} are keyword/value pairs which specify more about the @var{option} @dots{} are keyword/value pairs which specify more about the
defined module. The recognized options and their meaning is shown in defined module. The recognized options and their meaning are shown in
the following table. the following table.
@table @code @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} @code{let-optional*} binds them sequentially, consistent with @code{let}
and @code{let*} (@pxref{Local Bindings}). and @code{let*} (@pxref{Local Bindings}).
@deffn {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{}) expr @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 These two macros give you an optional argument interface that is very
@dfn{Schemey} and introduces no fancy syntax. They are compatible with @dfn{Schemey} and introduces no fancy syntax. They are compatible with
the scsh macros of the same name, but are slightly extended. Each of 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 @code{#f} if no default value was specified. @var{rest-arg} remains
bound to whatever may have been left of @var{rest-arg}. bound to whatever may have been left of @var{rest-arg}.
After binding the variables, the expressions @var{expr} @dots{} are After binding the variables, the expressions @var{body1} @var{body2} @dots{}
evaluated in order. are evaluated in order.
@end deffn @end deffn
Similarly, @code{let-keywords} and @code{let-keywords*} extract values Similarly, @code{let-keywords} and @code{let-keywords*} extract values
from keyword style argument lists, binding local variables to those from keyword style argument lists, binding local variables to those
values or to defaults. values or to defaults.
@deffn {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{}) body @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 @var{args} is evaluated and should give a list of the form
@code{(#:keyword1 value1 #:keyword2 value2 @dots{})}. The @code{(#:keyword1 value1 #:keyword2 value2 @dots{})}. The
@var{binding}s are variables and default expressions, with the @var{binding}s are variables and default expressions, with the variables
variables to be set (by name) from the keyword values. The @var{body} to be set (by name) from the keyword values. The @var{body1}
forms are then evaluated and the last is the result. An example will @var{body2} @dots{} forms are then evaluated and the last is the
make the syntax clearest, result. An example will make the syntax clearest,
@example @example
(define args '(#:xyzzy "hello" #:foo "world")) (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 possibilities. The @code{-public} versions not only define the
procedures/macros, but also export them from the current module. 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}. Like a mix of @code{define*} and @code{define-public}.
@end deffn @end deffn
@deffn {library syntax} defmacro* name formals body @deffn {library syntax} defmacro* name formals body1 body2 @dots{}
@deffnx {library syntax} defmacro*-public name formals body @deffnx {library syntax} defmacro*-public name formals body1 body2 @dots{}
These are just like @code{defmacro} and @code{defmacro-public} except that they These are just like @code{defmacro} and @code{defmacro-public} except that they
take @code{lambda*}-style extended parameter lists, where @code{#:optional}, take @code{lambda*}-style extended parameter lists, where @code{#:optional},
@code{#:key}, @code{#:allow-other-keys} and @code{#:rest} are allowed with the usual @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 lisp
@end deffn @end deffn
@deffn {Scheme Procedure} compose proc rest ... @deffn {Scheme Procedure} compose proc1 proc2 @dots{}
Compose @var{proc} with the procedures in @var{rest}, such that the last Compose @var{proc1} with the procedures @var{proc2} @dots{} such that
one in @var{rest} is applied first and @var{proc} last, and return the the last @var{proc} argument is applied first and @var{proc1} last, and
resulting procedure. The given procedures must have compatible arity. return the resulting procedure. The given procedures must have
compatible arity.
@lisp @lisp
(procedure? (compose 1+ 1-)) @result{} #t (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 code size. Additionally, the elimination of the call overhead rarely
matters for large procedures. 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 Define @var{name} as a procedure with parameters @var{parameter}s and
body @var{body}. bodies @var{body1}, @var{body2}, @enddots{}.
@end deffn @end deffn
@c Local Variables: @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. functions are convenient ways to do this.
@c begin (scm-doc-string "regex.scm" "regexp-substitute") @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}. 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 Or if @var{port} is @code{#f} then form a string from those parts and
return that. return that.
@ -276,7 +276,7 @@ re-ordering and hyphenating the fields.
@c begin (scm-doc-string "regex.scm" "regexp-substitute") @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 @cindex search and replace
Write to @var{port} selected parts of matches of @var{regexp} in 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 @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. expressions are evaluated in the new thread.
@end deffn @end deffn
@deffn macro begin-thread first [rest@dots{}] @deffn macro begin-thread expr1 expr2 @dots{}
Evaluate forms @var{first} and @var{rest} in a new thread formed by 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 @code{call-with-new-thread} using a default error handler that display
the error to the current error port. the error to the current error port.
@end deffn @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. in all threads is one way to avoid such problems.
@sp 1 @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 ()
@deffnx {C Function} scm_make_mutex_with_flags (SCM flags) @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 specified, it must be a list of symbols specifying configuration flags
for the newly-created mutex. The supported flags are: for the newly-created mutex. The supported flags are:
@table @code @table @code
@ -523,25 +523,25 @@ available from
(use-modules (ice-9 threads)) (use-modules (ice-9 threads))
@end example @end example
@deffn macro with-mutex mutex [body@dots{}] @deffn macro with-mutex mutex body1 body2 @dots{}
Lock @var{mutex}, evaluate the @var{body} forms, then unlock Lock @var{mutex}, evaluate the body @var{body1} @var{body2} @dots{},
@var{mutex}. The return value is the return from the last @var{body} then unlock @var{mutex}. The return value is that returned by the last
form. body form.
The lock, body and unlock form the branches of a @code{dynamic-wind} The lock, body and unlock form the branches of a @code{dynamic-wind}
(@pxref{Dynamic Wind}), so @var{mutex} is automatically unlocked if an (@pxref{Dynamic Wind}), so @var{mutex} is automatically unlocked if an
error or new continuation exits @var{body}, and is re-locked if error or new continuation exits the body, and is re-locked if
@var{body} is re-entered by a captured continuation. the body is re-entered by a captured continuation.
@end deffn @end deffn
@deffn macro monitor body@dots{} @deffn macro monitor body1 body2 @dots{}
Evaluate the @var{body} forms, with a mutex locked so only one thread Evaluate the body form @var{body1} @var{body2} @dots{} with a mutex
can execute that code at any one time. The return value is the return locked so only one thread can execute that code at any one time. The
from the last @var{body} form. return value is the return from the last body form.
Each @code{monitor} form has its own private mutex and the locking and Each @code{monitor} form has its own private mutex and the locking and
evaluation is as per @code{with-mutex} above. A standard mutex 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. recursively re-enter the @code{monitor} form.
The term ``monitor'' comes from operating system theory, where it The term ``monitor'' comes from operating system theory, where it
@ -890,11 +890,11 @@ canonical form. For example,
@end example @end example
@end defun @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 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 locations and set to the given @var{value}s. @var{body1} @var{body2}
in that environment, the result is the return from the last form in @dots{} is evaluated in that environment. The value returned is that of
@var{body}. last body form.
Each @var{param} is an expression which is evaluated to get the Each @var{param} is an expression which is evaluated to get the
parameter object. Often this will just be the name of a variable 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. expressions for the bindings are evaluated in parallel.
@end deffn @end deffn
@deffn {Scheme Procedure} par-map proc lst1 @dots{} lstN @deffn {Scheme Procedure} par-map proc lst1 lst2 @dots{}
@deffnx {Scheme Procedure} par-for-each proc lst1 @dots{} lstN @deffnx {Scheme Procedure} par-for-each proc lst1 lst2 @dots{}
Call @var{proc} on the elements of the given lists. @code{par-map} Call @var{proc} on the elements of the given lists. @code{par-map}
returns a list comprising the return values from @var{proc}. returns a list comprising the return values from @var{proc}.
@code{par-for-each} returns an unspecified value, but waits for all @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. Therefore, they should be avoided.
@deffn {Scheme Procedure} n-par-map 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 @dots{} lstN @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 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 @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 @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. keep the CPUs utilized, and not consume too much memory.
@end deffn @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 Apply @var{pproc} to the elements of the given lists, and apply
@var{sproc} to each result returned by @var{pproc}. The final return @var{sproc} to each result returned by @var{pproc}. The final return
value is unspecified, but all calls will have been completed before 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. Convert the procedure list of @var{hook} to a list.
@end deffn @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) @deffnx {C Function} scm_run_hook (hook, args)
Apply all procedures from the hook @var{hook} to the arguments Apply all procedures from the hook @var{hook} to the arguments @var{arg}
@var{args}. The order of the procedure application is first to @enddots{}. The order of the procedure application is first to last.
last. The return value of this procedure is not specified. The return value of this procedure is not specified.
@end deffn @end deffn
If, in C code, you are certain that you have a hook object and well 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. below.
@cindex slot @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 Define a class called @var{name} that inherits from @var{super}s, with
direct slots defined by @var{slot-definition}s and class options direct slots defined by @var{slot-definition}s and @var{class-option}s.
@var{options}. The newly created class is bound to the variable name The newly created class is bound to the variable name @var{name} in the
@var{name} in the current environment. current environment.
Each @var{slot-definition} is either a symbol that names the slot or a Each @var{slot-definition} is either a symbol that names the slot or a
list, 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 @var{slot-options} (counting from zero) are slot option keywords; the
odd-numbered elements are the corresponding values for those keywords. odd-numbered elements are the corresponding values for those keywords.
@var{options} is a similarly structured list containing class option Each @var{class-option} is an option keyword and corresponding value.
keywords and corresponding values.
@end deffn @end deffn
As an example, let us define a type for representing a complex number 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}. variable @code{c}.
@deffn generic make @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 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 In theory, @var{initarg} @dots{} can have any structure that is
whatever methods get applied when the @code{initialize} generic function understood by whatever methods get applied when the @code{initialize}
is applied to the newly allocated instance. generic function is applied to the newly allocated instance.
In practice, specialized @code{initialize} methods would normally call In practice, specialized @code{initialize} methods would normally call
@code{(next-method)}, and so eventually the standard GOOPS @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 @end deffn
@deffn generic make-instance @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}. @code{make-instance} is an alias for @code{make}.
@end deffn @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. function, is discarded and replaced by a new, empty generic function.
@end deffn @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 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 @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 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 Each @var{parameter} must be either a symbol or a two-element list
@code{(@var{symbol} @var{class})}. The symbols refer to variables in @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, caller when calling this method. The @var{class}es, if present,
specify the possible combinations of parameters to which this method specify the possible combinations of parameters to which this method
can be applied. can be applied.
@var{body} is the body of the method definition. @var{body} @dots{} are the bodies of the method definition.
@end deffn @end deffn
@code{define-method} expressions look a little like Scheme procedure @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 you may still want to use @code{goops-error} to signal any error
conditions that you detect. 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 Raise an error with key @code{goops-error} and error message constructed
from @var{format-string} and @var{args}. Error message formatting is from @var{format-string} and @var{arg} @enddots{}. Error message
as done by @code{scm-error}. formatting is as done by @code{scm-error}.
@end deffn @end deffn
@ -2228,11 +2228,12 @@ handles the redefinition by invoking @code{class-redefinition}
(@pxref{Redefining a Class}). (@pxref{Redefining a Class}).
@end itemize @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 Return a newly created class that inherits from @var{super}s, with
direct slots defined by @var{slot-definition}s and class options direct slots defined by @var{slot-definition}s and @var{class-option}s.
@var{options}. For the format of @var{slot-definition}s and For the format of @var{slot-definition}s and @var{class-option}s, see
@var{options}, see @ref{Class Definition,, define-class}. @ref{Class Definition,, define-class}.
@end deffn @end deffn
@noindent @code{class} expands to an expression which @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. evaluated parameters.
@end itemize @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 Return a newly created class that inherits from @var{supers}, with
direct slots defined by @var{slots} and class options @var{options}. direct slots defined by @var{slots} and @var{class-option}s. For the
For the format of @var{slots} and @var{options}, see @ref{Class format of @var{slots} and @var{class-option}s, see @ref{Class
Definition,, define-class}, except note that for @code{make-class}, Definition,, define-class}, except note that for @code{make-class},
@var{slots} and @var{options} are separate list parameters: @var{slots} @var{slots} is a separate list of slot definitions.
here is a list of slot definitions.
@end deffn @end deffn
@noindent @code{make-class} @noindent @code{make-class}
@ -2307,18 +2307,19 @@ has to be created once.
The @code{env} parameter is ignored. The @code{env} parameter is ignored.
@end deffn @end deffn
@deffn generic make metaclass @dots{} @deffn generic make metaclass initarg @dots{}
@var{metaclass} is the metaclass of the class being defined, either @var{metaclass} is the metaclass of the class being defined, either
taken from the @code{#:metaclass} class option or computed by taken from the @code{#:metaclass} class option or computed by
@code{ensure-metaclass}. The applied method must create and return the @code{ensure-metaclass}. The applied method must create and return the
fully initialized class metaobject for the new class definition. fully initialized class metaobject for the new class definition.
@end deffn @end deffn
The @code{(make @var{metaclass} @dots{})} invocation is a particular The @code{(make @var{metaclass} @var{initarg} @dots{})} invocation is a
case of the instance creation protocol covered in the previous section. particular case of the instance creation protocol covered in the
It will create an class metaobject with metaclass @var{metaclass}. By previous section. It will create an class metaobject with metaclass
default, this metaobject will be initialized by the @code{initialize} @var{metaclass}. By default, this metaobject will be initialized by the
method that is specialized for instances of type @code{<class>}. @code{initialize} method that is specialized for instances of type
@code{<class>}.
The @code{initialize} method for classes (signature @code{(initialize The @code{initialize} method for classes (signature @code{(initialize
<class> initargs)}) calls the following generic functions. <class> initargs)}) calls the following generic functions.
@ -2565,7 +2566,7 @@ calls @code{add-method!} to add this method to the relevant generic
function. function.
@end itemize @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 Make a method whose specializers are defined by the classes in
@var{parameter}s and whose procedure definition is constructed from the @var{parameter}s and whose procedure definition is constructed from the
@var{parameter} symbols and @var{body} forms. @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: The pattern matcher is defined as follows:
@deffn {Scheme Syntax} match exp clause ... @deffn {Scheme Syntax} match exp clause1 clause2 @dots{}
Match object @var{exp} against the patterns in the given @var{clause}s, Match object @var{exp} against the patterns in @var{clause1}
in the order in which they appear. Return the value produced by the @var{clause2} @dots{} in the order in which they appear. Return the
first matching clause. If no @var{clause} matches, throw an exception value produced by the first matching clause. If no clause matches,
with key @code{match-error}. throw an exception with key @code{match-error}.
Each @var{clause} has the form @code{(pattern body)}. Each Each clause has the form @code{(pattern body1 body2 @dots{})}. Each
@var{pattern} must follow the syntax described below. Each @var{body} @var{pattern} must follow the syntax described below. Each body is an
is an arbitrary Scheme expression, possibly referring to pattern arbitrary Scheme expression, possibly referring to pattern variables of
variables of @var{pattern}. @var{pattern}.
@end deffn @end deffn
@c FIXME: Document other forms: @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. instead of @nicode{%}, and are more powerful.
@sp 1 @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}. Write output specified by the @var{fmt} string to @var{dest}.
@var{dest} can be an output port, @code{#t} for @var{dest} can be an output port, @code{#t} for
@code{current-output-port} (@pxref{Default Ports}), or @code{#f} to @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}. Return a vector which is the entire contents of @var{stream}.
@end deffn @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, Apply @var{proc} successively over the elements of the given streams,
from first to last until the end of the shortest stream is reached. from first to last until the end of the shortest stream is reached.
Return the result from the last @var{proc} call. 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 @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 return from the previous @var{proc} call, or the given @var{init} for
the first call. 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 Call @var{proc} on the elements from the given @var{stream}s. The
return value is unspecified. 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}. @var{elem} is from the corresponding @var{stream}.
@code{stream-for-each} stops when it reaches the end of the shortest @code{stream-for-each} stops when it reaches the end of the shortest
@var{stream}. @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 Return a new stream which is the results of applying @var{proc} to the
elements of the given @var{stream}s. 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 @var{elem} is from the corresponding @var{stream}. The new stream
ends when the end of the shortest given @var{stream} is reached. ends when the end of the shortest given @var{stream} is reached.
@end deffn @end defun
@node Buffered Input @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. indicating whether the command processor is available.
@end deffn @end deffn
@deffn {Scheme Procedure} system* . args @deffn {Scheme Procedure} system* arg1 arg2 @dots{}
@deffnx {C Function} scm_system_star (args) @deffnx {C Function} scm_system_star (args)
Execute the command indicated by @var{args}. The first element must Execute the command indicated by @var{arg1} @var{arg2} @enddots{}. The
be a string indicating the command to be executed, and the remaining first element must be a string indicating the command to be executed,
items must be strings representing each of the arguments to that and the remaining items must be strings representing each of the
command. arguments to that command.
This function returns the exit status of the command as provided by This function returns the exit status of the command as provided by
@code{waitpid}. This value can be handled with @code{status:exit-val} @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. @code{primitive-_exit} should be used to exit without that.
@end deffn @end deffn
@deffn {Scheme Procedure} execl filename . args @deffn {Scheme Procedure} execl filename arg @dots{}
@deffnx {C Function} scm_execl (filename, args) @deffnx {C Function} scm_execl (filename, args)
Executes the file named by @var{filename} as a new process image. Executes the file named by @var{filename} as a new process image.
The remaining arguments are supplied to the process; from a C program 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. call, but we call it @code{execl} because of its Scheme calling interface.
@end deffn @end deffn
@deffn {Scheme Procedure} execlp filename . args @deffn {Scheme Procedure} execlp filename arg @dots{}
@deffnx {C Function} scm_execlp (filename, args) @deffnx {C Function} scm_execlp (filename, args)
Similar to @code{execl}, however if Similar to @code{execl}, however if
@var{filename} does not contain a slash @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. call, but we call it @code{execlp} because of its Scheme calling interface.
@end deffn @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) @deffnx {C Function} scm_execle (filename, env, args)
Similar to @code{execl}, but the environment of the new process is 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 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 @end deffn
@deffn {Scheme Syntax} define-syntax keyword expression @deffn {Scheme Syntax} define-syntax keyword expression
@deffnx {Scheme Syntax} let-syntax ((keyword transformer) ...) exp ... @deffnx {Scheme Syntax} let-syntax ((keyword transformer) @dots{})
@deffnx {Scheme Syntax} letrec-syntax ((keyword transformer) ...) exp ... exp1 exp2 @dots{}
@deffnx {Scheme Syntax} letrec-syntax ((keyword transformer) @dots{})
exp1 exp2 @dots{}
@xref{Defining Macros}, for documentation. @xref{Defining Macros}, for documentation.
@end deffn @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. @xref{SRFI-1 Fold and Map}, for documentation.
@end deffn @end deffn
@deffn {Scheme Procedure} list elem1 ... elemN @deffn {Scheme Procedure} list elem @dots{}
@xref{List Constructors}, for documentation. @xref{List Constructors}, for documentation.
@end deffn @end deffn
@ -413,7 +415,8 @@ grouped below by the existing manual sections to which they correspond.
@xref{List Selection}, for documentation. @xref{List Selection}, for documentation.
@end deffn @end deffn
@deffn {Scheme Procedure} append lst1 ... lstN @deffn {Scheme Procedure} append lst @dots{} obj
@deffnx {Scheme Procedure} append
@deffnx {Scheme Procedure} reverse lst @deffnx {Scheme Procedure} reverse lst
@xref{Append/Reverse}, for documentation. @xref{Append/Reverse}, for documentation.
@end deffn @end deffn
@ -440,15 +443,15 @@ grouped below by the existing manual sections to which they correspond.
@xref{String Selection}, for documentation. @xref{String Selection}, for documentation.
@end deffn @end deffn
@deffn {Scheme Procedure} string=? [s1 [s2 . rest]] @deffn {Scheme Procedure} string=? s1 s2 s3 @dots{}
@deffnx {Scheme Procedure} string<? [s1 [s2 . rest]] @deffnx {Scheme Procedure} string<? s1 s2 s3 @dots{}
@deffnx {Scheme Procedure} string>? [s1 [s2 . rest]] @deffnx {Scheme Procedure} string>? s1 s2 s3 @dots{}
@deffnx {Scheme Procedure} string<=? [s1 [s2 . rest]] @deffnx {Scheme Procedure} string<=? s1 s2 s3 @dots{}
@deffnx {Scheme Procedure} string>=? [s1 [s2 . rest]] @deffnx {Scheme Procedure} string>=? s1 s2 s3 @dots{}
@xref{String Comparison}, for documentation. @xref{String Comparison}, for documentation.
@end deffn @end deffn
@deffn {Scheme Procedure} string-append . args @deffn {Scheme Procedure} string-append arg @dots{}
@xref{Reversing and Appending Strings}, for documentation. @xref{Reversing and Appending Strings}, for documentation.
@end deffn @end deffn
@ -579,7 +582,7 @@ These procedures implement the @code{map} and @code{for-each} contracts
over vectors. over vectors.
@end deffn @end deffn
@deffn {Scheme Procedure} vector . l @deffn {Scheme Procedure} vector arg @dots{}
@deffnx {Scheme Procedure} vector? obj @deffnx {Scheme Procedure} vector? obj
@deffnx {Scheme Procedure} make-vector len @deffnx {Scheme Procedure} make-vector len
@deffnx {Scheme Procedure} make-vector len fill @deffnx {Scheme Procedure} make-vector len fill
@ -600,7 +603,7 @@ over vectors.
@xref{Continuations}, for documentation. @xref{Continuations}, for documentation.
@end deffn @end deffn
@deffn {Scheme Procedure} values arg1 ... argN @deffn {Scheme Procedure} values arg @dots{}
@deffnx {Scheme Procedure} call-with-values producer consumer @deffnx {Scheme Procedure} call-with-values producer consumer
@xref{Multiple Values}, for documentation. @xref{Multiple Values}, for documentation.
@end deffn @end deffn
@ -609,7 +612,7 @@ over vectors.
@xref{Dynamic Wind}, for documentation. @xref{Dynamic Wind}, for documentation.
@end deffn @end deffn
@deffn {Scheme Procedure} apply proc arg1 ... argN arglst @deffn {Scheme Procedure} apply proc arg @dots{} arglst
@xref{Fly Evaluation}, for documentation. @xref{Fly Evaluation}, for documentation.
@end deffn @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}. @xref{SRFI-1 Filtering and Partitioning}, for @code{partition}.
@end deffn @end deffn
@deffn {Scheme Procedure} fold-left combine nil list1 list2 ... listn @deffn {Scheme Procedure} fold-left combine nil list1 list2 @dots{}
@deffnx {Scheme Procedure} fold-right combine nil list1 list2 ... listn @deffnx {Scheme Procedure} fold-right combine nil list1 list2 @dots{}
These procedures are identical to the @code{fold} and @code{fold-right} These procedures are identical to the @code{fold} and @code{fold-right}
procedures provided by SRFI-1. @xref{SRFI-1 Fold and Map}, for procedures provided by SRFI-1. @xref{SRFI-1 Fold and Map}, for
documentation. documentation.
@ -903,7 +906,7 @@ compatible with either.
The @code{(rnrs records syntactic (6))} library exports the syntactic The @code{(rnrs records syntactic (6))} library exports the syntactic
API for working with R6RS records. 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 Defines a new record type, introducing bindings for a record-type
descriptor, a record constructor descriptor, a constructor procedure, descriptor, a record constructor descriptor, a constructor procedure,
a record predicate, and accessor and mutator procedures for the new 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. Change modules / Show current module.
@end deffn @end deffn
@deffn {REPL Command} import [module ...] @deffn {REPL Command} import module @dots{}
Import modules / List those imported. Import modules / List those imported.
@end deffn @end deffn
@ -247,7 +247,7 @@ List current bindings.
@end deffn @end deffn
@deffn {REPL Command} in module expression @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 Evaluate an expression, or alternatively, execute another meta-command
in the context of a module. For example, @samp{,in (foo bar) ,binding} in the context of a module. For example, @samp{,in (foo bar) ,binding}
will show the bindings in the module @code{(foo bar)}. 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. containing the second elements of each lists, and so on.
@end deffn @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 Return a count of the number of times @var{pred} returns true when
called on elements from the given lists. called on elements from the given lists.
@var{pred} is called with @var{N} parameters @code{(@var{pred} @var{pred} is called with @var{N} parameters @code{(@var{pred}
@var{elem1} @dots{} @var{elemN})}, each element being from the @var{elem1} @dots{} @var{elemN} )}, each element being from the
corresponding @var{lst1} @dots{} @var{lstN}. The first call is with corresponding list. The first call is with the first element of each
the first element of each list, the second with the second element list, the second with the second element from each, and so on.
from each, and so on.
Counting stops when the end of the shortest list is reached. At least Counting stops when the end of the shortest list is reached. At least
one list must be non-circular. one list must be non-circular.
@ -497,14 +496,14 @@ one list must be non-circular.
@c FIXME::martin: Review me! @c FIXME::martin: Review me!
@deffn {Scheme Procedure} fold proc init lst1 @dots{} lstN @deffn {Scheme Procedure} fold proc init lst1 lst2 @dots{}
@deffnx {Scheme Procedure} fold-right proc init lst1 @dots{} lstN @deffnx {Scheme Procedure} fold-right proc init lst1 lst2 @dots{}
Apply @var{proc} to the elements of @var{lst1} @dots{} @var{lstN} to Apply @var{proc} to the elements of @var{lst1} @var{lst2} @dots{} to
build a result, and return that result. build a result, and return that result.
Each @var{proc} call is @code{(@var{proc} @var{elem1} @dots{} Each @var{proc} call is @code{(@var{proc} @var{elem1} @var{elem2}
@var{elemN} @var{previous})}, where @var{elem1} is from @var{lst1}, @dots{} @var{previous})}, where @var{elem1} is from @var{lst1},
through @var{elemN} from @var{lstN}. @var{previous} is the return @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 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. 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" @result{} "xyz"
@end example @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} stops when the end of the shortest is reached; @code{fold-right}
commences at the last element of the shortest. Ie.@: elements past commences at the last element of the shortest. Ie.@: elements past the
the length of the shortest are ignored in the other @var{lst}s. At length of the shortest are ignored in the other @var{lst}s. At least
least one @var{lst} must be non-circular. one @var{lst} must be non-circular.
@code{fold} should be preferred over @code{fold-right} if the order of @code{fold} should be preferred over @code{fold-right} if the order of
processing doesn't matter, or can be arranged either way, since 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. @code{for-each} would have to be written out each time.
@end deffn @end deffn
@deffn {Scheme Procedure} pair-fold proc init lst1 @dots{} lstN @deffn {Scheme Procedure} pair-fold proc init lst1 lst2 @dots{}
@deffnx {Scheme Procedure} pair-fold-right proc init lst1 @dots{} lstN @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 same as @code{fold} and @code{fold-right}, but apply @var{proc} to
the pairs of the lists instead of the list elements. the pairs of the lists instead of the list elements.
@end deffn @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. to make a new define under a different name.
@end deffn @end deffn
@deffn {Scheme Procedure} any pred lst1 lst2 @dots{} lstN @deffn {Scheme Procedure} any pred lst1 lst2 @dots{}
Test whether any set of elements from @var{lst1} @dots{} lstN Test whether any set of elements from @var{lst1} @var{lst2} @dots{}
satisfies @var{pred}. If so the return value is the return from the satisfies @var{pred}. If so, the return value is the return value from
successful @var{pred} call, or if not the return is @code{#f}. 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{} If there are n list arguments, then @var{pred} must be a predicate
@var{elemN})} taking an element from each @var{lst}. The calls are taking n arguments. Each @var{pred} call is @code{(@var{pred}
made successively for the first, second, etc elements of the lists, @var{elem1} @var{elem2} @dots{} )} taking an element from each
stopping when @var{pred} returns non-@code{#f}, or when the end of the @var{lst}. The calls are made successively for the first, second, etc.
shortest list is reached. 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 the shortest list has been reached), if that point is reached, is a
tail call. tail call.
@end deffn @end deffn
@deffn {Scheme Procedure} every pred lst1 lst2 @dots{} lstN @deffn {Scheme Procedure} every pred lst1 lst2 @dots{}
Test whether every set of elements from @var{lst1} @dots{} lstN 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 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}. final @var{pred} call, or if not, the return value is @code{#f}.
Each @var{pred} call is @code{(@var{pred} @var{elem1} @dots{} If there are n list arguments, then @var{pred} must be a predicate
@var{elemN})} taking an element from each @var{lst}. The calls are taking n arguments. Each @var{pred} call is @code{(@var{pred}
made successively for the first, second, etc elements of the lists, @var{elem1} @var{elem2 @dots{}})} taking an element from each
stopping if @var{pred} returns @code{#f}, or when the end of any of @var{lst}. The calls are made successively for the first, second, etc.
the lists is reached. 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. the shortest list has been reached) is a tail call.
If one of @var{lst1} @dots{} @var{lstN} is empty then no calls to If one of @var{lst1} @var{lst2} @dots{}is empty then no calls to
@var{pred} are made, and the return is @code{#t}. @var{pred} are made, and the return value is @code{#t}.
@end deffn @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 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. 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 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 @example
(list-index odd? '(2 4 6 9)) @result{} 3 (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 @code{eq?} then they must also be equal under the predicate. This
simply means a given object must be equal to itself. 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. 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 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 @var{list3}, etc., for as many lists as given. If only one list or no
lists are given then the return is @code{#t}. 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 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 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 example
@end deffn @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 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 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 lists as given. If only one list or no lists are given, the return
return is @code{#t}. value is @code{#t}.
Two lists @var{x} and @var{y} are set-equal if each element of @var{x} 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 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 example
@end deffn @end deffn
@deffn {Scheme Procedure} lset-adjoin = list elem1 @dots{} @deffn {Scheme Procedure} lset-adjoin = list elem @dots{}
Add to @var{list} any of the given @var{elem}s not already in the Add to @var{list} any of the given @var{elem}s not already in the list.
list. @var{elem}s are @code{cons}ed onto the start of @var{list} (so @var{elem}s are @code{cons}ed onto the start of @var{list} (so the
the return shares a common tail with @var{list}), but the order return value shares a common tail with @var{list}), but the order that
they're added is unspecified. the @var{elem}s are added is unspecified.
The given @var{=} procedure is used for comparing elements, called as 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. the given @var{elem} parameters.
@example @example
@ -1097,11 +1099,11 @@ the given @var{elem} parameters.
@end example @end example
@end deffn @end deffn
@deffn {Scheme Procedure} lset-union = list1 list2 @dots{} @deffn {Scheme Procedure} lset-union = list @dots{}
@deffnx {Scheme Procedure} lset-union! = list1 list2 @dots{} @deffnx {Scheme Procedure} lset-union! = list @dots{}
Return the union of the argument list sets. The result is built by 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 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 argument that list itself is the result, for no list arguments the
result is the empty list. 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. @var{list1} to form its results.
@end deffn @end deffn
@deffn {Scheme Procedure} lset-xor = list1 list2 @dots{} @deffn {Scheme Procedure} lset-xor = list @dots{}
@deffnx {Scheme Procedure} lset-xor! = list1 list2 @dots{} @deffnx {Scheme Procedure} lset-xor! = list @dots{}
Return an XOR of the argument lists. For two lists this means those 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 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 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)) (use-modules (srfi srfi-26))
@end example @end example
@deffn {library syntax} cut slot @dots{} @deffn {library syntax} cut slot1 slot2 @dots{}
@deffnx {library syntax} cute slot @dots{} @deffnx {library syntax} cute slot1 slot2 @dots{}
Return a new procedure which will make a call (@var{slot} @dots{}) but Return a new procedure which will make a call (@var{slot1} @var{slot2}
with selected parameters specialized to given expressions. @dots{}) but with selected parameters specialized to given expressions.
An example will illustrate the idea. The following is a An example will illustrate the idea. The following is a
specialization of @code{write}, sending output to 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. Note that all fields of @var{type} and its supertypes must be specified.
@end deffn @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 Return a new compound condition composed of @var{conditions}. The
returned condition has the type of each condition of @var{conditions} returned condition has the type of each condition of @var{conditions}
(per @code{condition-has-type?}). (per @code{condition-has-type?}).
@ -3569,13 +3571,14 @@ The example below defines condition type @code{&foo}, inheriting from
@end lisp @end lisp
@end deffn @end deffn
@deffn {library syntax} condition type-field-bindings... @deffn {library syntax} condition type-field-binding1 type-field-binding2 @dots{}
Return a new condition, or compound condition, initialized according to Return a new condition or compound condition, initialized according to
@var{type-field-bindings}. Each @var{type-field-binding} must have the @var{type-field-binding1} @var{type-field-binding2} @enddots{}. Each
form @code{(type field-specs...)}, where @var{type} is the name of a @var{type-field-binding} must have the form @code{(type
variable bound to condition type; each @var{field-spec} must have the field-specs...)}, where @var{type} is the name of a variable bound to a
form @code{(field-name value)} where @var{field-name} is a symbol condition type; each @var{field-spec} must have the form
denoting the field being initialized to @var{value}. As for @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. @code{make-condition}, all fields must be specified.
The following example returns a simple condition: 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}. described above for @code{option}.
@end deffn @end deffn
@deffn {Scheme Procedure} args-fold args options unrecognized-option-proc operand-proc seeds @dots{} @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 Process @var{args}, a list of program arguments such as that returned by
by @code{(cdr (program-arguments))}, in order against @var{options}, a @code{(cdr (program-arguments))}, in order against @var{options}, a list
list of option objects as described above. All functions called take of option objects as described above. All functions called take the
the ``seeds'', or the last multiple-values as multiple arguments, ``seeds'', or the last multiple-values as multiple arguments, starting
starting with @var{seeds}, and must return the new seeds. Return the with @var{seed} @dots{}, and must return the new seeds. Return the
final seeds. final seeds.
Call @code{unrecognized-option-proc}, which is like an option object's 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 mechanism to load selected SRFI modules. This is implemented in the
Guile core, there's no module needed to get SRFI-55 itself. Guile core, there's no module needed to get SRFI-55 itself.
@deffn {library syntax} require-extension clause@dots{} @deffn {library syntax} require-extension clause1 clause2 @dots{}
Require each of the given @var{clause} features, throwing an error if Require the features of @var{clause1} @var{clause2} @dots{} , throwing
any are unavailable. an error if any are unavailable.
A @var{clause} is of the form @code{(@var{identifier} arg...)}. The A @var{clause} is of the form @code{(@var{identifier} arg...)}. The
only @var{identifier} currently supported is @code{srfi} and 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 @code{sxml-match} provides @code{case}-like form for pattern matching of XML
nodes. 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 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 (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 evaluated if the pattern match succeeds. Optionally, each @var{clause} within