A few improvements for functional programming

[na-sa-do]

I'm writing some functional code and finding myself wanting a few type operators to smooth things over. They could also be used to type Function#apply, Function#call, etc. Since they're pretty closely related I'll just make one suggestion—if that doesn't work out, my bad.

argsof <func>

A tuple for the arguments taken by the function, for use with the spread operator or Function#apply. Using this on a non-function is illegal. If an argument is optional, the type just has | undefined added. (What about rest parameters? Maybe rest parameters could be added to tuples, as a way to override the default behavior of unioning all the member types. But that's a separate suggestion.)

returnof <func>

The type of the function's return value. Using this on a non-function is illegal.

Spread operator in function types

type Arguments = [number, string, number];

function call(...Arguments) {
}

This results in a call which takes a number, a string and a number as arguments. Those arguments aren't actually directly accessible to the function, since they don't have names -- they can be reached from the arguments object.

My main use for all of these is to mimic an existing function type dynamically, like this:

function wrap<T extends Function>(inner: T): T {
    return function(...argsof T): returnof T {
        return inner.call(this, ...arguments);
    };
}

[aluanhaddad]

See also #5453

[mhegazy]

returnof tracked by #6606
argsof most usages should be tracked by #5453 and #12265