>> R5RS doesn't specify this kind of syntax (nor Chicken supports it):
>>
>> (let* loop ((a <init>) (b a))
>> <body>)
>>
>> To me it seems a missing piece of syntax. Am I wrong?
>
> I've missed it occasionally as well, but I'm not sure it's *that* useful.
Of course that's something we all can live without, but let me expose
a concrete example just for reference.
Let's say I want to traverse a string (or a vector). A nice way to
write that is:
(let loop ((i 0) (ch (string-ref buf 0)))
(do-something)
(if (some-condition-is-true)
(loop (+ i 1)
(string-ref buf (+ i 1)))))
So far so good... well, almost. If you need to change the starting
position (0) you have to remeber to change it in two locations. But
this is still a minor annoyance.
Now, let's suppose the starting position is not a literal value but
the result of an evaluation:
(let loop ((i (some-function)) (ch (string-ref buf (some-function))))
(do-something)
(if (some-condition-is-true)
(loop (+ i 1)
(string-ref buf (+ i 1)))))
This is unsatisfactory and might not be even viable if some-function
can't be evaluated twice (e.g. some-function = random).
So writing down the options, we have:
(let* loop ((i (random N)) (ch (string-ref buf i)))
(do-something)
(if (some-condition-is-true)
(loop (+ i 1)
(string-ref buf (+ i 1)))))
vs.
(let ((start (random N)))
(let loop ((i start) (ch (string-ref buf start)))
(do-something)
(if (some-condition-is-true)
(loop (+ i 1)
(string-ref buf (+ i 1))))))
vs.
(let ((ch '()))
(let loop ((i (random N)))
(set! ch (string-ref buf i))
(do-something)
(if (some-condition-is-true)
(loop (+ i 1)))))
Now, I guess each of us has its own preference but I don't see the
point to rule out the first option. As I already said defining a let*
syntax but not a named version of it give me a sense of
incompleteness. :-(
Ciao,
Michele
_______________________________________________
Chicken-users mailing list
[email protected]
https://lists.nongnu.org/mailman/listinfo/chicken-users
