From Newsgroup: comp.lang.scheme

Frode Vatvedt Fjeld wrote:

Scheme
(define vector-fill!
(lambda (v x)
(let ((n (vector-length v)))
(do ((i 0 (+ i 1)))
((= i n))
(vector-set! v i x)))))

Python
def vector_fill(v, x):
for i in range(len(v)):
v[i] = x

To me the Python code is easier to read, and I can't possibly fathom
how somebody could think the Scheme code is easier to read. It truly boggles my mind. [..]

The scheme example can only have been written by someone who is on the
outset determined to demonstrate that sexp-syntax is complicated. This
is how I'd write it in Common Lisp:

(defun vector-fill (v x)
(dotimes (i (length v))
(setf (aref v i) x)))

As you can see, it matches the python example quite closely.

Why would any human want to match Python?

Gauche Scheme

(vector-fill! vec 99)

(vector-map! (constantly 88) vec)


Multiply each element by 2:

(vector-map! (cut * 2 <>) vec)

Sum the elements in the vector.

(use scheme.vector)
(vector-fold + 0 vec)

Another way to sum.

(use gauche.sequence)
(fold + 0 vec)

Make a list containing the positive numbers in the vector.

(use gauche.sequence)
(filter positive? vec)

Find location of first negative number.

(use scheme.vector)
(vector-index negative? vec)
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.scheme

Pascal Costanza wrote:

What about dealing with an arbitrary number of filters?

(defmacro predicate-collect (list &body predicates)
(let ((collectors (mapcar (lambda (predicate)
(declare (ignore predicate))
(gensym "COLLECT"))
predicates))
(collect-t (gensym "COLLECT")))
`(with-collectors (,@collectors ,collect-t)
(dolist (l ,list)
(cond ,@(mapcar (lambda (predicate collector)
`((funcall ,predicate l) (,collector l)))
predicates collectors)
(t (,collect-t l)))))))

An example:

(predicate-collect '(-5 -4 -3 -2 -1 0 1 2 3 4 5)

(function evenp)
(lambda (n) (< n 0))
(lambda (n) (> n 3)))
(-4 -2 0 2 4)
(-5 -3 -1)
(5)
(1 3)

I use the list collector macros by Tim Bradshaw here - see http://www.tfeb.org/lisp/hax.html#COLLECTING

Gauche Scheme

(define (multi-partition the-list . predicates)
(if (null? predicates)
(list the-list)
(receive (yes no)
(partition (car predicates) the-list)
(cons yes (apply multi-partition no (cdr predicates))))))

(multi-partition '(-5 -4 -3 -2 -1 0 1 2 3 4 5)
even?
(is < 0)
(is > 3))

((-4 -2 0 2 4) (-5 -3 -1) (5) (1 3))

Given:

(define-syntax is
(syntax-rules ()
[(is x)
(lambda (y) (equal? y x))]
[(is compare x)
(lambda (y) (compare y x))]
[(is key compare x)
(lambda (y) (compare (key y) x))]))
--- Synchronet 3.22a-Linux NewsLink 1.2