Stumbled upon this curious syntax in a talk by Sussman:

(define ((f x) y) ...)

In standard Scheme:

(define (name . args) . body)

means:

(define name (lambda args . body))

In the past, I’ve implemented `(define name . body)`

syntax in a few evaluators as:

// Pseudo-C eval(env, expr) { ... if ( car(expr) == s_define ) { name = cadr(expr); body = cddr(expr); if ( pairQ(name) ) { return define(env, car(name), lambda(env, cdr(name), body)); } else { return define(env, name, car(body)); } } ... }

I was so wrong… the expansion of `define`

should ** recur** if name is a pair:

eval(env, expr) { again: ... if ( car(expr) == s_define ) { name = cadr(expr); body = cddr(expr); if ( pairQ(name) ) { expr = list(s_define, car(name), cons(s_lambda, cons(cdr(name), body))); goto again; } else { return define(env, name, cadr(body)); } } ... }

Example:

(define (((sequence op) start constant) . rest) (let ((result start)) (set! start (op start constant)) result)) (define arithmetic (sequence +)) (define geometric (sequence *)) (map (arithmetic 1 3) '(1 2 3 4)) ;; => (1 4 7 10) (map (geometric 1 2) '(1 2 3 4)) ;; => (1 2 4 8)

Expansion:

(define (((sequence op) start constant) . rest) (let ((result start)) (set! start (op start constant)) result)) => (define ((sequence op) start constant) (lambda rest (let ((result start)) (set! start (op start constant)) result))) => (define (sequence op) (lambda (start constant) (lambda rest (let ((result start)) (set! start (op start constant)) result)))) => (define sequence (lambda (op) (lambda (start constant) (lambda rest (let ((result start)) (set! start (op start constant)) result)))))

*Sweet!!*