The Great Debate

(define (f x)
  ...)

or

(define f (lambda (x)
  ...)

both

/thread

DEFMACRO *SHOVES LEGO BLOCKS UP MY NOSE*


function f(x) {
    ...
}
or

var f = function(x) {
    ...
}

Scheme's syntactic sugar for function definitions is quite brilliant because not only does the function definition match the function call (i.e. (define (f x) ...) => (f x) in Scheme vs. (defun f (x) ..) => (f x) in Common Lisp), but if implemented correctly if can be layered to create simplified higher-order functions.

]=> (define ((make-adder x) y)
      (+ x y))
make-adder
]=> (define add-3 (make-adder 3))
add-3
]=> (add-3 4)
7

>>5
Nice idea. I should ass something like (makeAdder X) Y = X+Y to Symta.

>>6
I should add
self fix.

>>5
babby's first currying

>>6
What's cool is that it's not even an idea really, it's just a side-effect.

All that needs to implemented is (define var val). Then have a macro that expands (define (func . args) body) to (define func (lambda args body)). Then the following expansion is automatic:

(define (((f x) y) z) ...)
(define ((f x) y) (lambda (z) ...))
(define (f x) (lambda (y) (lambda (z) ...)))
(define f (lambda (x) (lambda (y) (lambda (z) ...))))

Some implementations like chibi-scheme however evaluate function definitions differently than variable definitions, so it doesn't work.