Currying RFC

Automatic currying of all functions and closures
This isn't very detailed. It should at least vaguely the discuss the mechanics of 'turned into a closure', I would imagine that unboxed closures with by-value captures come into play and are worth mentioning, as would exhibiting some code transformations into explicit closure form, e.g. `foo(a, b)(c, d);` becoming `(|x, y| foo(a, b, x, y))(c, d)`.

Also, what about efficiently handling static vs. dynamic function calls? i.e. `let f: &FnTrait = if ... { some_2_arg_closure } else { some_other_2_arg_closure }; let g = f(1); g(2)` would presumably need to capture `f` into the `g` closure somehow, but would it capture by-value or by-reference? (Sometimes it will need to be by-value, e.g. when currying [a `FnOnce` closure](http://doc.rust-lang.org/master/std/ops/trait.FnOnce.html), sometimes it will need to be by-reference, since [it is possible](http://doc.rust-lang.org/master/std/ops/trait.Fn.html) to continuing using `f` later.) But, then, it would be inefficient (at compile time) to capture the function explicitly for static function calls (like calling `add(1, 2)` above), likely bloating our IR significantly and slowing LLVM to a creep (this is an implementation detail but it'd be nice to mention it, since compile times are very user-visible).

Lastly, what about more interesting curries:

- methods
- overloaded call operator (this definitely needs discussing since it is how unboxed closures work)