#include "_scm.h"
#include "eq.h"
-#include "scm_validate.h"
+#include "validate.h"
#include "list.h"
#ifdef __STDC__
\f
/* creating lists */
-/* SCM_P won't help us deal with varargs here. */
-#ifdef __STDC__
SCM
scm_listify (SCM elt, ...)
-#else
-SCM
-scm_listify (elt, va_alist)
- SCM elt;
- va_dcl
-#endif
{
va_list foo;
- SCM answer;
- SCM *pos;
+ SCM answer = SCM_EOL;
+ SCM *pos = &answer;
var_start (foo, elt);
- answer = SCM_EOL;
- pos = &answer;
while (elt != SCM_UNDEFINED)
{
*pos = scm_cons (elt, SCM_EOL);
}
-GUILE_PROC(scm_list, "list", 0, 0, 1,
+SCM_DEFINE (scm_list, "list", 0, 0, 1,
(SCM objs),
-"")
+ "Return a list containing OBJS, the arguments to `list'.")
#define FUNC_NAME s_scm_list
{
return objs;
#undef FUNC_NAME
-GUILE_PROC (scm_list_star, "list*", 1, 0, 1,
+SCM_DEFINE (scm_list_star, "list*", 1, 0, 1,
(SCM arg, SCM rest),
-"")
+ "Return an improper list of the arguments.")
#define FUNC_NAME s_scm_list_star
{
- if (SCM_NIMP (rest))
+ if (SCM_NNULLP (rest))
{
SCM prev = arg = scm_cons (arg, rest);
- while (SCM_NIMP (SCM_CDR (rest)))
+ while (SCM_NNULLP (SCM_CDR (rest)))
{
prev = rest;
rest = SCM_CDR (rest);
\f
/* general questions about lists --- null?, list?, length, etc. */
-GUILE_PROC(scm_null_p, "null?", 1, 0, 0,
+SCM_DEFINE (scm_null_p, "null?", 1, 0, 0,
(SCM x),
-"")
+ "Return #t iff X is the empty list, else #f.")
#define FUNC_NAME s_scm_null_p
{
- return SCM_BOOL(SCM_NULLP(x));
+ return SCM_BOOL (SCM_NULLP (x));
}
#undef FUNC_NAME
-GUILE_PROC(scm_list_p, "list?", 1, 0, 0,
+
+SCM_DEFINE (scm_list_p, "list?", 1, 0, 0,
(SCM x),
-"")
+ "Return #t iff X is a proper list, else #f.")
#define FUNC_NAME s_scm_list_p
{
- return SCM_BOOL(scm_ilength(x)>=0);
+ return SCM_BOOL (scm_ilength (x) >= 0);
}
#undef FUNC_NAME
long
scm_ilength(SCM sx)
{
- register long i = 0;
- register SCM tortoise = sx;
- register SCM hare = sx;
+ long i = 0;
+ SCM tortoise = sx;
+ SCM hare = sx;
do {
- if (SCM_IMP(hare)) return SCM_NULLP(hare) ? i : -1;
+ if (SCM_NULLP(hare)) return i;
if (SCM_NCONSP(hare)) return -1;
hare = SCM_CDR(hare);
i++;
- if (SCM_IMP(hare)) return SCM_NULLP(hare) ? i : -1;
+ if (SCM_NULLP(hare)) return i;
if (SCM_NCONSP(hare)) return -1;
hare = SCM_CDR(hare);
i++;
return -1;
}
-GUILE_PROC(scm_length, "length", 1, 0, 0,
+
+SCM_DEFINE (scm_length, "length", 1, 0, 0,
(SCM lst),
-"")
+ "Return the number of elements in list LST.")
#define FUNC_NAME s_scm_length
{
int i;
- SCM_VALIDATE_LIST_COPYLEN(1,lst,i);
+ SCM_VALIDATE_LIST_COPYLEN (1,lst,i);
return SCM_MAKINUM (i);
}
#undef FUNC_NAME
\f
/* appending lists */
-GUILE_PROC (scm_append, "append", 0, 0, 1,
+SCM_DEFINE (scm_append, "append", 0, 0, 1,
(SCM args),
-"A destructive version of @code{append} (@pxref{Pairs and Lists,,,r4rs,
-The Revised^4 Report on Scheme}). The cdr field of each list's final
-pair is changed to point to the head of the next list, so no consing is
-performed. Return a pointer to the mutated list.")
+ "Returns a list consisting of the elements of the first LIST\n"
+ "followed by the elements of the other LISTs.\n"
+ "\n"
+ " (append '(x) '(y)) => (x y)\n"
+ " (append '(a) '(b c d)) => (a b c d)\n"
+ " (append '(a (b)) '((c))) => (a (b) (c))\n"
+ "\n"
+ "The resulting list is always newly allocated, except that it shares\n"
+ "structure with the last LIST argument. The last argument may\n"
+ "actually be any object; an improper list results if the last\n"
+ "argument is not a proper list.\n"
+
+ " (append '(a b) '(c . d)) => (a b c . d)\n"
+ " (append '() 'a) => a\n")
#define FUNC_NAME s_scm_append
{
SCM res = SCM_EOL;
SCM *lloc = &res, arg;
if (SCM_IMP(args)) {
- SCM_VALIDATE_NULL(SCM_ARGn, args);
+ SCM_VALIDATE_NULL (SCM_ARGn, args);
return res;
}
- SCM_VALIDATE_CONS(SCM_ARGn, args);
+ SCM_VALIDATE_CONS (SCM_ARGn, args);
while (1) {
arg = SCM_CAR(args);
args = SCM_CDR(args);
if (SCM_IMP(args)) {
*lloc = arg;
- SCM_VALIDATE_NULL(SCM_ARGn, args);
+ SCM_VALIDATE_NULL (SCM_ARGn, args);
return res;
}
- SCM_VALIDATE_CONS(SCM_ARGn, args);
- for(;SCM_NIMP(arg);arg = SCM_CDR(arg)) {
- SCM_VALIDATE_CONS(SCM_ARGn, arg);
+ SCM_VALIDATE_CONS (SCM_ARGn, args);
+ for (; SCM_CONSP(arg); arg = SCM_CDR(arg)) {
*lloc = scm_cons(SCM_CAR(arg), SCM_EOL);
lloc = SCM_CDRLOC(*lloc);
}
- SCM_VALIDATE_NULL(SCM_ARGn, arg);
+ SCM_VALIDATE_NULL (SCM_ARGn, arg);
}
}
#undef FUNC_NAME
-GUILE_PROC (scm_append_x, "append!", 0, 0, 1,
+SCM_DEFINE (scm_append_x, "append!", 0, 0, 1,
(SCM args),
-"")
+ "A destructive version of @code{append} (@pxref{Pairs and Lists,,,r4rs,\n"
+ "The Revised^4 Report on Scheme}). The cdr field of each list's final\n"
+ "pair is changed to point to the head of the next list, so no consing is\n"
+ "performed. Return a pointer to the mutated list.")
#define FUNC_NAME s_scm_append_x
{
SCM arg;
args = SCM_CDR(args);
if (SCM_NULLP(args)) return arg;
if (SCM_NULLP(arg)) goto tail;
- SCM_VALIDATE_CONS(SCM_ARG1,arg);
+ SCM_VALIDATE_CONS (SCM_ARG1,arg);
SCM_SETCDR (scm_last_pair (arg), scm_append_x (args));
return arg;
}
#undef FUNC_NAME
-GUILE_PROC(scm_last_pair, "last-pair", 1, 0, 0,
- (SCM sx),
-"Return a pointer to the last pair in @var{lst}, signalling an error if
-@var{lst} is circular.")
+SCM_DEFINE (scm_last_pair, "last-pair", 1, 0, 0,
+ (SCM lst),
+ "Return a pointer to the last pair in @var{lst}, signalling an error if\n"
+ "@var{lst} is circular.")
#define FUNC_NAME s_scm_last_pair
{
- register SCM res = sx;
- register SCM x;
+ SCM tortoise = lst;
+ SCM hare = lst;
- if (SCM_NULLP (sx))
+ if (SCM_NULLP (lst))
return SCM_EOL;
- SCM_VALIDATE_CONS(SCM_ARG1,res);
- while (!0) {
- x = SCM_CDR(res);
- if (SCM_IMP(x) || SCM_NCONSP(x)) return res;
- res = x;
- x = SCM_CDR(res);
- if (SCM_IMP(x) || SCM_NCONSP(x)) return res;
- res = x;
- sx = SCM_CDR(sx);
- SCM_ASSERT(x != sx, sx, SCM_ARG1, FUNC_NAME);
+ SCM_VALIDATE_CONS (SCM_ARG1, lst);
+ do {
+ SCM ahead = SCM_CDR(hare);
+ if (SCM_NCONSP(ahead)) return hare;
+ hare = ahead;
+ ahead = SCM_CDR(hare);
+ if (SCM_NCONSP(ahead)) return hare;
+ hare = ahead;
+ tortoise = SCM_CDR(tortoise);
}
+ while (hare != tortoise);
+ SCM_MISC_ERROR ("Circular structure in position 1: ~S", SCM_LIST1 (lst));
}
#undef FUNC_NAME
\f
/* reversing lists */
-GUILE_PROC (scm_reverse, "reverse", 1, 0, 0,
- (SCM ls),
-"A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r4rs,
-The Revised^4 Report on Scheme}). The cdr of each cell in @var{lst} is
-modified to point to the previous list element. Return a pointer to the
-head of the reversed list.
-
-Caveat: because the list is modified in place, the tail of the original
-list now becomes its head, and the head of the original list now becomes
-the tail. Therefore, the @var{lst} symbol to which the head of the
-original list was bound now points to the tail. To ensure that the head
-of the modified list is not lost, it is wise to save the return value of
-@code{reverse!}")
+SCM_DEFINE (scm_reverse, "reverse", 1, 0, 0,
+ (SCM lst),
+ "Return a new list that contains the elements of LST but in reverse order.")
#define FUNC_NAME s_scm_reverse
{
- SCM res = SCM_EOL;
- SCM p = ls, t = ls;
- while (SCM_NIMP (p))
- {
- SCM_VALIDATE_CONS(1,ls);
- res = scm_cons (SCM_CAR (p), res);
- p = SCM_CDR (p);
- if (SCM_IMP (p))
- break;
- SCM_VALIDATE_CONS(1,ls);
- res = scm_cons (SCM_CAR (p), res);
- p = SCM_CDR (p);
- t = SCM_CDR (t);
- if (t == p)
- scm_misc_error (FUNC_NAME, "Circular structure: %S", SCM_LIST1 (ls));
+ SCM result = SCM_EOL;
+ SCM tortoise = lst;
+ SCM hare = lst;
+
+ do {
+ if (SCM_NULLP(hare)) return result;
+ SCM_ASSERT(SCM_CONSP(hare), lst, 1, FUNC_NAME);
+ result = scm_cons (SCM_CAR (hare), result);
+ hare = SCM_CDR (hare);
+ if (SCM_NULLP(hare)) return result;
+ SCM_ASSERT(SCM_CONSP(hare), lst, 1, FUNC_NAME);
+ result = scm_cons (SCM_CAR (hare), result);
+ hare = SCM_CDR (hare);
+ tortoise = SCM_CDR (tortoise);
}
- ls = p;
- SCM_VALIDATE_NULL(1,ls);
- return res;
+ while (hare != tortoise);
+ SCM_MISC_ERROR ("Circular structure in position 1: ~S", SCM_LIST1 (lst));
}
#undef FUNC_NAME
-GUILE_PROC (scm_reverse_x, "reverse!", 1, 1, 0,
- (SCM ls, SCM new_tail),
-"")
+SCM_DEFINE (scm_reverse_x, "reverse!", 1, 1, 0,
+ (SCM lst, SCM new_tail),
+ "A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r4rs,\n"
+ "The Revised^4 Report on Scheme}). The cdr of each cell in @var{lst} is\n"
+ "modified to point to the previous list element. Return a pointer to the\n"
+ "head of the reversed list.\n\n"
+ "Caveat: because the list is modified in place, the tail of the original\n"
+ "list now becomes its head, and the head of the original list now becomes\n"
+ "the tail. Therefore, the @var{lst} symbol to which the head of the\n"
+ "original list was bound now points to the tail. To ensure that the head\n"
+ "of the modified list is not lost, it is wise to save the return value of\n"
+ "@code{reverse!}")
#define FUNC_NAME s_scm_reverse_x
{
- SCM old_tail;
- SCM_ASSERT (scm_ilength (ls) >= 0, ls, SCM_ARG1, FUNC_NAME);
+ SCM_ASSERT (scm_ilength (lst) >= 0, lst, SCM_ARG1, FUNC_NAME);
if (SCM_UNBNDP (new_tail))
new_tail = SCM_EOL;
else
SCM_ASSERT (scm_ilength (new_tail) >= 0, new_tail, SCM_ARG2, FUNC_NAME);
- while (SCM_NIMP (ls))
+ while (SCM_NNULLP (lst))
{
- old_tail = SCM_CDR (ls);
- SCM_SETCDR (ls, new_tail);
- new_tail = ls;
- ls = old_tail;
+ SCM old_tail = SCM_CDR (lst);
+ SCM_SETCDR (lst, new_tail);
+ new_tail = lst;
+ lst = old_tail;
}
return new_tail;
}
\f
/* indexing lists by element number */
-GUILE_PROC(scm_list_ref, "list-ref", 2, 0, 0,
+SCM_DEFINE (scm_list_ref, "list-ref", 2, 0, 0,
(SCM lst, SCM k),
-"")
+ "Return the Kth element from list LST.")
#define FUNC_NAME s_scm_list_ref
{
register long i;
- SCM_VALIDATE_INT_MIN_COPY(2,k,0,i);
+ SCM_VALIDATE_INUM_MIN_COPY (2,k,0,i);
while (i-- > 0) {
SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst);
}
#undef FUNC_NAME
-GUILE_PROC(scm_list_set_x, "list-set!", 3, 0, 0,
+SCM_DEFINE (scm_list_set_x, "list-set!", 3, 0, 0,
(SCM lst, SCM k, SCM val),
-"Set the @var{k}th element of @var{lst} to @var{val}.")
+ "Set the @var{k}th element of @var{lst} to @var{val}.")
#define FUNC_NAME s_scm_list_set_x
{
register long i;
- SCM_VALIDATE_INT_MIN_COPY(2,k,0,i);
+ SCM_VALIDATE_INUM_MIN_COPY (2,k,0,i);
while (i-- > 0) {
SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst);
SCM_REGISTER_PROC(s_list_cdr_ref, "list-cdr-ref", 2, 0, 0, scm_list_tail);
-GUILE_PROC(scm_list_tail, "list-tail", 2, 0, 0,
+SCM_DEFINE (scm_list_tail, "list-tail", 2, 0, 0,
(SCM lst, SCM k),
-"Return the \"tail\" of @var{lst} beginning with its @var{k}th element.
-The first element of the list is considered to be element 0.
-
-@code{list-cdr-ref} and @code{list-tail} are identical. It may help to
-think of @code{list-cdr-ref} as accessing the @var{k}th cdr of the list,
-or returning the results of cdring @var{k} times down @var{lst}.")
+ "Return the \"tail\" of @var{lst} beginning with its @var{k}th element.\n"
+ "The first element of the list is considered to be element 0.\n\n"
+ "@code{list-cdr-ref} and @code{list-tail} are identical. It may help to\n"
+ "think of @code{list-cdr-ref} as accessing the @var{k}th cdr of the list,\n"
+ "or returning the results of cdring @var{k} times down @var{lst}.")
#define FUNC_NAME s_scm_list_tail
{
register long i;
- SCM_VALIDATE_INT_MIN_COPY(2,k,0,i);
+ SCM_VALIDATE_INUM_MIN_COPY (2,k,0,i);
while (i-- > 0) {
- SCM_VALIDATE_CONS(1,lst);
+ SCM_VALIDATE_CONS (1,lst);
lst = SCM_CDR(lst);
}
return lst;
#undef FUNC_NAME
-GUILE_PROC(scm_list_cdr_set_x, "list-cdr-set!", 3, 0, 0,
+SCM_DEFINE (scm_list_cdr_set_x, "list-cdr-set!", 3, 0, 0,
(SCM lst, SCM k, SCM val),
-"Set the @var{k}th cdr of @var{lst} to @var{val}.")
+ "Set the @var{k}th cdr of @var{lst} to @var{val}.")
#define FUNC_NAME s_scm_list_cdr_set_x
{
register long i;
- SCM_VALIDATE_INT_MIN_COPY(2,k,0,i);
+ SCM_VALIDATE_INUM_MIN_COPY (2,k,0,i);
while (i-- > 0) {
SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst);
\f
/* copying lists, perhaps partially */
-GUILE_PROC(scm_list_head, "list-head", 2, 0, 0,
+SCM_DEFINE (scm_list_head, "list-head", 2, 0, 0,
(SCM lst, SCM k),
-"Copy the first @var{k} elements from @var{lst} into a new list, and
-return it.")
+ "Copy the first @var{k} elements from @var{lst} into a new list, and\n"
+ "return it.")
#define FUNC_NAME s_scm_list_head
{
SCM answer;
SCM * pos;
register long i;
- SCM_VALIDATE_INT_MIN_COPY(2,k,0,i);
+ SCM_VALIDATE_INUM_MIN_COPY (2,k,0,i);
answer = SCM_EOL;
pos = &answer;
while (i-- > 0)
{
- SCM_VALIDATE_CONS(1,lst);
+ SCM_VALIDATE_CONS (1,lst);
*pos = scm_cons (SCM_CAR (lst), SCM_EOL);
pos = SCM_CDRLOC (*pos);
lst = SCM_CDR(lst);
#undef FUNC_NAME
-GUILE_PROC (scm_list_copy, "list-copy", 1, 0, 0,
+SCM_DEFINE (scm_list_copy, "list-copy", 1, 0, 0,
(SCM lst),
-"Return a (newly-created) copy of @var{lst}.")
+ "Return a (newly-created) copy of @var{lst}.")
#define FUNC_NAME s_scm_list_copy
{
SCM newlst;
\f
/* membership tests (memq, memv, etc.) */
-GUILE_PROC (scm_sloppy_memq, "sloppy-memq", 2, 0, 0,
+SCM_DEFINE (scm_sloppy_memq, "sloppy-memq", 2, 0, 0,
(SCM x, SCM lst),
-"@deffnx primitive sloppy-memv
-@deffnx primitive sloppy-member
-These procedures behave like @code{memq}, @code{memv} and @code{member}
-(@pxref{Pairs and Lists,,,r4rs, The Revised^4 Report on Scheme}), but do
-not perform any type or error checking. Their use is recommended only
-in writing Guile internals, not for high-level Scheme programs.")
+ "This procedure behaves like @code{memq}, but does no type or error checking.\n"
+ "Its use is recommended only in writing Guile internals,\n"
+ "not for high-level Scheme programs.")
#define FUNC_NAME s_scm_sloppy_memq
{
for(; SCM_CONSP (lst); lst = SCM_CDR(lst))
#undef FUNC_NAME
-GUILE_PROC (scm_sloppy_memv, "sloppy-memv", 2, 0, 0,
+SCM_DEFINE (scm_sloppy_memv, "sloppy-memv", 2, 0, 0,
(SCM x, SCM lst),
-"")
+ "This procedure behaves like @code{memv}, but does no type or error checking.\n"
+ "Its use is recommended only in writing Guile internals,\n"
+ "not for high-level Scheme programs.")
#define FUNC_NAME s_scm_sloppy_memv
{
for(; SCM_CONSP (lst); lst = SCM_CDR(lst))
#undef FUNC_NAME
-GUILE_PROC (scm_sloppy_member, "sloppy-member", 2, 0, 0,
+SCM_DEFINE (scm_sloppy_member, "sloppy-member", 2, 0, 0,
(SCM x, SCM lst),
-"")
+ "This procedure behaves like @code{member}, but does no type or error checking.\n"
+ "Its use is recommended only in writing Guile internals,\n"
+ "not for high-level Scheme programs.")
#define FUNC_NAME s_scm_sloppy_member
{
for(; SCM_CONSP (lst); lst = SCM_CDR(lst))
-GUILE_PROC(scm_memq, "memq", 2, 0, 0,
+SCM_DEFINE (scm_memq, "memq", 2, 0, 0,
(SCM x, SCM lst),
-"")
+ "Return the first sublist of LST whose car is `eq?' to X\n"
+ "where the sublists of LST are the non-empty lists returned\n"
+ "by `(list-tail LST K)' for K less than the length of LST. If\n"
+ "X does not occur in LST, then `#f' (not the empty list) is\n"
+ "returned.")
#define FUNC_NAME s_scm_memq
{
SCM answer;
- SCM_VALIDATE_LIST(2,lst);
+ SCM_VALIDATE_LIST (2,lst);
answer = scm_sloppy_memq (x, lst);
return (answer == SCM_EOL) ? SCM_BOOL_F : answer;
}
-GUILE_PROC(scm_memv, "memv", 2, 0, 0,
+SCM_DEFINE (scm_memv, "memv", 2, 0, 0,
(SCM x, SCM lst),
-"")
+ "Return the first sublist of LST whose car is `eqv?' to X\n"
+ "where the sublists of LST are the non-empty lists returned\n"
+ "by `(list-tail LST K)' for K less than the length of LST. If\n"
+ "X does not occur in LST, then `#f' (not the empty list) is\n"
+ "returned.")
#define FUNC_NAME s_scm_memv
{
SCM answer;
- SCM_VALIDATE_LIST(2,lst);
+ SCM_VALIDATE_LIST (2,lst);
answer = scm_sloppy_memv (x, lst);
return (answer == SCM_EOL) ? SCM_BOOL_F : answer;
}
#undef FUNC_NAME
-GUILE_PROC(scm_member, "member", 2, 0, 0,
+SCM_DEFINE (scm_member, "member", 2, 0, 0,
(SCM x, SCM lst),
-"")
+ "Return the first sublist of LST whose car is `equal?' to X\n"
+ "where the sublists of LST are the non-empty lists returned\n"
+ "by `(list-tail LST K)' for K less than the length of LST. If\n"
+ "X does not occur in LST, then `#f' (not the empty list) is\n"
+ "returned.")
#define FUNC_NAME s_scm_member
{
SCM answer;
- SCM_VALIDATE_LIST(2,lst);
+ SCM_VALIDATE_LIST (2,lst);
answer = scm_sloppy_member (x, lst);
return (answer == SCM_EOL) ? SCM_BOOL_F : answer;
}
\f
/* deleting elements from a list (delq, etc.) */
-GUILE_PROC(scm_delq_x, "delq!", 2, 0, 0,
+SCM_DEFINE (scm_delq_x, "delq!", 2, 0, 0,
(SCM item, SCM lst),
-"@deffnx primitive delv! item lst
-@deffnx primitive delete! item lst
-These procedures are destructive versions of @code{delq}, @code{delv}
-and @code{delete}: they modify the pointers in the existing @var{lst}
-rather than creating a new list. Caveat evaluator: Like other
-destructive list functions, these functions cannot modify the binding of
-@var{lst}, and so cannot be used to delete the first element of
-@var{lst} destructively.")
+ "@deffnx primitive delv! item lst\n"
+ "@deffnx primitive delete! item lst\n"
+ "These procedures are destructive versions of @code{delq}, @code{delv}\n"
+ "and @code{delete}: they modify the pointers in the existing @var{lst}\n"
+ "rather than creating a new list. Caveat evaluator: Like other\n"
+ "destructive list functions, these functions cannot modify the binding of\n"
+ "@var{lst}, and so cannot be used to delete the first element of\n"
+ "@var{lst} destructively.")
#define FUNC_NAME s_scm_delq_x
{
SCM walk;
#undef FUNC_NAME
-GUILE_PROC(scm_delv_x, "delv!", 2, 0, 0,
+SCM_DEFINE (scm_delv_x, "delv!", 2, 0, 0,
(SCM item, SCM lst),
-"")
+ "Destructively remove all elements from LST that are `eqv?' to ITEM.")
#define FUNC_NAME s_scm_delv_x
{
SCM walk;
-GUILE_PROC(scm_delete_x, "delete!", 2, 0, 0,
+SCM_DEFINE (scm_delete_x, "delete!", 2, 0, 0,
(SCM item, SCM lst),
-"")
+ "Destructively remove all elements from LST that are `equal?' to ITEM.")
#define FUNC_NAME s_scm_delete_x
{
SCM walk;
\f
-GUILE_PROC (scm_delq, "delq", 2, 0, 0,
+SCM_DEFINE (scm_delq, "delq", 2, 0, 0,
(SCM item, SCM lst),
-"@deffnx primitive delv item lst
-@deffnx primitive delete item lst
-Return a newly-created copy of @var{lst} with @var{item} removed. These
-procedures mirror @code{memq}, @code{memv} and @code{member}:
-@code{delq} compares elements of @var{lst} against @var{item} with
-@code{eq?}, @code{delv} uses @code{eqv?} and @code{delete} uses @code{equal?}")
+ "Return a newly-created copy of @var{lst} with elements `eq?' to @var{item} removed.\n"
+ "This procedure mirrors @code{memq}:\n"
+ "@code{delq} compares elements of @var{lst} against @var{item} with\n"
+ "@code{eq?}.")
#define FUNC_NAME s_scm_delq
{
SCM copy = scm_list_copy (lst);
}
#undef FUNC_NAME
-GUILE_PROC (scm_delv, "delv", 2, 0, 0,
+SCM_DEFINE (scm_delv, "delv", 2, 0, 0,
(SCM item, SCM lst),
-"")
+ "Return a newly-created copy of @var{lst} with elements `eqv?' to @var{item} removed.\n"
+ "This procedure mirrors @code{memv}:\n"
+ "@code{delv} compares elements of @var{lst} against @var{item} with\n"
+ "@code{eqv?}.")
#define FUNC_NAME s_scm_delv
{
SCM copy = scm_list_copy (lst);
}
#undef FUNC_NAME
-GUILE_PROC (scm_delete, "delete", 2, 0, 0,
+SCM_DEFINE (scm_delete, "delete", 2, 0, 0,
(SCM item, SCM lst),
-"")
+ "Return a newly-created copy of @var{lst} with elements `equal?' to @var{item} removed.\n"
+ "This procedure mirrors @code{member}:\n"
+ "@code{delete} compares elements of @var{lst} against @var{item} with\n"
+ "@code{equal?}.")
#define FUNC_NAME s_scm_delete
{
SCM copy = scm_list_copy (lst);
#undef FUNC_NAME
-GUILE_PROC(scm_delq1_x, "delq1!", 2, 0, 0,
+SCM_DEFINE (scm_delq1_x, "delq1!", 2, 0, 0,
(SCM item, SCM lst),
-"")
+ "Like `delq!', but only deletes the first occurrence of ITEM from LST.\n"
+ "Tests for equality using `eq?'. See also `delv1!' and `delete1!'.")
#define FUNC_NAME s_scm_delq1_x
{
SCM walk;
#undef FUNC_NAME
-GUILE_PROC(scm_delv1_x, "delv1!", 2, 0, 0,
- (SCM item, SCM lst),
-"")
+SCM_DEFINE (scm_delv1_x, "delv1!", 2, 0, 0,
+ (SCM item, SCM lst),
+ "Like `delv!', but only deletes the first occurrence of ITEM from LST.\n"
+ "Tests for equality using `eqv?'. See also `delq1!' and `delete1!'.")
#define FUNC_NAME s_scm_delv1_x
{
SCM walk;
#undef FUNC_NAME
-GUILE_PROC(scm_delete1_x, "delete1!", 2, 0, 0,
- (SCM item, SCM lst),
-"")
+SCM_DEFINE (scm_delete1_x, "delete1!", 2, 0, 0,
+ (SCM item, SCM lst),
+ "Like `delete!', but only deletes the first occurrence of ITEM from LST.\n"
+ "Tests for equality using `equal?'. See also `delq1!' and `delv1!'.")
#define FUNC_NAME s_scm_delete1_x
{
SCM walk;
HCoop / bpt / guile.git / blobdiff