Infer type for generic.

[Strate]

Hi!

Seems that some cases of inferring types does not work:

interface Blabla<T> {
    (): T
}

function some(): Blabla {
    return () => {
        return 123;
    }
}

I got compilation error:

error TS2314: Generic type 'Blabla<T>' requires 1 type argument(s).

Is it possible to infer number type for T?

[ahejlsberg]

No, but you can just omit the type annotation and TypeScript will infer the return type of some to be () => number. That type is structurally compatible with Blabla<number> so you get the same effect:

interface Blabla<T> {
    (): T
}

function some() {
    return () => {
        return 123;
    }
}

var f: Blabla<number> = some();

[Strate]

It would be very great if typescript infer type in this case.
In real life I have a bit more complex example:

interface Action {
  // some properties here
}
interface Dispatch {
    (action: Action): void
}
interface State {
  // some properties here
}
interface Thunk<R> {
    (dispatch: Dispatch, getState?: () => State): R
}

function doAction(): Thunk {
    return (dispatch, getState) => { // dispatch and getState arguments proper typed here
        return 123;
    }
}

without return type annotation I should annotate arguments for returning closure (I use ts with noImplicitAny compiler option). And now I should explicitly write Thunk<number>, but compiler really can infer that type.

[bedorlan]

I had the exact same problem. I solved it like this:

interface Action {
  // some properties here
}
interface Dispatch {
    (action: Action): void
}
interface State {
  // some properties here
}
interface Thunk<R> {
    (dispatch: Dispatch, getState?: () => State): R
}

function doAction() {
    return createThunk((dispatch, getState) => {
        return 123;
    })
}

function createThunk<T>(f: Thunk<T>): Thunk<T> {
    return f
}

Have you found a better way?