Re: Collecting in the opposite order in a CL loop

[Pascal J. Bourguignon]

Sean McAfee <eefacm@gmail.com> writes:

> pjb@informatimago.com (Pascal J. Bourguignon) writes:
>
>> Sean McAfee <eefacm@gmail.com> writes:
>>> (loop for x = num then (/ x 10) until (zerop x) with result = nil do
>>>   (setq result (cons (mod x 10) result))
>>>   finally return result)
>
>> Use push instead of setq cons.
>> Use truncate instead of / for integer division.
>> Use finally (return ...); finally return is ClTl2, not Common Lisp.
>
> Thanks for the tips.  But what's the reason for the last two?  They seem
> equivalent to me, aside from the latter forms having the small advantage
> of brevity over the former.

You expressed a desire to program in a more "common" lisp.
In CL (/ 13 10) --> 13/10,  and in CL finally return is invalid.



>>> Is there an elegant way to build up a list "backwards" using the CL loop
>>> facility?
>
>> Notice that building this list backwards as you want it is wrong:
>>
>> 1234 --> (1 2 3 4)
>>   34 --> (3 4)
>>
>> with the most significant digits in the lowest indexes, you cannot use
>> the list of digits do to anything.
>
> Nothing except what I need it for.  I want to transform my input text in
> chunks of a certain small unit, identified by a regexp, and to do so a
> variable number of units at a time, inserting a space between the
> groups.  The basic outline of my code is as follows:
>
> (defun transform-text (arg)
>   (interactive "p")
>   (save-match-data
>     (loop for count in (digits-of arg) do
>       (loop repeat count do
>         (search-forward-regexp "\\=\\s *\\(etc.etc.\\)")
>         (replace-match (compute-replacement-text (match-string 1)))
>         finally (insert " "))
>       finally (backward-delete-char 1))))
>
> So an argument of 123 to this routine would mean "transform one unit,
> insert a space, transform two more units, add a space, and lastly
> transform three more units."  I need the digits most-significant-first
> because that's the order I typed them in.
>
> Anyway, I like how the collect clause lets me accumulate a return value
> for the loop without having to declare one explicitly, and was hoping a
> similar construction might let me do the same in the correct order for
> this usage.

Well, the most elegant way is often to use a recursive function as I
showed.  Since it is expected that interactive user input won't overflow
the stack, there's no problem in using it.

-- 
__Pascal Bourguignon__