Learning Lisp in Linux?

[B. Pym]

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.

(loop for (key value) on property-list by #'cddr
unless (member key excluded-keys)
append (list key value)) ; [1]

(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]

Post by B. Pym

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.

(loop for (key value) on property-list by #'cddr
unless (member key excluded-keys)
append (list key value)) ; [1]

(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)

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.