Re: Understanding dotimes skipping by 2

[Joost Kremers]

On Fri, Sep 28 2018, Van L wrote:
> > the following code snippet is as follows:
> > (setq l `(1 2 3 4 5 6 7 8 9 0))
> > (1 2 3 4 5 6 7 8 9 0)
> > ;; iterate through a list two elements at a time
> > (let ((x 0))
> >  (dotimes (/ (length l) 2)
> >    (progn
> >      (insert (format "%s %s, " (nth x l) (nth (+ x 1) l)))
> >      (setq x (+ x 2)))))
> >
> > ;; and below are the results
> > 1 2, 3 4, 5 6, 7 8, 9 0, nil nil, nil nil, nil nil, nil nil, 
> > nil nil, 2
> >
> > I'm confused about the output (nil etc...)which follow the 
> > expected numbers. 
> > could someone explain?
>
> The first argument to dotimes needs a symbol to value binding at 
> a guess.

There is, actually... The first argument of `dotimes' should be a 
list of three elements: a symbol to be bound as a list variable, 
an expression to calculate the upper bound of the loop and an 
expression to be returned as the final result. 

In the OP's code, the first element of the list is `/', so that 
gets bound as list variable. (Yes, in Lisp that's possible).

The second element is `(length l)', which returns the value 10, so 
that the loop is executed 10 times. The first five of these, `(nth 
x l)' and `(nth (+ x 1) l)' refer to elements in the list, after 
that, the return value of both function calls in `nil', hence the 
list of nil's in the output.

The third element of the first argument of `dotimes' here is the 
value 2, so that is returned as the final result, which is why the 
`2' appears at the end.

> The character l and 1 are too easy to confuse in reading you 
> might want to avoid that.
>
> (setq q '(1 2 3 4 5 6 7 8 9 0))
> (let ((x 0))
>   (dotimes (i (/ (length q) 2))
>     (progn
>       (insert (format "%s %s, " (nth x q) (nth (+ x 1) q)))
>       (setq x (+ x 2)))))
>
> ; 1 2, 3 4, 5 6, 7 8, 9 0, 

A few comments:

- `progn' really isn't necessary here, so should be avoided.
- `dotimes' isn't really appropriate here, either, because you're 
 not doing anything with the loop variable `i'. A `while' loop 
 would be more idiomatic:

```
(let ((x 0))
 (while (< x (length l))
   (insert (format "%s %s, " (nth x l) (nth (1+ x) l)))
   (setq x (+ x 2))))
```

- Note also the use of `(1+ x)' instead of (+ x 1). Though 
 honestly I don't know what the difference really is. It's just 
 the idiom I'm used to.

HTH

--
Joost Kremers
Life has its moments