Proposal for Parameter Type Inference for immediately invoked anonymous functions

[aersam]

I have to target ES3/ES5 and I quite often find myself writing something like this:

for (let roleType of this.RoleTypes) {
    ((roleType) => {
        //roleType is of type any, but should be typeof "outer" roleType
            observable.subscribe((nv) => {//Do something with it in a function
                this.afunction(nv, roleType2.RoleTypeID);
            });                                    
    })(roleType); //Protect variable scope
}

or something like this:

(($) => {
    //Why not infer $ as typeof jQuery?
})(jQuery);

I think it was reasonable to infer the parameter type from its only usage here

[RyanCavanaugh]

How do we avoid making this circular? We already contextually type function arguments by the type of their corresponding parameters.

(function(x) {

})(t => t);

Here, to get the type of x, we would (under the proposal) get the type of t => t. But that type is already dependent on the type of x, so we have to get the type of x, which involves us getting the type of t => t, and around and around we go.

[aersam]

I didn't think of that... The only option would be to only infer x if the parameter value is not inferred which seems to be complicated and not really foreseeable...

[DanielRosenwasser]

@RyanCavanaugh and I have talked about this offline. It is rather difficult to reason about precisely what you want to happen, but I think we can at least give some decent inference here. Also, I'd argue this is sufficiently prominent in JS code that we should consider it more.

For now you can always give a type annotation on the TS side. In JS, it seems like JSDoc comments on function expressions don't get picked up though?

[michaelmesser]

Flow can do it