457 lines
29 KiB
HTML
457 lines
29 KiB
HTML
<!doctype html public "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
|
<html>
|
|
<!--
|
|
|
|
Generated from r6rs-lib.tex by tex2page, v 20070803
|
|
(running on MzScheme 371, unix),
|
|
(c) Dorai Sitaram,
|
|
http://www.ccs.neu.edu/~dorai/tex2page/tex2page-doc.html
|
|
|
|
-->
|
|
<head>
|
|
<title>
|
|
r6rs-lib
|
|
</title>
|
|
<link rel="stylesheet" type="text/css" href="r6rs-lib-Z-S.css" title=default>
|
|
<meta name=robots content="index,follow">
|
|
</head>
|
|
<body>
|
|
<div id=slidecontent>
|
|
<div align=right class=navigation>[Go to <span><a href="r6rs-lib.html">first</a>, <a href="r6rs-lib-Z-H-3.html">previous</a></span><span>, <a href="r6rs-lib-Z-H-5.html">next</a></span> page<span>; </span><span><a href="r6rs-lib-Z-H-1.html#node_toc_start">contents</a></span><span><span>; </span><a href="r6rs-lib-Z-H-21.html#node_index_start">index</a></span>]</div>
|
|
<p></p>
|
|
<a name="node_chap_3"></a>
|
|
<h1 class=chapter>
|
|
<div class=chapterheading><a href="r6rs-lib-Z-H-1.html#node_toc_node_chap_3">Chapter 3</a></div><br>
|
|
<a href="r6rs-lib-Z-H-1.html#node_toc_node_chap_3">List utilities</a></h1>
|
|
<p></p>
|
|
<p>
|
|
This chapter describes the <tt>(rnrs lists (6))</tt><a name="node_idx_200"></a>library, which
|
|
contains various useful procedures that operate on lists.</p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_202"></a>find<i> proc list</i>)</tt> procedure </div>
|
|
<p>
|
|
<i>Proc</i> should accept one argument
|
|
and return a single value. <i>Proc</i> should not mutate <i>list</i>.
|
|
The <tt>find</tt> procedure applies <i>proc</i> to the elements of
|
|
<i>list</i> in order. If <i>proc</i> returns a true value for an
|
|
element, <tt>find</tt> immediately returns that element. If <i>proc</i>
|
|
returns <tt>#f</tt> for all elements of the list, <tt>find</tt> returns
|
|
<tt>#f</tt>. <i>Proc</i> is always called in the same dynamic environment
|
|
as <tt>find</tt> itself.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(find even? ’(3 1 4 1 5 9)) ⇒ 4<br>
|
|
(find even? ’(3 1 5 1 5 9)) ⇒ <tt>#f</tt><br>
|
|
<p></tt></p>
|
|
<p>
|
|
<em>Implementation responsibilities: </em>The implementation must check that <i>list</i> is a chain of
|
|
pairs up to the found element, or that it is indeed a list if no
|
|
element is found. It should not check that it is a chain of pairs
|
|
beyond the found element. The implementation must check the restrictions on
|
|
<i>proc</i> to the extent performed by applying it as described.
|
|
An
|
|
implementation may check whether <i>proc</i> is an appropriate argument
|
|
before applying it.
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_204"></a>for-all<i> proc <i>list<sub>1</sub></i> <i>list<sub>2</sub></i> <tt>...</tt> <i>list<sub><em>n</em></sub></i></i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_206"></a>exists<i> proc <i>list<sub>1</sub></i> <i>list<sub>2</sub></i> <tt>...</tt> <i>list<sub><em>n</em></sub></i></i>)</tt> procedure </div>
|
|
<p>
|
|
The <i>list</i>s should all have the same length, and
|
|
<i>proc</i> should accept <em>n</em> arguments and
|
|
return a single value.
|
|
<i>Proc</i> should not mutate the <i>list</i> arguments.</p>
|
|
<p>
|
|
For natural numbers <em>i</em> = 0, 1, <tt>...</tt>, the <tt>for-all</tt> procedure
|
|
successively applies <i>proc</i> to arguments <em>x</em><sub><em>i</em></sub><sup>1</sup> <tt>...</tt> <em>x</em><sub><em>i</em></sub><sup><em>n</em></sup>,
|
|
where <em>x</em><sub><em>i</em></sub><sup><em>j</em></sup> is the <em>i</em>th element of <i>list<sub><em>j</em></sub></i>, until <tt>#f</tt> is
|
|
returned. If <i>proc</i> returns true values for all but the last
|
|
element of <i>list<sub>1</sub></i>, <tt>for-all</tt> performs a tail call of <i>proc</i>
|
|
on the <em>k</em>th elements, where <em>k</em> is the length of <i>list<sub>1</sub></i>. If <i>proc</i>
|
|
returns <tt>#f</tt> on any set of elements, <tt>for-all</tt> returns
|
|
<tt>#f</tt> after the first such application of <i>proc</i>.
|
|
If the <i>list</i>s are all empty, <tt>for-all</tt> returns <tt>#t</tt>.</p>
|
|
<p>
|
|
For natural numbers <em>i</em> = 0, 1, <tt>...</tt>, the <tt>exists</tt> procedure
|
|
applies <i>proc</i> successively to arguments <em>x</em><sub><em>i</em></sub><sup>1</sup> <tt>...</tt> <em>x</em><sub><em>i</em></sub><sup><em>n</em></sup>,
|
|
where <em>x</em><sub><em>i</em></sub><sup><em>j</em></sup> is the <em>i</em>th element of <i>list<sub><em>j</em></sub></i>, until a true value is
|
|
returned. If <i>proc</i> returns <tt>#f</tt> for all but the last
|
|
elements of the <i>list</i>s, <tt>exists</tt> performs a tail call of
|
|
<i>proc</i> on the <em>k</em>th elements, where <em>k</em> is the length of
|
|
<i>list<sub>1</sub></i>.
|
|
If <i>proc</i> returns a true value on any set of elements, <tt>exists</tt> returns that value after the first such application of
|
|
<i>proc</i>. If the <i>list</i>s
|
|
are all empty, <tt>exists</tt> returns <tt>#f</tt>.</p>
|
|
<p>
|
|
<i>Proc</i> is always called in the same dynamic environment
|
|
as <tt>for-all</tt> or, respectively, <tt>exists</tt> itself.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(for-all even? ’(3 1 4 1 5 9)) <br> ⇒ <tt>#f</tt><br>
|
|
(for-all even? ’(3 1 4 1 5 9 . 2)) <br> ⇒ <tt>#f</tt><br>
|
|
(for-all even? ’(2 4 14)) ⇒ <tt>#t</tt><br>
|
|
(for-all even? ’(2 4 14 . 9)) <br> ⇒ <tt> <tt>&assertion</tt></tt> <i>exception</i><br>
|
|
(for-all (lambda (n) (and (even? n) n))<br>
|
|
’(2 4 14)) <br> ⇒ 14<br>
|
|
(for-all < ’(1 2 3) ’(2 3 4)) <br> ⇒ <tt>#t</tt><br>
|
|
(for-all < ’(1 2 4) ’(2 3 4)) <br> ⇒ <tt>#f</tt><br>
|
|
<br>
|
|
(exists even? ’(3 1 4 1 5 9)) <br> ⇒ <tt>#t</tt><br>
|
|
(exists even? ’(3 1 1 5 9)) ⇒ <tt>#f</tt><br>
|
|
(exists even? ’(3 1 1 5 9 . 2)) <br> ⇒ <tt> <tt>&assertion</tt></tt> <i>exception</i><br>
|
|
(exists (lambda (n) (and (even? n) n)) ’(2 1 4 14)) <br> ⇒ 2<br>
|
|
(exists < ’(1 2 4) ’(2 3 4)) ⇒ <tt>#t</tt><br>
|
|
(exists > ’(1 2 3) ’(2 3 4)) ⇒ <tt>#f</tt><br>
|
|
<p></tt></p>
|
|
<p>
|
|
<em>Implementation responsibilities: </em>The implementation must check that the <i>list</i>s are
|
|
chains of pairs to the extent necessary to determine the return value.
|
|
If this requires traversing the lists entirely, the implementation
|
|
should check that the <i>list</i>s all have the same length. If not,
|
|
it should not check that the <i>list</i>s are chains of pairs beyond
|
|
the traversal. The implementation must check the restrictions on
|
|
<i>proc</i> to the extent performed by applying it as described.
|
|
An
|
|
implementation may check whether <i>proc</i> is an appropriate argument
|
|
before applying it.
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_208"></a>filter<i> proc list</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_210"></a>partition<i> proc list</i>)</tt> procedure </div>
|
|
<p>
|
|
<i>Proc</i> should accept one argument
|
|
and return a single value. <i>Proc</i> should not mutate <i>list</i>.</p>
|
|
<p>
|
|
The <tt>filter</tt> procedure applies
|
|
<i>proc</i> to each element of <i>list</i> and returns a list of
|
|
the elements of <i>list</i> for which <i>proc</i> returned a true
|
|
value. The <tt>partition</tt> procedure also applies <i>proc</i> to
|
|
each element of <i>list</i>, but returns two values, the first one a
|
|
list of the elements of <i>list</i> for which <i>proc</i> returned a
|
|
true value, and the second a list of the elements of <i>list</i> for
|
|
which <i>proc</i> returned <tt>#f</tt>.
|
|
In both cases, the elements of the result list(s) are in the same
|
|
order as they appear in the input list.
|
|
<i>Proc</i> is always called in the same dynamic environment
|
|
as <tt>filter</tt> or, respectively, <tt>partition</tt> itself.
|
|
If multiple returns occur from <tt>filter</tt> or <tt>partitions</tt>, the return
|
|
values returned by earlier returns are not mutated.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(filter even? ’(3 1 4 1 5 9 2 6)) <br> ⇒ (4 2 6)<br>
|
|
<br>
|
|
(partition even? ’(3 1 4 1 5 9 2 6)) <br> ⇒ (4 2 6) (3 1 1 5 9) ; two values<br>
|
|
<p></tt></p>
|
|
<p>
|
|
<em>Implementation responsibilities: </em>The implementation must check the restrictions on <i>proc</i>
|
|
to the extent performed by applying it as described.
|
|
An
|
|
implementation may check whether <i>proc</i> is an appropriate argument
|
|
before applying it.
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_212"></a>fold-left<i> combine nil <i>list<sub>1</sub></i> <i>list<sub>2</sub></i> <tt>...</tt><i>list<sub><em>n</em></sub></i></i>)</tt> procedure </div>
|
|
<p>
|
|
The <i>list</i>s should all have the same
|
|
length. <i>Combine</i> must be a procedure. It should accept one more
|
|
argument than there are <i>list</i>s and return a single value.
|
|
It should not mutate the <i>list</i> arguments.
|
|
The <tt>fold-left</tt> procedure iterates the <i>combine</i> procedure over an
|
|
accumulator value and the elements of the <i>list</i>s from left to
|
|
right, starting with an accumulator value of <i>nil</i>. More
|
|
specifically, <tt>fold-left</tt> returns <i>nil</i> if the <i>list</i>s are
|
|
empty. If they are not empty, <i>combine</i> is first applied to
|
|
<i>nil</i> and the respective first elements of the <i>list</i>s in
|
|
order. The result becomes the new accumulator value, and <i>combine</i>
|
|
is applied to the new accumulator value and the respective next elements
|
|
of the <i>list</i>. This step is repeated until the end of the list is
|
|
reached; then the accumulator value is returned.
|
|
<i>Combine</i> is always called in the same dynamic environment
|
|
as <tt>fold-left</tt> itself.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(fold-left + 0 ’(1 2 3 4 5)) ⇒ 15<br>
|
|
<br>
|
|
(fold-left (lambda (a e) (cons e a)) ’()<br>
|
|
’(1 2 3 4 5)) <br> ⇒ (5 4 3 2 1)<br>
|
|
<br>
|
|
(fold-left (lambda (count x)<br>
|
|
(if (odd? x) (+ count 1) count))<br>
|
|
0<br>
|
|
’(3 1 4 1 5 9 2 6 5 3)) <br> ⇒ 7<br>
|
|
<br>
|
|
(fold-left (lambda (max-len s)<br>
|
|
(max max-len (string-length s)))<br>
|
|
0<br>
|
|
’("longest" "long" "longer")) <br> ⇒ 7<br>
|
|
<br>
|
|
(fold-left cons ’(q) ’(a b c)) <br> ⇒ ((((q) . a) . b) . c)<br>
|
|
<br>
|
|
(fold-left + 0 ’(1 2 3) ’(4 5 6)) <br> ⇒ 21<br>
|
|
<p></tt></p>
|
|
<p>
|
|
<em>Implementation responsibilities: </em>The implementation should check that the <i>list</i>s all
|
|
have the same length. The implementation must check the restrictions
|
|
on <i>combine</i> to the extent performed by applying it as described.
|
|
An
|
|
implementation may check whether <i>combine</i> is an appropriate argument
|
|
before applying it.
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_214"></a>fold-right<i> combine nil <i>list<sub>1</sub></i> <i>list<sub>2</sub></i> <tt>...</tt><i>list<sub><em>n</em></sub></i></i>)</tt> procedure </div>
|
|
<p>
|
|
The <i>list</i>s should all have the same
|
|
length. <i>Combine</i> must be a procedure. It should accept one more
|
|
argument than there are <i>list</i>s and return a single value.
|
|
<i>Combine</i> should not mutate the <i>list</i> arguments.
|
|
The <tt>fold-right</tt> procedure iterates the <i>combine</i> procedure over
|
|
the elements of the <i>list</i>s from right to left and an accumulator
|
|
value, starting with an accumulator value of <i>nil</i>. More
|
|
specifically, <tt>fold-right</tt> returns <i>nil</i> if the <i>list</i>s
|
|
are empty. If they are not empty, <i>combine</i> is first applied to the
|
|
respective last elements of the <i>list</i>s in order and <i>nil</i>.
|
|
The result becomes the new accumulator value, and <i>combine</i> is
|
|
applied to the respective previous elements of the <i>list</i>s and the
|
|
new accumulator value. This step is repeated until the beginning of the
|
|
list is reached; then the accumulator value is returned.
|
|
<i>Proc</i> is always called in the same dynamic environment
|
|
as <tt>fold-right</tt> itself.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(fold-right + 0 ’(1 2 3 4 5)) <br> ⇒ 15<br>
|
|
<br>
|
|
(fold-right cons ’() ’(1 2 3 4 5)) <br> ⇒ (1 2 3 4 5)<br>
|
|
<br>
|
|
(fold-right (lambda (x l)<br>
|
|
(if (odd? x) (cons x l) l))<br>
|
|
’()<br>
|
|
’(3 1 4 1 5 9 2 6 5))<br>
|
|
⇒ (3 1 1 5 9 5)<br>
|
|
<br>
|
|
(fold-right cons ’(q) ’(a b c)) <br> ⇒ (a b c q)<br>
|
|
<br>
|
|
(fold-right + 0 ’(1 2 3) ’(4 5 6)) <br> ⇒ 21<br>
|
|
<p></tt></p>
|
|
<p>
|
|
<em>Implementation responsibilities: </em>The implementation should check that the <i>list</i>s all
|
|
have the same length. The implementation must check the restrictions
|
|
on <i>combine</i> to the extent performed by applying it as described.
|
|
An
|
|
implementation may check whether <i>combine</i> is an appropriate argument
|
|
before applying it.
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_216"></a>remp<i> proc list</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_218"></a>remove<i> obj list</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_220"></a>remv<i> obj list</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_222"></a>remq<i> obj list</i>)</tt> procedure </div>
|
|
<p>
|
|
<i>Proc</i> should accept one argument
|
|
and return a single value.
|
|
<i>Proc</i> should not mutate <i>list</i>.</p>
|
|
<p>
|
|
Each of these procedures returns a list of the elements of <i>list</i>
|
|
that do not satisfy a given condition. The <tt>remp</tt> procedure
|
|
applies <i>proc</i> to each element of <i>list</i> and returns a
|
|
list of the elements of <i>list</i> for which <i>proc</i> returned
|
|
<tt>#f</tt>. <i>Proc</i> is always called in the same dynamic environment
|
|
as <tt>remp</tt> itself.
|
|
The <tt>remove</tt>, <tt>remv</tt>, and <tt>remq</tt> procedures return a list of
|
|
the elements that are not <i>obj</i>. The <tt>remq</tt> procedure uses <tt>eq?</tt> to
|
|
compare <i>obj</i> with the elements of <i>list</i>, while <tt>remv</tt>
|
|
uses <tt>eqv?</tt> and <tt>remove</tt> uses <tt>equal?</tt>.
|
|
The elements of the result list are in the same
|
|
order as they appear in the input list.
|
|
If multiple returns occur from <tt>remp</tt>, the return
|
|
values returned by earlier returns are not mutated.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(remp even? ’(3 1 4 1 5 9 2 6 5)) <br> ⇒ (3 1 1 5 9 5)<br>
|
|
<br>
|
|
(remove 1 ’(3 1 4 1 5 9 2 6 5)) <br> ⇒ (3 4 5 9 2 6 5)<br>
|
|
<br>
|
|
(remv 1 ’(3 1 4 1 5 9 2 6 5)) <br> ⇒ (3 4 5 9 2 6 5)<br>
|
|
<br>
|
|
(remq ’foo ’(bar foo baz)) ⇒ (bar baz)<br>
|
|
<p></tt></p>
|
|
<p>
|
|
<em>Implementation responsibilities: </em>The implementation must check the restrictions on <i>proc</i>
|
|
to the extent performed by applying it as described.
|
|
An
|
|
implementation may check whether <i>proc</i> is an appropriate argument
|
|
before applying it.
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_224"></a>memp<i> proc list</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_226"></a>member<i> obj list</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_228"></a>memv<i> obj list</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_230"></a>memq<i> obj list</i>)</tt> procedure </div>
|
|
<p>
|
|
<i>Proc</i> should accept one argument
|
|
and return a single value. <i>Proc</i> should not mutate <i>list</i>.</p>
|
|
<p>
|
|
These procedures return the first sublist of <i>list</i> whose car
|
|
satisfies a given condition, where the sublists of <i>lists</i> are the
|
|
lists returned by <tt>(list-tail <i>list</i> <i>k</i>)</tt> for
|
|
<i>k</i> less than the length of <i>list</i>. The <tt>memp</tt> procedure applies
|
|
<i>proc</i> to the cars of the sublists of <i>list</i> until it
|
|
finds one for which <i>proc</i> returns a true value.
|
|
<i>Proc</i> is always called in the same dynamic environment
|
|
as <tt>memp</tt> itself. The <tt>member</tt>, <tt>memv</tt>, and <tt>memq</tt> procedures look for the first occurrence of
|
|
<i>obj</i>. If <i>list</i> does not contain an element satisfying the
|
|
condition, then <tt>#f</tt> (not the empty list) is returned. The <tt>member</tt> procedure uses <tt>equal?</tt> to compare <i>obj</i> with the elements of
|
|
<i>list</i>, while <tt>memv</tt> uses <tt>eqv?</tt> and <tt>memq</tt> uses
|
|
<tt>eq?</tt>.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(memp even? ’(3 1 4 1 5 9 2 6 5)) <br> ⇒ (4 1 5 9 2 6 5)<br>
|
|
<br>
|
|
(memq ’a ’(a b c)) ⇒ (a b c)<br>
|
|
(memq ’b ’(a b c)) ⇒ (b c)<br>
|
|
(memq ’a ’(b c d)) ⇒ <tt>#f</tt><br>
|
|
(memq (list ’a) ’(b (a) c)) ⇒ <tt>#f</tt><br>
|
|
(member (list ’a)<br>
|
|
’(b (a) c)) ⇒ ((a) c)<br>
|
|
(memq 101 ’(100 101 102)) ⇒ <i>unspecified</i><br>
|
|
(memv 101 ’(100 101 102)) ⇒ (101 102)<p></tt> </p>
|
|
<p>
|
|
<em>Implementation responsibilities: </em>The implementation must check that <i>list</i> is a chain of
|
|
pairs up to the found element, or that it is indeed a list if no
|
|
element is found. It should not check that it is a chain of pairs
|
|
beyond the found element. The implementation must check the restrictions on
|
|
<i>proc</i> to the extent performed by applying it as described.
|
|
An
|
|
implementation may check whether <i>proc</i> is an appropriate argument
|
|
before applying it.
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_232"></a>assp<i> proc alist</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_234"></a>assoc<i> obj alist</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_236"></a>assv<i> obj alist</i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_238"></a>assq<i> obj alist</i>)</tt> procedure </div>
|
|
<p>
|
|
<i>Alist</i> (for “association list”) should be a list of pairs.
|
|
<i>Proc</i> should accept one argument
|
|
and return a single value. <i>Proc</i> should not mutate <i>alist</i>.</p>
|
|
<p>
|
|
These procedures find the first pair in <i>alist</i>
|
|
whose car field satisfies a given condition, and returns that pair
|
|
without traversing <i>alist</i> further.
|
|
If no pair in <i>alist</i> satisfies the condition, then <tt>#f</tt>
|
|
is returned. The <tt>assp</tt> procedure successively applies
|
|
<i>proc</i> to the car fields of <i>alist</i> and looks for a pair
|
|
for which it returns a true value.
|
|
<i>Proc</i> is always called in the same dynamic environment
|
|
as <tt>assp</tt> itself. The <tt>assoc</tt>, <tt>assv</tt>, and <tt>assq</tt> procedures look for a pair that has <i>obj</i> as its car. The
|
|
<tt>assoc</tt> procedure uses
|
|
<tt>equal?</tt> to compare <i>obj</i> with the car fields of the pairs in
|
|
<i>alist</i>, while <tt>assv</tt> uses <tt>eqv?</tt> and <tt>assq</tt> uses
|
|
<tt>eq?</tt>.</p>
|
|
<p>
|
|
<em>Implementation responsibilities: </em>The implementation must check that <i>alist</i> is a chain of
|
|
pairs containing pairs up to the found pair, or that it is indeed a
|
|
list of pairs if no element is found. It should not check that it is
|
|
a chain of pairs beyond the found element. The implementation must
|
|
check the restrictions on <i>proc</i> to the extent performed by
|
|
applying it as described.
|
|
An
|
|
implementation may check whether <i>proc</i> is an appropriate argument
|
|
before applying it.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(define d ’((3 a) (1 b) (4 c)))<br>
|
|
<br>
|
|
(assp even? d) ⇒ (4 c)<br>
|
|
(assp odd? d) ⇒ (3 a)<br>
|
|
<br>
|
|
(define e ’((a 1) (b 2) (c 3)))<br>
|
|
(assq ’a e) ⇒ (a 1)<br>
|
|
(assq ’b e) ⇒ (b 2)<br>
|
|
(assq ’d e) ⇒ <tt>#f</tt><br>
|
|
(assq (list ’a) ’(((a)) ((b)) ((c))))<br>
|
|
⇒ <tt>#f</tt><br>
|
|
(assoc (list ’a) ’(((a)) ((b)) ((c)))) <br>
|
|
⇒ ((a))<br>
|
|
(assq 5 ’((2 3) (5 7) (11 13))) <br>
|
|
⇒ <i>unspecified</i><br>
|
|
(assv 5 ’((2 3) (5 7) (11 13))) <br>
|
|
⇒ (5 7)<p></tt></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div align=left><tt>(<a name="node_idx_240"></a>cons*<i> <i>obj<sub>1</sub></i> <tt>...</tt> <i>obj<sub><em>n</em></sub></i> <i>obj</i></i>)</tt> procedure </div>
|
|
|
|
<div align=left><tt>(<a name="node_idx_242"></a>cons*<i> <i>obj</i></i>)</tt> procedure </div>
|
|
<p>
|
|
If called with at least two arguments, <tt>cons*</tt> returns a freshly
|
|
allocated chain of pairs whose cars are <i>obj<sub>1</sub></i>, <tt>...</tt>,
|
|
<i>obj<sub><em>n</em></sub></i>, and whose last cdr is <i>obj</i>. If called with only one
|
|
argument, <tt>cons*</tt> returns that argument.</p>
|
|
<p>
|
|
</p>
|
|
|
|
<tt>(cons* 1 2 ’(3 4 5)) ⇒ (1 2 3 4 5)<br>
|
|
(cons* 1 2 3) ⇒ (1 2 . 3)<br>
|
|
(cons* 1) ⇒ 1<p></tt></p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<p>
|
|
</p>
|
|
<p>
|
|
</p>
|
|
<p></p>
|
|
<div class=smallskip></div>
|
|
<p style="margin-top: 0pt; margin-bottom: 0pt">
|
|
<div align=right class=navigation>[Go to <span><a href="r6rs-lib.html">first</a>, <a href="r6rs-lib-Z-H-3.html">previous</a></span><span>, <a href="r6rs-lib-Z-H-5.html">next</a></span> page<span>; </span><span><a href="r6rs-lib-Z-H-1.html#node_toc_start">contents</a></span><span><span>; </span><a href="r6rs-lib-Z-H-21.html#node_index_start">index</a></span>]</div>
|
|
</p>
|
|
<p></p>
|
|
</div>
|
|
</body>
|
|
</html>
|