| This is tricky in the comment format but here goes. Let us declare that a function is passed exactly one value, and that it passes exactly one value to the chosen continuation. However that does not imply that it takes exactly one named argument. (lambda a ...) Binds that one value to a. If you pass it a list, that's a variadic function. (lambda (a b) ...) Requires the argument be a list of two values and binds the elements to a, b. (lambda (a (b c) d) ...) Likewise, except it's now a list of three things where element 1 must be a list of two things. The corresponding return/continuation part then looks like (let a (foo) (b c) (bar) ...) where the let binds whatever foo returned to a, binds a list of length 2 from bar and so forth. This works really nicely with static typing in the absence of function currying. Destructuring bind on function arguments is somewhat common. In lisp, you have to work out what let returns when the binding doesn't typecheck at runtime and that's a bit of a mess. In SML the construct typechecks at compile time but I can't work out how to reconcile it with currying. Parameter trees, the (a (b) c) idea, I first saw in kernel. I don't remember if it went as far as let binding / destructuring on the continuation invocation. I like the destructuring syntax more than currying so haven't put as much thought into providing both as the latter might deserve. |