# The Sweetest Sugar

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 ) {
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 ) {
body = cddr(expr);
if ( pairQ(name) ) {
expr = list(s_define, car(name), cons(s_lambda, cons(cdr(name), body)));
goto again;
} else {
}
}
...
}
```

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!!