Pascal Costanza wrote:

> > I'm not advocating tail-recursion instead of specialized iteration
> > mechanisms closer to the problem domain. I'm just saying tail-
> > recursion code isn't anywhere as low-level as you're making it up to
> > be.
>
> It actually is, and your posting below shows it very nicely.
>
> >> Here is a nice example using loop:
> >>
> >> (loop for (key value) on property-list by #'cddr
> >> unless (member key excluded-keys)
> >> append (list key value)) ; [1]
>
> As a function:
>
> (defun filter (excluded-keys property-list)
> (loop for (key value) on property-list by #'cddr
> unless (member key excluded-keys)
> nconc (list key value)))
>
> > (filter '(c d) '(a 1 b 2 b 3 c 4 d 5 c 6))
> (A 1 B 2 B 3)
>
> The result is a correct property list

Gauche Scheme
(define (remove-props bad-keys prop-list)
(concatenate
(remove (^p (member (car p) bad-keys))
(slices prop-list 2))))

(remove-props '(c d) '(a 1 b 2 b 3 c 4 d 5 c 6))
===>
(a 1 b 2 b 3)

B. Pym wrote:

> Pascal Costanza wrote:
>
> > > I'm not advocating tail-recursion instead of specialized iteration
> > > mechanisms closer to the problem domain. I'm just saying tail-
> > > recursion code isn't anywhere as low-level as you're making it up to
> > > be.
> >
> > It actually is, and your posting below shows it very nicely.
> >
> > >> Here is a nice example using loop:
> > > >
> > >> (loop for (key value) on property-list by #'cddr
> > >> unless (member key excluded-keys)
> > >> append (list key value)) ; [1]
> >
> > As a function:
> >
> > (defun filter (excluded-keys property-list)
> > (loop for (key value) on property-list by #'cddr
> > unless (member key excluded-keys)
> > nconc (list key value)))
> >
> > > (filter '(c d) '(a 1 b 2 b 3 c 4 d 5 c 6))
> > (A 1 B 2 B 3)
> >
> > The result is a correct property list
>
> Gauche Scheme
>
> (define (remove-props bad-keys prop-list)
> (concatenate
> (remove (^p (member (car p) bad-keys))
> (slices prop-list 2))))
>
> (remove-props '(c d) '(a 1 b 2 b 3 c 4 d 5 c 6))
> ===>
> (a 1 b 2 b 3)

Nicolas Neuss wrote:

> > does this look like assembly?
> >
> > (define (! n)
> > (let loop ((x n) (r 1))
> > (if (zero? x) r
> > (loop (- x 1) (* x r)))))
>
> Yes, it does compared with
>
> (defun factorial (n)
> (loop for n from 1 upto n
> and f = 1 then (* f n)
> finally (return f)))

It's shorter using "do".

(define (fac n)
(do ((i 1 (+ 1 i))
(f 1 (* f i)))
((> i n) f)))

(fac 5)
===>
120

Paul Graham:

I consider Loop one of the worst flaws in CL, and an example
to be borne in mind by both macro writers and language designers.

Paul Graham, May 2001:

A hacker's language is terse and hackable. Common Lisp is not.

The good news is, it's not Lisp that sucks, but Common Lisp.