Pascal Costanza wrote:

> > I don't need a general purpose transformation, just some guidelines to
> > follow when I see code like this.
>
> General guideline: Look for a solution that uses LOOP. ;)
>
> (defun diff3 (list)
> (let ((avg (loop for element in list
> sum element into sum
> count t into length
> finally (return (/ sum length)))))
> (loop for element in list
> collect (- element avg))))

Shorter and Lispier.

Gauche Scheme:

(define (diff lst)
(let* ((len 0)
(sum (fold
(lambda (n s) (set! len (+ 1 len)) (+ n s))
0 lst))
(avg (/ sum len)))
(map (cut - <> avg) lst)))

(diff '(2 3 4))
===>
(-1 0 1)

(diff '(2 4 9))
===>
(-3 -1 4)

"Robert L." <No_spamming@noWhere_7073.org> writes:

> Gauche Scheme:
> (define (diff lst)
> (let* ((len 0)
> (sum (fold
> (lambda (n s) (set! len (+ 1 len)) (+ n s))
> 0 lst))
> (avg (/ sum len)))
> (map (cut - <> avg) lst)))

Ugh! Just find the sum and the length using two passes over the list.
The Lisp list is already in memory so I'd want to see a benchmark before
believing that two passes are slower in a given app. The reason for the
complicated fold in Haskell is that the list can be lazily generated, so
using a single pass can dispose of the elements once they are summed,
instead of building up a potentially large list in memory.

Anyway, the Scheme version is repulsive even if you want to do just one
pass. Try:

(define (diff lst)
(define (sumlen lst sum len)
(cond ((nil? lst) (list sum len))
(#t (sumlen (cdr lst) (+ sum (car lst)) (1+ len)))))
(let* ((xy (sumlen lst 0 0))
(sum (car xy))
(len (cadr xy))
(avg (/ sum len)))
(map (lambda (a) (- a avg)) lst)))