blob: a3858906cbe057a8799aa1b5d27317417cd4b92b (
plain)
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
|
# Lisp For Schemers
## Tags
* type: documentation
* keywords: LISP, Scheme, iota, loop, iterate
## iota
### In Scheme
```
scheme@(guile-user)> (iota 12)
$1 = (0 1 2 3 4 5 6 7 8 9 10 11)
```
### In Common Lisp
The Common Lisp loop macro is not without its problems. See the paper "Don't Loop, Iterate" linked below. The paper compares different iteration mechanisms and promotes the author's own iterate macro. Personally, I think Scheme's approach with SRFI-1 is much cleaner. Explicit iteration is often distracting. Recursion is often what the programmer really wants.
=> https://common-lisp.net/project/iterate/doc/Don_0027t-Loop-Iterate.html Don't Loop, Iterate
```
CL-USER: (loop for i below 12 collect i)
(0 1 2 3 4 5 6 7 8 9 10 11)
CL-USER: (macroexpand '(loop for i below 12 collect i))
(BLOCK NIL
(LET ((I 0))
(DECLARE (IGNORABLE I)
(TYPE (AND NUMBER REAL) I))
(SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD (#:LOOP-LIST-HEAD-493
#:LOOP-LIST-TAIL-494)
(TAGBODY
SB-LOOP::NEXT-LOOP
(WHEN (>= I '12) (GO SB-LOOP::END-LOOP))
(SB-LOOP::LOOP-COLLECT-RPLACD
(#:LOOP-LIST-HEAD-493 #:LOOP-LIST-TAIL-494) (LIST I))
(SB-LOOP::LOOP-DESETQ I (1+ I))
(GO SB-LOOP::NEXT-LOOP)
SB-LOOP::END-LOOP
(RETURN-FROM NIL
(SB-LOOP::LOOP-COLLECT-ANSWER #:LOOP-LIST-HEAD-493))))))
T
```
#### Using iota from the alexandria library with GNU/Guix:
```
guix shell sbcl sbcl-alexandria rlwrap -- rlwrap sbcl
```
```
CL-USER: (asdf:make "alexandria")
CL-USER: (in-package :alexandria)
CL-USER: (alexandria:iota 12)
(0 1 2 3 4 5 6 7 8 9 10 11)
```
=> https://common-lisp.net/project/alexandria/ alexandria
|
