forked from scheme-requests-for-implementation/srfi-51
-
Notifications
You must be signed in to change notification settings - Fork 0
/
srfi-51.html
581 lines (530 loc) · 25 KB
/
srfi-51.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<html>
<head>
<title>SRFI 51: Handling rest list</title>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link rel="stylesheet" href="/srfi.css" type="text/css" />
</head>
<body>
<H1>Title</H1>
Handling rest list
<H1>Author</H1>
<span class="author">Joo ChurlSoo</span>
<H1>Status</H1>
This SRFI is currently in ``<span class="status">final</span>'' status. To see an explanation of each status that a SRFI can hold, see <A HREF="http://srfi.schemers.org/srfi-process.html">here</A>.
You can access the discussion via <A HREF=mail-archive/maillist.html>the archive of the mailing list</A>.
<P><UL>
<LI>Received: <a href="http://srfi.schemers.org/srfi-51/srfi-51-1.1.txt">2004/01/09</a>
<LI>Draft: 2004/01/18-2004/03/18
<LI>Revised: <a href="http://srfi.schemers.org/srfi-51/srfi-51-1.2.txt">2004/01/28</a>
<LI>Revised: <a href="http://srfi.schemers.org/srfi-51/srfi-51-1.3.txt">2004/02/08</a>
<LI>Revised: <a href="http://srfi.schemers.org/srfi-51/srfi-51-1.4.txt">2004/03/24</a>
<LI>Revised: <a
href="http://srfi.schemers.org/srfi-51/srfi-51-1.5.txt">2004/05/06</a>
<LI>Final: 2004/06/07
</UL>
<h1>Related SRFIs</h1>
<p>
The procedure and macros proposed in this SRFI make a strong
combination with <code>receive</code> (<a href="../srfi-8/">SRFI
8</a>) and <code>let-values</code> (<a href="../srfi-11/">SRFI 11</a>).
</p>
<h1>Abstract</h1>
<p>
This SRFI introduces the <code>rest-values</code> procedure which has three modes of
operation:
</p>
<ol>
<li>it processes a rest list after checking its elements with default values or
predicate procedures,</li>
<li> it processes a rest list with default values without checking its elements,</li>
<li> it processes a default list whose elements are lists or pairs, after
checking their elements that are default values or predicate procedures
with the elements of a rest list,</li>
</ol>
<p>
and eight macros which additionally check the rest arguments that are returned
by <code>rest-values</code>.
</p>
<h1>Rationale</h1>
<p>
When defining a procedure with a variable number of arguments, <code>rest-values</code>
with or without the checking macros reduces the clutter of various
conditionals and error conditions.
</p>
<h1>Specification</h1>
<dl>
<dt class="proc def">
<code>(rest-values [<caller>] <rest-list>
[<args-number-limit> <default> ...])</code></dt>
<dt>
<dd> <code><caller></code> is any scheme expression.</dd>
<dd> <code><args-number-limit></code> should be an integer, <code>+</code>, <code>-</code>, or a boolean.</dd>
<dd>
<dt>
<ol>
<li>When the <code><args-number-limit></code> is <code>+</code> or a positive integer,
each <code><default></code> should be a list that contains default value(s), or a
pair whose car is a default value and cdr is a predicate procedure.</li>
<li>When the <code><args-number-limit></code> is <code>-</code> or a negative integer,
each <code><default></code> is any scheme expression.</li>
<li>When the <code><args-number-limit></code> is a boolean,
each <code><default></code> is the same as 1.</li>
</ol>
<ol>
<li>(first mode of operation)
<p>
<code>Rest-values</code> checks whether each element of the <code><rest-list></code> is a member of
the corresponding <code><default></code> list, or satisfies the predicate procedure of
the corresponding <code><default></code> pair, and then returns the checked element(s).
If the element doesn't pass, <code>rest-values</code> signals an error. when there are
no more elements in the <code><rest-list></code>, then <code>rest-values</code> additionally returns
the car values of the remaining <code><default></code>s. On the other hand, when the
number of elements of the <code><rest-list></code> are more than the number of the
<code><default></code>s, the supernumerary elements are additionally returned if the
<code><args-number-limit></code> is <code>+</code>, or its value is not less than the number of
elements of the <code><rest-list></code>.
</p>
</li>
<li>(second mode of operation)
<p>
This is the same as the first except that <code>rest-values</code>
does not check each element of the <code><rest-list></code>, and it uses
<code>-</code> instead of <code>+</code>, and an absolute value
instead of a simple value as the value of
<code><args-number-limit></code>.
</p>
</li>
<li>(third mode of operation)
<p>
<code>Rest-values</code> checks whether any element of the <code><default></code> list is a member of
the <code><rest-list></code>, or any element of the <code><rest-list></code> satisfies the predicate
procedure of the <code><default></code> pair, and then returns the checked element. If
the <code><default></code> doesn't pass, <code>rest-values</code> returns the car value of the
<code><default></code>. when any elements of the <code><rest-list></code> are remained after the
above processing, <code>rest-values</code> either signals an error if the
<code><args-number-limit></code> is <code>#t</code>, or returns the remaining elements of the
<code><rest-list></code> if the <code><args-number-limit></code> is <code>#f</code>.
</p>
</ol>
<dl>
<dt><code class="syntax def">(<span>arg-and</span> [<<var class="opt">caller</var>>] <<var>variable</var>> <<var>expr</var>>
...)</code> (syntax)</dt>
<dt>
<code class="syntax def">(<span>arg-ands</span>
[common <<var class="opt">caller</var>>]
([<<var class="opt">caller</var>>]
<<var class="opt">variable</var>>
<<var class="opt">expr</var>>
<var class="rest">...</var>)
<var class="rest">...</var>)</code>
(syntax)
</dt>
<dt><code class="syntax def">(<span>err-and</span> <caller> <expression> ...)</code> (syntax)</dt>
<dt><code class="syntax def">(<span>err-ands</span> (<caller> <expression> ...) ...)</code> (syntax)</dt>
<dt><code class="syntax def">(<span>arg-or</span> [<caller>] <variable> <expr> ...)</code> (syntax)</dt>
<dt><code class="syntax def">(<span>arg-ors</span> [common <caller>] ([<caller>] <variable> <expr> ...) ...)</code> (syntax)</dt>
<dt><code class="syntax def">(<span>err-or</span> <caller> <expression> ...)</code> (syntax)</dt>
<dt><code class="syntax def">(<span>err-ors</span> (<caller> <expression> ...) ...)</code>
(syntax)</dt>
<dd>Each <code><variable></code> should be an argument of a procedure.</dd>
<dd>The <code><caller></code>, <code><expr></code>, and <code><expression></code> are any scheme expression, but
the <code><expr></code> should contain the corresponding <code><variable></code>.</dd>
<dd>
<code>Arg-and</code>, <code>arg-ands</code>, <code>err-and</code>, and <code>err-ands</code> are the same as <code>and</code> except that these
signal an error in case <code>and</code> returns a false value.</dd>
<dd>
<code>Arg-or</code>, <code>arg-ors</code>, <code>err-or</code>, and <code>err-ors</code> are the same as <code>or</code> except that these
signal an error in case <code>or</code> returns a true value.
</dd>
</dl>
<p>
Examples
</p>
<pre>caller => <procedure caller>
rest-list => (x 1)
(rest-values rest-list) => x 1
(rest-values rest-list 2) => x 1
(rest-values caller rest-list) => x 1
(rest-values caller rest-list -3) => x 1
(rest-values rest-list -2 'y 3 1)
=> error too many defaults (y 3 1) default-list (<= (length default-list) 2)
(rest-values 'caller rest-list 1 '(x y z))
=> error too many arguments (x 1) rest-list (<= (length rest-list) 1) caller
(rest-values caller rest-list 2 (list 'x 'y 'z) (cons "str" string?))
=> error incorrect argument 1 arg (<procedure string?> arg) <procedure caller>
(rest-values rest-list 2 '(y z) `(100 . ,number?))
=> error unmatched argument x arg (member arg (y z))
(rest-values "caller: bad argument" rest-list 2 '(y z) `(100 . ,number?))
=> error caller: bad argument x arg (member arg (y z))
(rest-values 'caller rest-list (list 'x 'y) (cons 1 number?))
=> error bad optional argument (x y) option
(or (boolean? option) (integer? option) (memq option (list + -))) caller
(rest-values rest-list - 'y 100 "str")
=> x 1 "str"
(rest-values rest-list + `(x y z) `(100 . ,number?) `("str" . ,string?))
=> x 1 "str"
(rest-values rest-list #t `(x y z) `(100 . ,number?) `("str" . ,string?))
=> x 1 "str"
(rest-values rest-list #t `(100 . ,number?) `("str" . ,string?) `(x y z))
=> 1 "str" x
(rest-values rest-list #t `(100 . ,number?) `("str" . ,string?) `(y z))
=> error bad argument (x) rest-list (null? rest-list)
(rest-values rest-list #f `(100 . ,number?) `("str" . ,string?) `(y z))
=> 1 "str" y x
recaller => <procedure caller>
str => "string"
num => 2
(arg-and num (number? num) (< num 2))
=> error incorrect argument 2 num (< num 2)
(arg-and caller num (number? num) (< num 2))
=> error incorrect argument 2 num (< num 2) <procedure caller>
(arg-and 'caller num (number? num) (< num 2))
=> error incorrect argument 2 num (< num 2) caller
(arg-and "caller: bad argument" num (number? num) (< num 2))
=> error caller: bad argument 2 num (< num 2)
(arg-ands (str (string? str) (< (string-length str) 7))
("caller: bad argument" num (number? num) (< num 2)))
=> error caller: bad argument 2 num (< num 2)
(arg-ands ("caller: bad argument" str (string? str) (< (string-length str) 7))
(num (number? num) (< num 2)))
=> error incorrect argument 2 num (< num 2)
(arg-ands common 'caller
(str (string? str) (< (string-length str) 7))
(num (number? num) (< num 2)))
=> error incorrect argument 2 num (< num 2) caller
(arg-ands common "caller: bad argument"
(str (string? str) (< (string-length str) 7))
("caller: incorrect argument" num (number? num) (< num 2)))
=> error caller: incorrect argument 2 num (< num 2)
(err-and 'caller
(string? str) (< (string-length str) 7) (number? num) (< num 2))
=> error false expression (< num 2) caller
(err-ands (caller (string? str) (< (string-length str) 7))
("num failed test in caller" (number? num) (< num 2)))
=> error num failed test in caller (< num 2)
(define (read-line . p-d)
;; p-d should be (<input-port> <symbol>).
(receive (p d) (rest-values p-d 2
(cons (current-input-port) input-port?)
(list 'trim 'concat 'split...))
...))
(define (read-line . p-d)
(receive (p d) (rest-values p-d -2 (current-input-port) 'trim)
(arg-ands (p (input-port? p))
(d (memq d '(trim concat split...))))
...))
(define (read-line . p-d)
;; p-d can be (<input-port> <symbol>) or (<symbol> <input-port>).
(receive (p d) (rest-values p-d #t
(cons (current-input-port) input-port?)
(list 'trim 'concat 'split...))
...))
(define (delete x ls . predicate)
(let ((pred (rest-values 'delete predicate 1 (list equal? eqv? eq?))))
...))
(define (delete x ls . predicate)
(let ((pred (rest-values 'delete predicate -1 equal?)))
(err-and 'delete (list? ls) (memq pred (list equal? eqv? eq?)))
...))
(define (substring str . start-end)
(let ((str-len (arg-and substring str (string? str) (string-length str))))
(receive (start end) (rest-values substring start-end -2 0 str-len)
(arg-ands common substring
(start (integer? start) (<= 0 start str-len))
(end (integer? end) (<= start end str-len)))
...)))
(define (procedure-with-sequential-binding-arguments . a-b-c)
(receive (a b c) (rest-values a-b-c -3 10 #f #f)
(let* ((b (or b (+ a 10)))
(c (or c (+ a b))))
...)))
</pre>
<H1>Implementation</H1>
The implementation below requires <a href="../srfi-1/">SRFI 1</a>
(List library) and <a href="../srfi-23/">SRFI 23</a> (Error
reporting mechanism).
<pre>
(define (rest-values rest . default)
(let* ((caller (if (or (null? default)
(boolean? (car default))
(integer? (car default))
(memq (car default) (list + -)))
'()
(if (string? rest) rest (list rest))))
(rest-list (if (null? caller) rest (car default)))
(rest-length (if (list? rest-list)
(length rest-list)
(if (string? caller)
(error caller rest-list 'rest-list
'(list? rest-list))
(apply error "bad rest list" rest-list 'rest-list
'(list? rest-list) caller))))
(default (if (null? caller) default (cdr default)))
(default-list (if (null? default) default (cdr default)))
(default-length (length default-list))
(number
(and (not (null? default))
(let ((option (car default)))
(or (and (integer? option)
(or (and (> rest-length (abs option))
(if (string? caller)
(error caller rest-list 'rest-list
`(<= (length rest-list)
,(abs option)))
(apply error "too many arguments"
rest-list 'rest-list
`(<= (length rest-list)
,(abs option))
caller)))
(and (> default-length (abs option))
(if (string? caller)
(error caller default-list
'default-list
`(<= (length default-list)
,(abs option)))
(apply error "too many defaults"
default-list 'default-list
`(<= (length default-list)
,(abs option))
caller)))
option))
(eq? option #t)
(and (not option) 'false)
(and (eq? option +) +)
(and (eq? option -) -)
(if (string? caller)
(error caller option 'option
'(or (boolean? option)
(integer? option)
(memq option (list + -))))
(apply error "bad optional argument" option 'option
'(or (boolean? option)
(integer? option)
(memq option (list + -)))
caller)))))))
(cond
((or (eq? #t number) (eq? 'false number))
(and (not (every pair? default-list))
(if (string? caller)
(error caller default-list 'default-list
'(every pair? default-list))
(apply error "bad default list" default-list 'default-list
'(every pair? default-list) caller)))
(let loop ((rest-list rest-list)
(default-list default-list)
(result '()))
(if (null? default-list)
(if (null? rest-list)
(apply values (reverse result))
(if (eq? #t number)
(if (string? caller)
(error caller rest-list 'rest-list '(null? rest-list))
(apply error "bad argument" rest-list 'rest-list
'(null? rest-list) caller))
(apply values (append-reverse result rest-list))))
(if (null? rest-list)
(apply values (append-reverse result (map car default-list)))
(let ((default (car default-list)))
(let lp ((rest rest-list)
(head '()))
(if (null? rest)
(loop (reverse head)
(cdr default-list)
(cons (car default) result))
(if (list? default)
(if (member (car rest) default)
(loop (append-reverse head (cdr rest))
(cdr default-list)
(cons (car rest) result))
(lp (cdr rest) (cons (car rest) head)))
(if ((cdr default) (car rest))
(loop (append-reverse head (cdr rest))
(cdr default-list)
(cons (car rest) result))
(lp (cdr rest) (cons (car rest) head)))))))))))
((or (and (integer? number) (> number 0))
(eq? number +))
(and (not (every pair? default-list))
(if (string? caller)
(error caller default-list 'default-list
'(every pair? default-list))
(apply error "bad default list" default-list 'default-list
'(every pair? default-list) caller)))
(let loop ((rest rest-list)
(default default-list))
(if (or (null? rest) (null? default))
(apply values
(if (> default-length rest-length)
(append rest-list
(map car (list-tail default-list rest-length)))
rest-list))
(let ((arg (car rest))
(par (car default)))
(if (list? par)
(if (member arg par)
(loop (cdr rest) (cdr default))
(if (string? caller)
(error caller arg 'arg `(member arg ,par))
(apply error "unmatched argument"
arg 'arg `(member arg ,par) caller)))
(if ((cdr par) arg)
(loop (cdr rest) (cdr default))
(if (string? caller)
(error caller arg 'arg `(,(cdr par) arg))
(apply error "incorrect argument"
arg 'arg `(,(cdr par) arg) caller))))))))
(else
(apply values (if (> default-length rest-length)
(append rest-list (list-tail default-list rest-length))
rest-list))))))
(define-syntax arg-and
(syntax-rules()
((arg-and arg (a1 a2 ...) ...)
(and (or (symbol? 'arg)
(error "bad syntax" 'arg '(symbol? 'arg)
'(arg-and arg (a1 a2 ...) ...)))
(or (a1 a2 ...)
(error "incorrect argument" arg 'arg '(a1 a2 ...)))
...))
((arg-and caller arg (a1 a2 ...) ...)
(and (or (symbol? 'arg)
(error "bad syntax" 'arg '(symbol? 'arg)
'(arg-and caller arg (a1 a2 ...) ...)))
(or (a1 a2 ...)
(if (string? caller)
(error caller arg 'arg '(a1 a2 ...))
(error "incorrect argument" arg 'arg '(a1 a2 ...) caller)))
...))))
;; accessory macro for arg-ands
(define-syntax caller-arg-and
(syntax-rules()
((caller-arg-and caller arg (a1 a2 ...) ...)
(and (or (symbol? 'arg)
(error "bad syntax" 'arg '(symbol? 'arg)
'(caller-arg-and caller arg (a1 a2 ...) ...)))
(or (a1 a2 ...)
(if (string? caller)
(error caller arg 'arg '(a1 a2 ...))
(error "incorrect argument" arg 'arg '(a1 a2 ...) caller)))
...))
((caller-arg-and null caller arg (a1 a2 ...) ...)
(and (or (symbol? 'arg)
(error "bad syntax" 'arg '(symbol? 'arg)
'(caller-arg-and caller arg (a1 a2 ...) ...)))
(or (a1 a2 ...)
(if (string? caller)
(error caller arg 'arg '(a1 a2 ...))
(error "incorrect argument" arg 'arg '(a1 a2 ...) caller)))
...))))
(define-syntax arg-ands
(syntax-rules (common)
((arg-ands (a1 a2 ...) ...)
(and (arg-and a1 a2 ...) ...))
((arg-ands common caller (a1 a2 ...) ...)
(and (caller-arg-and caller a1 a2 ...) ...))))
(define-syntax arg-or
(syntax-rules()
((arg-or arg (a1 a2 ...) ...)
(or (and (not (symbol? 'arg))
(error "bad syntax" 'arg '(symbol? 'arg)
'(arg-or arg (a1 a2 ...) ...)))
(and (a1 a2 ...)
(error "incorrect argument" arg 'arg '(a1 a2 ...)))
...))
((arg-or caller arg (a1 a2 ...) ...)
(or (and (not (symbol? 'arg))
(error "bad syntax" 'arg '(symbol? 'arg)
'(arg-or caller arg (a1 a2 ...) ...)))
(and (a1 a2 ...)
(if (string? caller)
(error caller arg 'arg '(a1 a2 ...))
(error "incorrect argument" arg 'arg '(a1 a2 ...) caller)))
...))))
;; accessory macro for arg-ors
(define-syntax caller-arg-or
(syntax-rules()
((caller-arg-or caller arg (a1 a2 ...) ...)
(or (and (not (symbol? 'arg))
(error "bad syntax" 'arg '(symbol? 'arg)
'(caller-arg-or caller arg (a1 a2 ...) ...)))
(and (a1 a2 ...)
(if (string? caller)
(error caller arg 'arg '(a1 a2 ...))
(error "incorrect argument" arg 'arg '(a1 a2 ...) caller)))
...))
((caller-arg-or null caller arg (a1 a2 ...) ...)
(or (and (not (symbol? 'arg))
(error "bad syntax" 'arg '(symbol? 'arg)
'(caller-arg-or caller arg (a1 a2 ...) ...)))
(and (a1 a2 ...)
(if (string? caller)
(error caller arg 'arg '(a1 a2 ...))
(error "incorrect argument" arg 'arg '(a1 a2 ...) caller)))
...))))
(define-syntax arg-ors
(syntax-rules (common)
((arg-ors (a1 a2 ...) ...)
(or (arg-or a1 a2 ...) ...))
((arg-ors common caller (a1 a2 ...) ...)
(or (caller-arg-or caller a1 a2 ...) ...))))
(define-syntax err-and
(syntax-rules ()
((err-and err expression ...)
(and (or expression
(if (string? err)
(error err 'expression)
(error "false expression" 'expression err)))
...))))
(define-syntax err-ands
(syntax-rules ()
((err-ands (err expression ...) ...)
(and (err-and err expression ...)
...))))
(define-syntax err-or
(syntax-rules ()
((err-or err expression ...)
(or (and expression
(if (string? err)
(error err 'expression)
(error "true expression" 'expression err)))
...))))
(define-syntax err-ors
(syntax-rules ()
((err-ors (err expression ...) ...)
(or (err-or err expression ...)
...))))
</pre>
<H1>Copyright</H1>
<p>Copyright (C) Joo ChurlSoo (2004). All Rights Reserved.</p>
<p>
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
</p>
<p>
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
</p>
<p>
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
</p>
<hr>
<address>Editor: <a href="mailto:srfi minus editors at srfi dot schemers dot org">Mike Sperber</a></address>
<!-- Created: Mon Feb 3 14:53:23 MET 2003 -->
<!-- hhmts start -->
Last modified: Sun Jan 28 13:40:36 MET 2007
<!-- hhmts end -->
</body>
</html>