summaryrefslogtreecommitdiff
path: root/doc/ref/srfi-modules.texi
diff options
context:
space:
mode:
Diffstat (limited to 'doc/ref/srfi-modules.texi')
-rw-r--r--doc/ref/srfi-modules.texi460
1 files changed, 230 insertions, 230 deletions
diff --git a/doc/ref/srfi-modules.texi b/doc/ref/srfi-modules.texi
index c620050f0..b115068a0 100644
--- a/doc/ref/srfi-modules.texi
+++ b/doc/ref/srfi-modules.texi
@@ -199,24 +199,24 @@ processing procedure, you should also have a look at the sections
New lists can be constructed by calling one of the following
procedures.
-@deffn procedure xcons d a
+@deffn {Scheme Procedure} xcons d a
Like @code{cons}, but with interchanged arguments. Useful mostly when
passed to higher-order procedures.
@end deffn
-@deffn procedure list-tabulate n init-proc
+@deffn {Scheme Procedure} list-tabulate n init-proc
Return an @var{n}-element list, where each list element is produced by
applying the procedure @var{init-proc} to the corresponding list
index. The order in which @var{init-proc} is applied to the indices
is not specified.
@end deffn
-@deffn procedure circular-list elt1 elt2 @dots{}
+@deffn {Scheme Procedure} circular-list elt1 elt2 @dots{}
Return a circular list containing the given arguments @var{elt1}
@var{elt2} @dots{}.
@end deffn
-@deffn procedure iota count [start step]
+@deffn {Scheme Procedure} iota count [start step]
Return a list containing @var{count} elements, where each element is
calculated as follows:
@@ -233,23 +233,23 @@ calculated as follows:
The procedures in this section test specific properties of lists.
-@deffn procedure proper-list? obj
+@deffn {Scheme Procedure} proper-list? obj
Return @code{#t} if @var{obj} is a proper list, that is a finite list,
terminated with the empty list. Otherwise, return @code{#f}.
@end deffn
-@deffn procedure circular-list? obj
+@deffn {Scheme Procedure} circular-list? obj
Return @code{#t} if @var{obj} is a circular list, otherwise return
@code{#f}.
@end deffn
-@deffn procedure dotted-list? obj
+@deffn {Scheme Procedure} dotted-list? obj
Return @code{#t} if @var{obj} is a dotted list, return @code{#f}
otherwise. A dotted list is a finite list which is not terminated by
the empty list, but some other value.
@end deffn
-@deffn procedure null-list? lst
+@deffn {Scheme Procedure} null-list? lst
Return @code{#t} if @var{lst} is the empty list @code{()}, @code{#f}
otherwise. If something else than a proper or circular list is passed
as @var{lst}, an error is signalled. This procedure is recommented
@@ -257,14 +257,14 @@ for checking for the end of a list in contexts where dotted lists are
not allowed.
@end deffn
-@deffn procedure not-pair? obj
+@deffn {Scheme Procedure} not-pair? obj
Return @code{#t} is @var{obj} is not a pair, @code{#f} otherwise.
This is shorthand notation @code{(not (pair? @var{obj}))} and is
supposed to be used for end-of-list checking in contexts where dotted
lists are allowed.
@end deffn
-@deffn procedure list= elt= list1 @dots{}
+@deffn {Scheme Procedure} list= elt= list1 @dots{}
Return @code{#t} if all argument lists are equal, @code{#f} otherwise.
List equality is determined by testing whether all lists have the same
length and the corresponding elements are equal in the sense of the
@@ -278,42 +278,42 @@ equality predicate @var{elt=}. If no or only one list is given,
@c FIXME::martin: Review me!
-@deffn procedure first pair
-@deffnx procedure second pair
-@deffnx procedure third pair
-@deffnx procedure fourth pair
-@deffnx procedure fifth pair
-@deffnx procedure sixth pair
-@deffnx procedure seventh pair
-@deffnx procedure eighth pair
-@deffnx procedure ninth pair
-@deffnx procedure tenth pair
+@deffn {Scheme Procedure} first pair
+@deffnx {Scheme Procedure} second pair
+@deffnx {Scheme Procedure} third pair
+@deffnx {Scheme Procedure} fourth pair
+@deffnx {Scheme Procedure} fifth pair
+@deffnx {Scheme Procedure} sixth pair
+@deffnx {Scheme Procedure} seventh pair
+@deffnx {Scheme Procedure} eighth pair
+@deffnx {Scheme Procedure} ninth pair
+@deffnx {Scheme Procedure} tenth pair
These are synonyms for @code{car}, @code{cadr}, @code{caddr}, @dots{}.
@end deffn
-@deffn procedure car+cdr pair
+@deffn {Scheme Procedure} car+cdr pair
Return two values, the @sc{car} and the @sc{cdr} of @var{pair}.
@end deffn
-@deffn procedure take lst i
-@deffnx procedure take! lst i
+@deffn {Scheme Procedure} take lst i
+@deffnx {Scheme Procedure} take! lst i
Return a list containing the first @var{i} elements of @var{lst}.
@code{take!} may modify the structure of the argument list @var{lst}
in order to produce the result.
@end deffn
-@deffn procedure drop lst i
+@deffn {Scheme Procedure} drop lst i
Return a list containing all but the first @var{i} elements of
@var{lst}.
@end deffn
-@deffn procedure take-right lst i
+@deffn {Scheme Procedure} take-right lst i
Return the a list containing the @var{i} last elements of @var{lst}.
@end deffn
-@deffn procedure drop-right lst i
-@deffnx procedure drop-right! lst i
+@deffn {Scheme Procedure} drop-right lst i
+@deffnx {Scheme Procedure} drop-right! lst i
Return the a list containing all but the @var{i} last elements of
@var{lst}.
@@ -321,8 +321,8 @@ Return the a list containing all but the @var{i} last elements of
@var{lst} in order to produce the result.
@end deffn
-@deffn procedure split-at lst i
-@deffnx procedure split-at! lst i
+@deffn {Scheme Procedure} split-at lst i
+@deffnx {Scheme Procedure} split-at! lst i
Return two values, a list containing the first @var{i} elements of the
list @var{lst} and a list containing the remaining elements.
@@ -330,7 +330,7 @@ list @var{lst} and a list containing the remaining elements.
@var{lst} in order to produce the result.
@end deffn
-@deffn procedure last lst
+@deffn {Scheme Procedure} last lst
Return the last element of the non-empty, finite list @var{lst}.
@end deffn
@@ -340,21 +340,21 @@ Return the last element of the non-empty, finite list @var{lst}.
@c FIXME::martin: Review me!
-@deffn procedure length+ lst
+@deffn {Scheme Procedure} length+ lst
Return the length of the argument list @var{lst}. When @var{lst} is a
circular list, @code{#f} is returned.
@end deffn
-@deffn procedure concatenate list-of-lists
-@deffnx procedure concatenate! list-of-lists
+@deffn {Scheme Procedure} concatenate list-of-lists
+@deffnx {Scheme Procedure} concatenate! list-of-lists
Construct a list by appending all lists in @var{list-of-lists}.
@code{concatenate!} may modify the structure of the given lists in
order to produce the result.
@end deffn
-@deffn procedure append-reverse rev-head tail
-@deffnx procedure append-reverse! rev-head tail
+@deffn {Scheme Procedure} append-reverse rev-head tail
+@deffnx {Scheme Procedure} append-reverse! rev-head tail
Reverse @var{rev-head}, append @var{tail} and return the result. This
is equivalent to @code{(append (reverse @var{rev-head}) @var{tail})},
but more efficient.
@@ -363,18 +363,18 @@ but more efficient.
the result.
@end deffn
-@deffn procedure zip lst1 lst2 @dots{}
+@deffn {Scheme Procedure} zip lst1 lst2 @dots{}
Return a list as long as the shortest of the argument lists, where
each element is a list. The first list contains the first elements of
the argument lists, the second list contains the second elements, and
so on.
@end deffn
-@deffn procedure unzip1 lst
-@deffnx procedure unzip2 lst
-@deffnx procedure unzip3 lst
-@deffnx procedure unzip4 lst
-@deffnx procedure unzip5 lst
+@deffn {Scheme Procedure} unzip1 lst
+@deffnx {Scheme Procedure} unzip2 lst
+@deffnx {Scheme Procedure} unzip3 lst
+@deffnx {Scheme Procedure} unzip4 lst
+@deffnx {Scheme Procedure} unzip5 lst
@code{unzip1} takes a list of lists, and returns a list containing the
first elements of each list, @code{unzip2} returns two lists, the
first containing the first elements of each lists and the second
@@ -387,7 +387,7 @@ containing the second elements of each lists, and so on.
@c FIXME::martin: Review me!
-@deffn procedure fold kons knil lst1 lst2 @dots{}
+@deffn {Scheme Procedure} fold kons knil lst1 lst2 @dots{}
Fold the procedure @var{kons} across all elements of @var{lst1},
@var{lst2}, @dots{}. Produce the result of
@@ -398,7 +398,7 @@ if @var{enm} are the elements of the lists @var{lst1}, @var{lst2},
@dots{}.
@end deffn
-@deffn procedure fold-right kons knil lst1 lst2 @dots{}
+@deffn {Scheme Procedure} fold-right kons knil lst1 lst2 @dots{}
Similar to @code{fold}, but applies @var{kons} in right-to-left order
to the list elements, that is:
@@ -406,27 +406,27 @@ to the list elements, that is:
@var{e22} @dots{} (@var{kons} @var{en1} @var{en2} @var{knil})))},
@end deffn
-@deffn procedure pair-fold kons knil lst1 lst2 @dots{}
+@deffn {Scheme Procedure} pair-fold kons knil lst1 lst2 @dots{}
Like @code{fold}, but apply @var{kons} to the pairs of the list
instead of the list elements.
@end deffn
-@deffn procedure pair-fold-right kons knil lst1 lst2 @dots{}
+@deffn {Scheme Procedure} pair-fold-right kons knil lst1 lst2 @dots{}
Like @code{fold-right}, but apply @var{kons} to the pairs of the list
instead of the list elements.
@end deffn
-@deffn procedure reduce f ridentity lst
+@deffn {Scheme Procedure} reduce f ridentity lst
@code{reduce} is a variant of @code{reduce}. If @var{lst} is
@code{()}, @var{ridentity} is returned. Otherwise, @code{(fold (car
@var{lst}) (cdr @var{lst}))} is returned.
@end deffn
-@deffn procedure reduce-right f ridentity lst
+@deffn {Scheme Procedure} reduce-right f ridentity lst
This is the @code{fold-right} variant of @var{reduce}.
@end deffn
-@deffn procedure unfold p f g seed [tail-gen]
+@deffn {Scheme Procedure} unfold p f g seed [tail-gen]
@code{unfold} is defined as follows:
@lisp
@@ -458,7 +458,7 @@ elements by @var{f}. These elements are put into a list in
left-to-right order, and @var{p} tells when to stop unfolding.
@end deffn
-@deffn procedure unfold-right p f g seed [tail]
+@deffn {Scheme Procedure} unfold-right p f g seed [tail]
Construct a list with the following loop.
@lisp
@@ -487,7 +487,7 @@ Creates the tail of the list; defaults to @code{(lambda (x) '())}.
@end deffn
-@deffn procedure map f lst1 lst2 @dots{}
+@deffn {Scheme Procedure} map f lst1 lst2 @dots{}
Map the procedure over the list(s) @var{lst1}, @var{lst2}, @dots{} and
return a list containing the results of the procedure applications.
This procedure is extended with respect to R5RS, because the argument
@@ -496,7 +496,7 @@ length as the shortest argument lists. The order in which @var{f}
will be applied to the list element(s) is not specified.
@end deffn
-@deffn procedure for-each f lst1 lst2 @dots{}
+@deffn {Scheme Procedure} for-each f lst1 lst2 @dots{}
Apply the procedure @var{f} to each pair of corresponding elements of
the list(s) @var{lst1}, @var{lst2}, @dots{}. The return value is not
specified. This procedure is extended with respect to R5RS, because
@@ -506,8 +506,8 @@ be applied to tge list elements in left-to-right order.
@end deffn
-@deffn procedure append-map f lst1 lst2 @dots{}
-@deffnx procedure append-map! f lst1 lst2 @dots{}
+@deffn {Scheme Procedure} append-map f lst1 lst2 @dots{}
+@deffnx {Scheme Procedure} append-map! f lst1 lst2 @dots{}
Equivalent to
@lisp
@@ -530,7 +530,7 @@ The dynamic order in which the various applications of @var{f} are
made is not specified.
@end deffn
-@deffn procedure map! f lst1 lst2 @dots{}
+@deffn {Scheme Procedure} map! f lst1 lst2 @dots{}
Linear-update variant of @code{map} -- @code{map!} is allowed, but not
required, to alter the cons cells of @var{lst1} to construct the
result list.
@@ -540,13 +540,13 @@ made is not specified. In the n-ary case, @var{lst2}, @var{lst3},
@dots{} must have at least as many elements as @var{lst1}.
@end deffn
-@deffn procedure pair-for-each f lst1 lst2 @dots{}
+@deffn {Scheme Procedure} pair-for-each f lst1 lst2 @dots{}
Like @code{for-each}, but applies the procedure @var{f} to the pairs
from which the argument lists are constructed, instead of the list
elements. The return value is not specified.
@end deffn
-@deffn procedure filter-map f lst1 lst2 @dots{}
+@deffn {Scheme Procedure} filter-map f lst1 lst2 @dots{}
Like @code{map}, but only results from the applications of @var{f}
which are true are saved in the result list.
@end deffn
@@ -562,8 +562,8 @@ specific condition. Partitioning a list means to make two groups of
list elements, one which contains the elements satisfying a condition,
and the other for the elements which don't.
-@deffn procedure filter pred lst
-@deffnx procedure filter! pred lst
+@deffn {Scheme Procedure} filter pred lst
+@deffnx {Scheme Procedure} filter! pred lst
Return a list containing all elements from @var{lst} which satisfy the
predicate @var{pred}. The elements in the result list have the same
order as in @var{lst}. The order in which @var{pred} is applied to
@@ -572,8 +572,8 @@ the list elements is not specified.
@code{filter!} is allowed, but not required to modify the structure of
@end deffn
-@deffn procedure partition pred lst
-@deffnx procedure partition! pred lst
+@deffn {Scheme Procedure} partition pred lst
+@deffnx {Scheme Procedure} partition! pred lst
Return two lists, one containing all elements from @var{lst} which
satisfy the predicate @var{pred}, and one list containing the elements
which do not satisfy the predicated. The elements in the result lists
@@ -584,8 +584,8 @@ applied to the list elements is not specified.
the input list.
@end deffn
-@deffn procedure remove pred lst
-@deffnx procedure remove! pred lst
+@deffn {Scheme Procedure} remove pred lst
+@deffnx {Scheme Procedure} remove! pred lst
Return a list containing all elements from @var{lst} which do not
satisfy the predicate @var{pred}. The elements in the result list
have the same order as in @var{lst}. The order in which @var{pred} is
@@ -605,18 +605,18 @@ The procedures for searching elements in lists either accept a
predicate or a comparison object for determining which elements are to
be searched.
-@deffn procedure find pred lst
+@deffn {Scheme Procedure} find pred lst
Return the first element of @var{lst} which satisfies the predicate
@var{pred} and @code{#f} if no such element is found.
@end deffn
-@deffn procedure find-tail pred lst
+@deffn {Scheme Procedure} find-tail pred lst
Return the first pair of @var{lst} whose @sc{car} satisfies the
predicate @var{pred} and @code{#f} if no such element is found.
@end deffn
-@deffn procedure take-while pred lst
-@deffnx procedure take-while! pred lst
+@deffn {Scheme Procedure} take-while pred lst
+@deffnx {Scheme Procedure} take-while! pred lst
Return the longest initial prefix of @var{lst} whose elements all
satisfy the predicate @var{pred}.
@@ -624,15 +624,15 @@ satisfy the predicate @var{pred}.
list while producing the result.
@end deffn
-@deffn procedure drop-while pred lst
+@deffn {Scheme Procedure} drop-while pred lst
Drop the longest initial prefix of @var{lst} whose elements all
satisfy the predicate @var{pred}.
@end deffn
-@deffn procedure span pred lst
-@deffnx procedure span! pred lst
-@deffnx procedure break pred lst
-@deffnx procedure break! pred lst
+@deffn {Scheme Procedure} span pred lst
+@deffnx {Scheme Procedure} span! pred lst
+@deffnx {Scheme Procedure} break pred lst
+@deffnx {Scheme Procedure} break! pred lst
@code{span} splits the list @var{lst} into the longest initial prefix
whose elements all satisfy the predicate @var{pred}, and the remaining
tail. @code{break} inverts the sense of the predicate.
@@ -642,25 +642,25 @@ the structure of the input list @var{lst} in order to produce the
result.
@end deffn
-@deffn procedure any pred lst1 lst2 @dots{}
+@deffn {Scheme Procedure} any pred lst1 lst2 @dots{}
Apply @var{pred} across the lists and return a true value if the
predicate returns true for any of the list elements(s); return
@code{#f} otherwise. The true value returned is always the result of
the first succesful application of @var{pred}.
@end deffn
-@deffn procedure every pred lst1 lst2 @dots{}
+@deffn {Scheme Procedure} every pred lst1 lst2 @dots{}
Apply @var{pred} across the lists and return a true value if the
predicate returns true for every of the list elements(s); return
@code{#f} otherwise. The true value returned is always the result of
the final succesful application of @var{pred}.
@end deffn
-@deffn procedure list-index pred lst1 lst2 @dots{}
+@deffn {Scheme Procedure} list-index pred lst1 lst2 @dots{}
Return the index of the leftmost element that satisfies @var{pred}.
@end deffn
-@deffn procedure member x lst [=]
+@deffn {Scheme Procedure} member x lst [=]
Return the first sublist of @var{lst} whose @sc{car} is equal to
@var{x}. If @var{x} does no appear in @var{lst}, return @code{#f}.
Equality is determined by the equality predicate @var{=}, or
@@ -677,8 +677,8 @@ The procedures for deleting elements from a list either accept a
predicate or a comparison object for determining which elements are to
be removed.
-@deffn procedure delete x lst [=]
-@deffnx procedure delete! x lst [=]
+@deffn {Scheme Procedure} delete x lst [=]
+@deffnx {Scheme Procedure} delete! x lst [=]
Return a list containing all elements from @var{lst}, but without the
elements equal to @var{x}. Equality is determined by the equality
predicate @var{=}, which defaults to @code{equal?} if not given.
@@ -687,8 +687,8 @@ predicate @var{=}, which defaults to @code{equal?} if not given.
the argument list in order to produce the result.
@end deffn
-@deffn procedure delete-duplicates lst [=]
-@deffnx procedure delete-duplicates! lst [=]
+@deffn {Scheme Procedure} delete-duplicates lst [=]
+@deffnx {Scheme Procedure} delete-duplicates! lst [=]
Return a list containing all elements from @var{lst}, but without
duplicate elements. Equality of elements is determined by the
equality predicate @var{=}, which defaults to @code{equal?} if not
@@ -708,13 +708,13 @@ Association lists are described in detail in section @ref{Association
Lists}. The present section only documents the additional procedures
for dealing with association lists defined by SRFI-1.
-@deffn procedure assoc key alist [=]
+@deffn {Scheme Procedure} assoc key alist [=]
Return the pair from @var{alist} which matches @var{key}. Equality is
determined by @var{=}, which defaults to @code{equal?} if not given.
@var{alist} must be an association lists---a list of pairs.
@end deffn
-@deffn procedure alist-cons key datum alist
+@deffn {Scheme Procedure} alist-cons key datum alist
Equivalent to
@lisp
@@ -725,13 +725,13 @@ This procedure is used to coons a new pair onto an existing
association list.
@end deffn
-@deffn procedure alist-copy alist
+@deffn {Scheme Procedure} alist-copy alist
Return a newly allocated copy of @var{alist}, that means that the
spine of the list as well as the pairs are copied.
@end deffn
-@deffn procedure alist-delete key alist [=]
-@deffnx procedure alist-delete! key alist [=]
+@deffn {Scheme Procedure} alist-delete key alist [=]
+@deffnx {Scheme Procedure} alist-delete! key alist [=]
Return a list containing the pairs of @var{alist}, but without the
pairs whose @sc{cars} are equal to @var{key}. Equality is determined
by @var{=}, which defaults to @code{equal?} if not given.
@@ -759,43 +759,43 @@ All these procedures accept an equality predicate as the first
argument. This predicate is used for testing the objects in the list
sets for sameness.
-@deffn procedure lset<= = list1 @dots{}
+@deffn {Scheme Procedure} lset<= = list1 @dots{}
Return @code{#t} if every @var{listi} is a subset of @var{listi+1},
otherwise return @code{#f}. Returns @code{#t} if called with less
than two arguments. @var{=} is used for testing element equality.
@end deffn
-@deffn procedure lset= = list1 list2 @dots{}
+@deffn {Scheme Procedure} lset= = list1 list2 @dots{}
Return @code{#t} if all argument lists are equal. @var{=} is used for
testing element equality.
@end deffn
-@deffn procedure lset-adjoin = list elt1 @dots{}
-@deffnx procedure lset-adjoin! = list elt1 @dots{}
+@deffn {Scheme Procedure} lset-adjoin = list elt1 @dots{}
+@deffnx {Scheme Procedure} lset-adjoin! = list elt1 @dots{}
Add all @var{elts} to the list @var{list}, suppressing duplicates and
return the resulting list. @code{lset-adjoin!} is allowed, but not
required to modify its first argument. @var{=} is used for testing
element equality.
@end deffn
-@deffn procedure lset-union = list1 @dots{}
-@deffnx procedure lset-union! = list1 @dots{}
+@deffn {Scheme Procedure} lset-union = list1 @dots{}
+@deffnx {Scheme Procedure} lset-union! = list1 @dots{}
Return the union of all argument list sets. The union is the set of
all elements which appear in any of the argument sets.
@code{lset-union!} is allowed, but not required to modify its first
argument. @var{=} is used for testing element equality.
@end deffn
-@deffn procedure lset-intersection = list1 list2 @dots{}
-@deffnx procedure lset-intersection! = list1 list2 @dots{}
+@deffn {Scheme Procedure} lset-intersection = list1 list2 @dots{}
+@deffnx {Scheme Procedure} lset-intersection! = list1 list2 @dots{}
Return the intersection of all argument list sets. The intersection
is the set containing all elements which appear in all argument sets.
@code{lset-intersection!} is allowed, but not required to modify its
first argument. @var{=} is used for testing element equality.
@end deffn
-@deffn procedure lset-difference = list1 list2 @dots{}
-@deffnx procedure lset-difference! = list1 list2 @dots{}
+@deffn {Scheme Procedure} lset-difference = list1 list2 @dots{}
+@deffnx {Scheme Procedure} lset-difference! = list1 list2 @dots{}
Return the difference of all argument list sets. The difference is
the the set containing all elements of the first list which do not
appear in the other lists. @code{lset-difference!} is allowed, but
@@ -803,8 +803,8 @@ not required to modify its first argument. @var{=} is used for testing
element equality.
@end deffn
-@deffn procedure lset-xor = list1 @dots{}
-@deffnx procedure lset-xor! = list1 @dots{}
+@deffn {Scheme Procedure} lset-xor = list1 @dots{}
+@deffnx {Scheme Procedure} lset-xor! = list1 @dots{}
Return the set containing all elements which appear in the first
argument list set, but not in the second; or, more generally: which
appear in an odd number of sets. @code{lset-xor!} is allowed, but
@@ -812,8 +812,8 @@ not required to modify its first argument. @var{=} is used for testing
element equality.
@end deffn
-@deffn procedure lset-diff+intersection = list1 list2 @dots{}
-@deffnx procedure lset-diff+intersection! = list1 list2 @dots{}
+@deffn {Scheme Procedure} lset-diff+intersection = list1 list2 @dots{}
+@deffnx {Scheme Procedure} lset-diff+intersection! = list1 list2 @dots{}
Return two values, the difference and the intersection of the argument
list sets. This works like a combination of @code{lset-difference} and
@code{lset-intersection}, but is more efficient.
@@ -939,42 +939,42 @@ For example, you can use the procedures @code{u8vector?},
@code{make-s8vector}, @code{u16vector}, @code{u32vector-length},
@code{s64vector-ref}, @code{f32vector-set!} or @code{f64vector->list}.
-@deffn primitive TAGvector? obj
+@deffn {Scheme Procedure} TAGvector? obj
Return @code{#t} if @var{obj} is a homogeneous numeric vector of type
@code{TAG}.
@end deffn
-@deffn primitive make-TAGvector n [value]
+@deffn {Scheme Procedure} make-TAGvector n [value]
Create a newly allocated homogeneous numeric vector of type
@code{TAG}, which can hold @var{n} elements. If @var{value} is given,
the vector is initialized with the value, otherwise, the contents of
the returned vector is not specified.
@end deffn
-@deffn primitive TAGvector value1 @dots{}
+@deffn {Scheme Procedure} TAGvector value1 @dots{}
Create a newly allocated homogeneous numeric vector of type
@code{TAG}. The returned vector is as long as the number of arguments
given, and is initialized with the argument values.
@end deffn
-@deffn primitive TAGvector-length TAGvec
+@deffn {Scheme Procedure} TAGvector-length TAGvec
Return the number of elements in @var{TAGvec}.
@end deffn
-@deffn primitive TAGvector-ref TAGvec i
+@deffn {Scheme Procedure} TAGvector-ref TAGvec i
Return the element at index @var{i} in @var{TAGvec}.
@end deffn
-@deffn primitive TAGvector-ref TAGvec i value
+@deffn {Scheme Procedure} TAGvector-ref TAGvec i value
Set the element at index @var{i} in @var{TAGvec} to @var{value}. The
return value is not specified.
@end deffn
-@deffn primitive TAGvector->list TAGvec
+@deffn {Scheme Procedure} TAGvector->list TAGvec
Return a newly allocated list holding all elements of @var{TAGvec}.
@end deffn
-@deffn primitive list->TAGvector lst
+@deffn {Scheme Procedure} list->TAGvector lst
Return a newly allocated homogeneous numeric vector of type @code{TAG},
initialized with the elements of the list @var{lst}.
@end deffn
@@ -1079,7 +1079,7 @@ Example:
Please note the quote before the @code{#,(file ...)} expression. This
is necessary because ports are not self-evaluating in Guile.
-@deffn procedure define-reader-ctor symbol proc
+@deffn {Scheme Procedure} define-reader-ctor symbol proc
Define @var{proc} as the reader constructor for hash-comma forms with a
tag @var{symbol}. @var{proc} will be applied to the datum(s) following
the tag in the hash-comma expression after the complete form has been
@@ -1196,7 +1196,7 @@ In addition to the primitives @code{string?} and @code{string-null?},
which are already in the Guile core, the string predicates
@code{string-any} and @code{string-every} are defined by SRFI-13.
-@deffn primitive string-any pred s [start end]
+@deffn {Scheme Procedure} string-any pred s [start end]
Check if the predicate @var{pred} is true for any character in
the string @var{s}, proceeding from left (index @var{start}) to
right (index @var{end}). If @code{string-any} returns true,
@@ -1204,7 +1204,7 @@ the returned true value is the one produced by the first
successful application of @var{pred}.
@end deffn
-@deffn primitive string-every pred s [start end]
+@deffn {Scheme Procedure} string-every pred s [start end]
Check if the predicate @var{pred} is true for every character
in the string @var{s}, proceeding from left (index @var{start})
to right (index @var{end}). If @code{string-every} returns
@@ -1222,7 +1222,7 @@ SRFI-13 defines several procedures for constructing new strings. In
addition to @code{make-string} and @code{string} (available in the Guile
core library), the procedure @code{string-tabulate} does exist.
-@deffn primitive string-tabulate proc len
+@deffn {Scheme Procedure} string-tabulate proc len
@var{proc} is an integer->char procedure. Construct a string
of size @var{len} by applying @var{proc} to each index to
produce the corresponding string element. The order in which
@@ -1241,11 +1241,11 @@ The Guile core already contains the procedure @code{list->string} for
converting a list of characters into a string (@pxref{List/String
Conversion}).
-@deffn primitive string->list str [start end]
+@deffn {Scheme Procedure} string->list str [start end]
Convert the string @var{str} into a list of characters.
@end deffn
-@deffn primitive reverse-list->string chrs
+@deffn {Scheme Procedure} reverse-list->string chrs
An efficient implementation of @code{(compose string->list
reverse)}:
@@ -1254,7 +1254,7 @@ reverse)}:
@end smalllisp
@end deffn
-@deffn primitive string-join ls [delimiter grammar]
+@deffn {Scheme Procedure} string-join ls [delimiter grammar]
Append the string in the string list @var{ls}, using the string
@var{delim} as a delimiter between the elements of @var{ls}.
@var{grammar} is a symbol which specifies how the delimiter is
@@ -1294,18 +1294,18 @@ Additional selector procedures are documented in the Strings section
@code{string-copy} is also available in core Guile, but this version
accepts additional start/end indices.
-@deffn primitive string-copy str [start end]
+@deffn {Scheme Procedure} string-copy str [start end]
Return a freshly allocated copy of the string @var{str}. If
given, @var{start} and @var{end} delimit the portion of
@var{str} which is copied.
@end deffn
-@deffn primitive substring/shared str start [end]
+@deffn {Scheme Procedure} substring/shared str start [end]
Like @code{substring}, but the result may share memory with the
argument @var{str}.
@end deffn
-@deffn primitive string-copy! target tstart s [start end]
+@deffn {Scheme Procedure} string-copy! target tstart s [start end]
Copy the sequence of characters from index range [@var{start},
@var{end}) in string @var{s} to string @var{target}, beginning
at index @var{tstart}. The characters are copied left-to-right
@@ -1315,27 +1315,27 @@ error if the copy operation runs off the end of the target
string.
@end deffn
-@deffn primitive string-take s n
-@deffnx primitive string-take-right s n
+@deffn {Scheme Procedure} string-take s n
+@deffnx {Scheme Procedure} string-take-right s n
Return the @var{n} first/last characters of @var{s}.
@end deffn
-@deffn primitive string-drop s n
-@deffnx primitive string-drop-right s n
+@deffn {Scheme Procedure} string-drop s n
+@deffnx {Scheme Procedure} string-drop-right s n
Return all but the first/last @var{n} characters of @var{s}.
@end deffn
-@deffn primitive string-pad s len [chr start end]
-@deffnx primitive string-pad-right s len [chr start end]
+@deffn {Scheme Procedure} string-pad s len [chr start end]
+@deffnx {Scheme Procedure} string-pad-right s len [chr start end]
Take that characters from @var{start} to @var{end} from the
string @var{s} and return a new string, right(left)-padded by the
character @var{chr} to length @var{len}. If the resulting
string is longer than @var{len}, it is truncated on the right (left).
@end deffn
-@deffn primitive string-trim s [char_pred start end]
-@deffnx primitive string-trim-right s [char_pred start end]
-@deffnx primitive string-trim-both s [char_pred start end]
+@deffn {Scheme Procedure} string-trim s [char_pred start end]
+@deffnx {Scheme Procedure} string-trim-right s [char_pred start end]
+@deffnx {Scheme Procedure} string-trim-both s [char_pred start end]
Trim @var{s} by skipping over all characters on the left/right/both
sides of the string that satisfy the parameter @var{char_pred}:
@@ -1368,7 +1368,7 @@ of the same name in the Guile core. The second modification procedure
@code{string-set!} is documented in the Strings section (@pxref{String
Modification}).
-@deffn primitive string-fill! str chr [start end]
+@deffn {Scheme Procedure} string-fill! str chr [start end]
Stores @var{chr} in every element of the given @var{str} and
returns an unspecified value.
@end deffn
@@ -1387,8 +1387,8 @@ index in the case of a true return value.
@code{string-hash} and @code{string-hash-ci} are for calculating hash
values for strings, useful for implementing fast lookup mechanisms.
-@deffn primitive string-compare s1 s2 proc_lt proc_eq proc_gt [start1 end1 start2 end2]
-@deffnx primitive string-compare-ci 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]
+@deffnx {Scheme Procedure} string-compare-ci s1 s2 proc_lt proc_eq proc_gt [start1 end1 start2 end2]
Apply @var{proc_lt}, @var{proc_eq}, @var{proc_gt} to the
mismatch index, depending upon whether @var{s1} is less than,
equal to, or greater than @var{s2}. The mismatch index is the
@@ -1398,30 +1398,30 @@ largest index @var{i} such that for every 0 <= @var{j} <
character comparison is done case-insensitively.
@end deffn
-@deffn primitive string= s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string<> s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string< s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string> s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string<= s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string>= s1 s2 [start1 end1 start2 end2]
+@deffn {Scheme Procedure} string= s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string<> s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string< s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string> s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string<= s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string>= s1 s2 [start1 end1 start2 end2]
Compare @var{s1} and @var{s2} and return @code{#f} if the predicate
fails. Otherwise, the mismatch index is returned (or @var{end1} in the
case of @code{string=}.
@end deffn
-@deffn primitive string-ci= s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-ci<> s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-ci< s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-ci> s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-ci<= s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-ci>= s1 s2 [start1 end1 start2 end2]
+@deffn {Scheme Procedure} string-ci= s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-ci<> s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-ci< s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-ci> s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-ci<= s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-ci>= s1 s2 [start1 end1 start2 end2]
Compare @var{s1} and @var{s2} and return @code{#f} if the predicate
fails. Otherwise, the mismatch index is returned (or @var{end1} in the
case of @code{string=}. These are the case-insensitive variants.
@end deffn
-@deffn primitive string-hash s [bound start end]
-@deffnx primitive string-hash-ci s [bound start end]
+@deffn {Scheme Procedure} string-hash s [bound start end]
+@deffnx {Scheme Procedure} string-hash-ci s [bound start end]
Return a hash value of the string @var{s} in the range 0 @dots{}
@var{bound} - 1. @code{string-hash-ci} is the case-insensitive variant.
@end deffn
@@ -1436,19 +1436,19 @@ Using these procedures you can determine whether a given string is a
prefix or suffix of another string or how long a common prefix/suffix
is.
-@deffn primitive string-prefix-length s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-prefix-length-ci s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-suffix-length s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-suffix-length-ci s1 s2 [start1 end1 start2 end2]
+@deffn {Scheme Procedure} string-prefix-length s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-prefix-length-ci s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-suffix-length s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-suffix-length-ci s1 s2 [start1 end1 start2 end2]
Return the length of the longest common prefix/suffix of the two
strings. @code{string-prefix-length-ci} and
@code{string-suffix-length-ci} are the case-insensitive variants.
@end deffn
-@deffn primitive string-prefix? s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-prefix-ci? s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-suffix? s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-suffix-ci? s1 s2 [start1 end1 start2 end2]
+@deffn {Scheme Procedure} string-prefix? s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-prefix-ci? s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-suffix? s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-suffix-ci? s1 s2 [start1 end1 start2 end2]
Is @var{s1} a prefix/suffix of @var{s2}. @code{string-prefix-ci?} and
@code{string-suffix-ci?} are the case-insensitive variants.
@end deffn
@@ -1462,8 +1462,8 @@ Is @var{s1} a prefix/suffix of @var{s2}. @code{string-prefix-ci?} and
Use these procedures to find out whether a string contains a given
character or a given substring, or a character from a set of characters.
-@deffn primitive string-index s char_pred [start end]
-@deffnx primitive string-index-right s char_pred [start end]
+@deffn {Scheme Procedure} string-index s char_pred [start end]
+@deffnx {Scheme Procedure} string-index-right s char_pred [start end]
Search through the string @var{s} from left to right (right to left),
returning the index of the first (last) occurence of a character which
@@ -1480,8 +1480,8 @@ is in the set @var{char_pred}, if it is a character set.
@end itemize
@end deffn
-@deffn primitive string-skip s char_pred [start end]
-@deffnx primitive string-skip-right s char_pred [start end]
+@deffn {Scheme Procedure} string-skip s char_pred [start end]
+@deffnx {Scheme Procedure} string-skip-right s char_pred [start end]
Search through the string @var{s} from left to right (right to left),
returning the index of the first (last) occurence of a character which
@@ -1498,7 +1498,7 @@ is not in the set if @var{char_pred} is a character set.
@end itemize
@end deffn
-@deffn primitive string-count s char_pred [start end]
+@deffn {Scheme Procedure} string-count s char_pred [start end]
Return the count of the number of characters in the string
@var{s} which
@@ -1514,8 +1514,8 @@ is in the set @var{char_pred}, if it is a character set.
@end itemize
@end deffn
-@deffn primitive string-contains s1 s2 [start1 end1 start2 end2]
-@deffnx primitive string-contains-ci s1 s2 [start1 end1 start2 end2]
+@deffn {Scheme Procedure} string-contains s1 s2 [start1 end1 start2 end2]
+@deffnx {Scheme Procedure} string-contains-ci s1 s2 [start1 end1 start2 end2]
Does string @var{s1} contain string @var{s2}? Return the index
in @var{s1} where @var{s2} occurs as a substring, or false.
The optional start/end indices restrict the operation to the
@@ -1534,20 +1534,20 @@ These procedures convert the alphabetic case of strings. They are
similar to the procedures in the Guile core, but are extended to handle
optional start/end indices.
-@deffn primitive string-upcase s [start end]
-@deffnx primitive string-upcase! s [start end]
+@deffn {Scheme Procedure} string-upcase s [start end]
+@deffnx {Scheme Procedure} string-upcase! s [start end]
Upcase every character in @var{s}. @code{string-upcase!} is the
side-effecting variant.
@end deffn
-@deffn primitive string-downcase s [start end]
-@deffnx primitive string-downcase! s [start end]
+@deffn {Scheme Procedure} string-downcase s [start end]
+@deffnx {Scheme Procedure} string-downcase! s [start end]
Downcase every character in @var{s}. @code{string-downcase!} is the
side-effecting variant.
@end deffn
-@deffn primitive string-titlecase s [start end]
-@deffnx primitive string-titlecase! s [start end]
+@deffn {Scheme Procedure} string-titlecase s [start end]
+@deffnx {Scheme Procedure} string-titlecase! s [start end]
Upcase every first character in every word in @var{s}, downcase the
other characters. @code{string-titlecase!} is the side-effecting
variant.
@@ -1562,8 +1562,8 @@ variant.
One appending procedure, @code{string-append} is the same in R5RS and in
SRFI-13, so it is not redefined.
-@deffn primitive string-reverse str [start end]
-@deffnx primitive string-reverse! str [start end]
+@deffn {Scheme Procedure} string-reverse str [start end]
+@deffnx {Scheme Procedure} string-reverse! str [start end]
Reverse the string @var{str}. The optional arguments
@var{start} and @var{end} delimit the region of @var{str} to
operate on.
@@ -1572,23 +1572,23 @@ operate on.
unspecified value.
@end deffn
-@deffn primitive string-append/shared ls @dots{}
+@deffn {Scheme Procedure} string-append/shared ls @dots{}
Like @code{string-append}, but the result may share memory
with the argument strings.
@end deffn
-@deffn primitive string-concatenate ls
+@deffn {Scheme Procedure} string-concatenate ls
Append the elements of @var{ls} (which must be strings)
together into a single string. Guaranteed to return a freshly
allocated string.
@end deffn
-@deffn primitive string-concatenate/shared ls
+@deffn {Scheme Procedure} string-concatenate/shared ls
Like @code{string-concatenate}, but the result may share memory
with the strings in the list @var{ls}.
@end deffn
-@deffn primitive string-concatenate-reverse ls final_string end
+@deffn {Scheme Procedure} string-concatenate-reverse ls final_string end
Without optional arguments, this procedure is equivalent to
@smalllisp
@@ -1604,7 +1604,7 @@ is given, only the characters of @var{final_string} up to index
Guaranteed to return a freshly allocated string.
@end deffn
-@deffn primitive string-concatenate-reverse/shared ls final_string end
+@deffn {Scheme Procedure} string-concatenate-reverse/shared ls final_string end
Like @code{string-concatenate-reverse}, but the result may
share memory with the the strings in the @var{ls} arguments.
@end deffn
@@ -1619,29 +1619,29 @@ share memory with the the strings in the @var{ls} arguments.
the characters a string is composed of. The fold and unfold procedures
are list iterators and constructors.
-@deffn primitive string-map proc s [start end]
+@deffn {Scheme Procedure} string-map proc s [start end]
@var{proc} is a char->char procedure, it is mapped over
@var{s}. The order in which the procedure is applied to the
string elements is not specified.
@end deffn
-@deffn primitive string-map! proc s [start end]
+@deffn {Scheme Procedure} string-map! proc s [start end]
@var{proc} is a char->char procedure, it is mapped over
@var{s}. The order in which the procedure is applied to the
string elements is not specified. The string @var{s} is
modified in-place, the return value is not specified.
@end deffn
-@deffn primitive string-fold kons knil s [start end]
-@deffnx primitive string-fold-right kons knil s [start end]
+@deffn {Scheme Procedure} string-fold kons knil s [start end]
+@deffnx {Scheme Procedure} string-fold-right kons knil s [start end]
Fold @var{kons} over the characters of @var{s}, with @var{knil} as the
terminating element, from left to right (or right to left, for
@code{string-fold-right}). @var{kons} must expect two arguments: The
actual character and the last result of @var{kons}' application.
@end deffn
-@deffn primitive string-unfold p f g seed [base make_final]
-@deffnx primitive string-unfold-right p f g seed [base make_final]
+@deffn {Scheme Procedure} string-unfold p f g seed [base make_final]
+@deffnx {Scheme Procedure} string-unfold-right p f g seed [base make_final]
These are the fundamental string constructors.
@itemize @bullet
@item @var{g} is used to generate a series of @emph{seed}
@@ -1662,7 +1662,7 @@ value (on which @var{p} returns true) to produce the final/rightmost
@end itemize
@end deffn
-@deffn primitive string-for-each proc s [start end]
+@deffn {Scheme Procedure} string-for-each proc s [start end]
@var{proc} is mapped over @var{s} in left-to-right order. The
return value is not specified.
@end deffn
@@ -1684,7 +1684,7 @@ consider this code fragment, which replicates the input string
"foofoo"
@end lisp
-@deffn primitive xsubstring s from [to start end]
+@deffn {Scheme Procedure} xsubstring s from [to start end]
This is the @emph{extended substring} procedure that implements
replicated copying of a substring of some string.
@@ -1697,7 +1697,7 @@ beginning at index @var{from}, and ending at @var{to}, which
defaults to @var{from} + (@var{end} - @var{start}).
@end deffn
-@deffn primitive string-xcopy! target tstart s sfrom [sto start end]
+@deffn {Scheme Procedure} string-xcopy! target tstart s sfrom [sto start end]
Exactly the same as @code{xsubstring}, but the extracted text
is written into the string @var{target} starting at index
@var{tstart}. The operation is not defined if @code{(eq?
@@ -1715,13 +1715,13 @@ cannot copy a string on top of itself.
another string and @code{string-tokenize} splits a string into a list of
strings, breaking it up at a specified character.
-@deffn primitive string-replace s1 s2 [start1 end1 start2 end2]
+@deffn {Scheme Procedure} string-replace s1 s2 [start1 end1 start2 end2]
Return the string @var{s1}, but with the characters
@var{start1} @dots{} @var{end1} replaced by the characters
@var{start2} @dots{} @var{end2} from @var{s2}.
@end deffn
-@deffn primitive string-tokenize s [token_char start end]
+@deffn {Scheme Procedure} string-tokenize s [token_char start end]
Split the string @var{s} into a list of substrings, where each
substring is a maximal non-empty contiguous sequence of
characters equal to the character @var{token_char}, or
@@ -1739,7 +1739,7 @@ token borders.
@dfn{Filtering} means to remove all characters from a string which do
not match a given criteria, @dfn{deleting} means the opposite.
-@deffn primitive string-filter s char_pred [start end]
+@deffn {Scheme Procedure} string-filter s char_pred [start end]
Filter the string @var{s}, retaining only those characters that
satisfy the @var{char_pred} argument. If the argument is a
procedure, it is applied to each character as a predicate, if
@@ -1747,7 +1747,7 @@ it is a character, it is tested for equality and if it is a
character set, it is tested for membership.
@end deffn
-@deffn primitive string-delete s char_pred [start end]
+@deffn {Scheme Procedure} string-delete s char_pred [start end]
Filter the string @var{s}, retaining only those characters that
do not satisfy the @var{char_pred} argument. If the argument
is a procedure, it is applied to each character as a predicate,
@@ -1823,21 +1823,21 @@ or whether several character sets are equal or subsets of each other.
@code{char-set-hash} can be used for calculating a hash value, maybe for
usage in fast lookup procedures.
-@deffn primitive char-set? obj
+@deffn {Scheme Procedure} char-set? obj
Return @code{#t} if @var{obj} is a character set, @code{#f}
otherwise.
@end deffn
-@deffn primitive char-set= cs1 @dots{}
+@deffn {Scheme Procedure} char-set= cs1 @dots{}
Return @code{#t} if all given character sets are equal.
@end deffn
-@deffn primitive char-set<= cs1 @dots{}
+@deffn {Scheme Procedure} char-set<= cs1 @dots{}
Return @code{#t} if every character set @var{cs}i is a subset
of character set @var{cs}i+1.
@end deffn
-@deffn primitive char-set-hash cs [bound]
+@deffn {Scheme Procedure} char-set-hash cs [bound]
Compute a hash value for the character set @var{cs}. If
@var{bound} is given and not @code{#f}, it restricts the
returned value to the range 0 @dots{} @var{bound - 1}.
@@ -1859,34 +1859,34 @@ element of the set can be checked with @code{end-of-char-set?}.
Additionally, mapping and (un-)folding procedures for character sets are
provided.
-@deffn primitive char-set-cursor cs
+@deffn {Scheme Procedure} char-set-cursor cs
Return a cursor into the character set @var{cs}.
@end deffn
-@deffn primitive char-set-ref cs cursor
+@deffn {Scheme Procedure} char-set-ref cs cursor
Return the character at the current cursor position
@var{cursor} in the character set @var{cs}. It is an error to
pass a cursor for which @code{end-of-char-set?} returns true.
@end deffn
-@deffn primitive char-set-cursor-next cs cursor
+@deffn {Scheme Procedure} char-set-cursor-next cs cursor
Advance the character set cursor @var{cursor} to the next
character in the character set @var{cs}. It is an error if the
cursor given satisfies @code{end-of-char-set?}.
@end deffn
-@deffn primitive end-of-char-set? cursor
+@deffn {Scheme Procedure} end-of-char-set? cursor
Return @code{#t} if @var{cursor} has reached the end of a
character set, @code{#f} otherwise.
@end deffn
-@deffn primitive char-set-fold kons knil cs
+@deffn {Scheme Procedure} char-set-fold kons knil cs
Fold the procedure @var{kons} over the character set @var{cs},
initializing it with @var{knil}.
@end deffn
-@deffn primitive char-set-unfold p f g seed [base_cs]
-@deffnx primitive char-set-unfold! p f g seed base_cs
+@deffn {Scheme Procedure} char-set-unfold p f g seed [base_cs]
+@deffnx {Scheme Procedure} char-set-unfold! p f g seed base_cs
This is a fundamental constructor for character sets.
@itemize @bullet
@item @var{g} is used to generate a series of ``seed'' values
@@ -1902,12 +1902,12 @@ form the result; @var{base_cs} defaults to the empty set.
@code{char-set-unfold!} is the side-effecting variant.
@end deffn
-@deffn primitive char-set-for-each proc cs
+@deffn {Scheme Procedure} char-set-for-each proc cs
Apply @var{proc} to every character in the character set
@var{cs}. The return value is not specified.
@end deffn
-@deffn primitive char-set-map proc cs
+@deffn {Scheme Procedure} char-set-map proc cs
Map the procedure @var{proc} over every character in @var{cs}.
@var{proc} must be a character -> character procedure.
@end deffn
@@ -1920,17 +1920,17 @@ Map the procedure @var{proc} over every character in @var{cs}.
New character sets are produced with these procedures.
-@deffn primitive char-set-copy cs
+@deffn {Scheme Procedure} char-set-copy cs
Return a newly allocated character set containing all
characters in @var{cs}.
@end deffn
-@deffn primitive char-set char1 @dots{}
+@deffn {Scheme Procedure} char-set char1 @dots{}
Return a character set containing all given characters.
@end deffn
-@deffn primitive list->char-set char_list [base_cs]
-@deffnx primitive list->char-set! char_list base_cs
+@deffn {Scheme Procedure} list->char-set char_list [base_cs]
+@deffnx {Scheme Procedure} list->char-set! char_list base_cs
Convert the character list @var{list} to a character set. If
the character set @var{base_cs} is given, the character in this
set are also included in the result.
@@ -1938,8 +1938,8 @@ set are also included in the result.
@code{list->char-set!} is the side-effecting variant.
@end deffn
-@deffn primitive string->char-set s [base_cs]
-@deffnx primitive string->char-set! s base_cs
+@deffn {Scheme Procedure} string->char-set s [base_cs]
+@deffnx {Scheme Procedure} string->char-set! s base_cs
Convert the string @var{str} to a character set. If the
character set @var{base_cs} is given, the characters in this
set are also included in the result.
@@ -1947,8 +1947,8 @@ set are also included in the result.
@code{string->char-set!} is the side-effecting variant.
@end deffn
-@deffn primitive char-set-filter pred cs [base_cs]
-@deffnx primitive char-set-filter! pred cs base_cs
+@deffn {Scheme Procedure} char-set-filter pred cs [base_cs]
+@deffnx {Scheme Procedure} char-set-filter! pred cs base_cs
Return a character set containing every character from @var{cs}
so that it satisfies @var{pred}. If provided, the characters
from @var{base_cs} are added to the result.
@@ -1956,8 +1956,8 @@ from @var{base_cs} are added to the result.
@code{char-set-filter!} is the side-effecting variant.
@end deffn
-@deffn primitive ucs-range->char-set lower upper [error? base_cs]
-@deffnx primitive uce-range->char-set! lower upper error? base_cs
+@deffn {Scheme Procedure} ucs-range->char-set lower upper [error? base_cs]
+@deffnx {Scheme Procedure} uce-range->char-set! lower upper error? base_cs
Return a character set containing all characters whose
character codes lie in the half-open range
[@var{lower},@var{upper}).
@@ -1974,7 +1974,7 @@ given.
@code{ucs-range->char-set!} is the side-effecting variant.
@end deffn
-@deffn procedure ->char-set x
+@deffn {Scheme Procedure} ->char-set x
Coerce @var{x} into a character set. @var{x} may be a string, a
character or a character set.
@end deffn
@@ -1988,37 +1988,37 @@ character or a character set.
Access the elements and other information of a character set with these
procedures.
-@deffn primitive char-set-size cs
+@deffn {Scheme Procedure} char-set-size cs
Return the number of elements in character set @var{cs}.
@end deffn
-@deffn primitive char-set-count pred cs
+@deffn {Scheme Procedure} char-set-count pred cs
Return the number of the elements int the character set
@var{cs} which satisfy the predicate @var{pred}.
@end deffn
-@deffn primitive char-set->list cs
+@deffn {Scheme Procedure} char-set->list cs
Return a list containing the elements of the character set
@var{cs}.
@end deffn
-@deffn primitive char-set->string cs
+@deffn {Scheme Procedure} char-set->string cs
Return a string containing the elements of the character set
@var{cs}. The order in which the characters are placed in the
string is not defined.
@end deffn
-@deffn primitive char-set-contains? cs char
+@deffn {Scheme Procedure} char-set-contains? cs char
Return @code{#t} iff the character @var{ch} is contained in the
character set @var{cs}.
@end deffn
-@deffn primitive char-set-every pred cs
+@deffn {Scheme Procedure} char-set-every pred cs
Return a true value if every character in the character set
@var{cs} satisfies the predicate @var{pred}.
@end deffn
-@deffn primitive char-set-any pred cs
+@deffn {Scheme Procedure} char-set-any pred cs
Return a true value if any character in the character set
@var{cs} satisfies the predicate @var{pred}.
@end deffn
@@ -2034,45 +2034,45 @@ such as union, complement, intersection etc. All of these procedures
provide side-effecting variants, which modify their character set
argument(s).
-@deffn primitive char-set-adjoin cs char1 @dots{}
-@deffnx primitive char-set-adjoin! cs char1 @dots{}
+@deffn {Scheme Procedure} char-set-adjoin cs char1 @dots{}
+@deffnx {Scheme Procedure} char-set-adjoin! cs char1 @dots{}
Add all character arguments to the first argument, which must
be a character set.
@end deffn
-@deffn primitive char-set-delete cs char1 @dots{}
-@deffnx primitive char-set-delete! cs char1 @dots{}
+@deffn {Scheme Procedure} char-set-delete cs char1 @dots{}
+@deffnx {Scheme Procedure} char-set-delete! cs char1 @dots{}
Delete all character arguments from the first argument, which
must be a character set.
@end deffn
-@deffn primitive char-set-complement cs
-@deffnx primitive char-set-complement! cs
+@deffn {Scheme Procedure} char-set-complement cs
+@deffnx {Scheme Procedure} char-set-complement! cs
Return the complement of the character set @var{cs}.
@end deffn
-@deffn primitive char-set-union cs1 @dots{}
-@deffnx primitive char-set-union! cs1 @dots{}
+@deffn {Scheme Procedure} char-set-union cs1 @dots{}
+@deffnx {Scheme Procedure} char-set-union! cs1 @dots{}
Return the union of all argument character sets.
@end deffn
-@deffn primitive char-set-intersection cs1 @dots{}
-@deffnx primitive char-set-intersection! cs1 @dots{}
+@deffn {Scheme Procedure} char-set-intersection cs1 @dots{}
+@deffnx {Scheme Procedure} char-set-intersection! cs1 @dots{}
Return the intersection of all argument character sets.
@end deffn
-@deffn primitive char-set-difference cs1 @dots{}
-@deffnx primitive char-set-difference! cs1 @dots{}
+@deffn {Scheme Procedure} char-set-difference cs1 @dots{}
+@deffnx {Scheme Procedure} char-set-difference! cs1 @dots{}
Return the difference of all argument character sets.
@end deffn
-@deffn primitive char-set-xor cs1 @dots{}
-@deffnx primitive char-set-xor! cs1 @dots{}
+@deffn {Scheme Procedure} char-set-xor cs1 @dots{}
+@deffnx {Scheme Procedure} char-set-xor! cs1 @dots{}
Return the exclusive-or of all argument character sets.
@end deffn
-@deffn primitive char-set-diff+intersection cs1 @dots{}
-@deffnx primitive char-set-diff+intersection! cs1 @dots{}
+@deffn {Scheme Procedure} char-set-diff+intersection cs1 @dots{}
+@deffnx {Scheme Procedure} char-set-diff+intersection! cs1 @dots{}
Return the difference and the intersection of all argument
character sets.
@end deffn