Generics; ReturnType<Foo> != ReturnType<typeof foo>

TypeScript Version: Version 2.9.0-dev.20180516

Search Terms: generic function returntype

I couldn't think of a good title for this,

Code

type Delegate<T> = () => T;

function executeGeneric<
    X,
    DelegateT extends Delegate<X> 
>(delegate: DelegateT): ReturnType<DelegateT> {
    //Type 'X' is not assignable to type 'ReturnType<DelegateT>'.
    const x: ReturnType<typeof delegate> = delegate();
    //Type 'X' is not assignable to type 'ReturnType<DelegateT>'.
    const y: ReturnType<DelegateT> = delegate();
    //Type 'X' is not assignable to type 'ReturnType<DelegateT>'.
    return delegate();
}

Expected behavior:

Return successfully.

Intuitively, to me,

delegate is of typeDelegateT.
ReturnType<DelegateT> and ReturnType<typeof delegate> should be the same

However,

Actual behavior:

Type 'X' is not assignable to type 'ReturnType<DelegateT>'.

Playground Link: Here

Related Issues:

ReturnType<DelegateT> and ReturnType<typeof delegate> are the same, and both are not assignable from DelegateT, you can not assign a function that returns a string to a string.

Isn't delegate of type DelegateT and delegate() of type ReturnType<DelegateT>?

delegate() is not supposed to be X, it could be X but it could also be something that extends X

But it's saying that delegate() is of type X when it shouldn't be (intuitively, to me, anyway)

ah. sorry about that, did not see the call there.. yes. you are right about that.

I don't know why I didn't think of this shorter example.

function executeGeneric<
    DelegateT extends () => number
>(delegate: DelegateT): ReturnType<DelegateT> {
    //Type 'number' is not assignable to type 'ReturnType<DelegateT>'.
    const x: ReturnType<typeof delegate> = delegate();
    //Type 'number' is not assignable to type 'ReturnType<DelegateT>'.
    const y: ReturnType<DelegateT> = delegate();
    //Type 'number' is not assignable to type 'ReturnType<DelegateT>'.
    return delegate();
}

Playground

This is a suggestion, not a bug.

Direct function calls are evaluated according to their constraints. This is generally desirable:

function invokeAndMultiply<T extends () => number>(a: T, b: T) {
    // OK or no?
    return a() * b();
}

In general you cannot multiply arbitrary types, so this example would be an error if we forced deferral of a()'s return type to ReturnType<T>.

It'd be a pretty substantial complexity trade-off to start deferring the return type evaluation, since anything you do with a generic type constrained to a function type would then need follow-on special handling.

Let's say we defer the evaluation of a()'s return type.

In this example, even if TS hasn't evaluated what ReturnType<T> is,
it should know that ReturnType<T> extends number.

And because of that, it should allow their multiplication, because you can multiply two number types and ReturnType<T> is a subtype of number; the result being just number.

My example is simple. So, deferring the evaluation of the type is also not an issue.

In general, if given this,

function foo<F extends () => T> (f : F) : ReturnType<F> {
    /*
        Current behaviour:
        `value` is of type `T`.

        Proposed behaviour:
        `value` is of type `(T & ReturnType<F>)`,
        where evaluation of `ReturnType<F>` is deferred.
    */
    const value = f();
    //Right now, we can do all things `T` can do because `value` is subtype of `T`.

    /*
        This should now work because `(T & ReturnType<F>)` extends `ReturnType<F>`.
    */
    return value;
}

Actually, I don't know anything about the compiler internals but I'm quite pleased with the above suggestion =x
Is there anything about it that stands out as potentially dangerous?

What additional feedback would be useful on this request? I filed a duplicate in #47900.

My real-world use case boils down to this:

interface IReadable {
  read(): number | string;
}
class Reader<R extends IReadable> {
  constructor(private _reader: R) {}

  read(): ReturnType<R["read"]> {
    return this._reader.read();  // error :(
  }
}

let num = new Reader({ read: () => 1 }).read();  // inferred as number
let str = new Reader({ read: () => "1" }).read();  // inferred as string

Navigation Menu

Repository navigation

Generics; ReturnType<Foo> != ReturnType<typeof foo> #24277

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Generics; ReturnType<Foo> != ReturnType<typeof foo> #24277

Description

Activity

mhegazy commented on May 21, 2018

AnyhowStep commented on May 21, 2018

mhegazy commented on May 21, 2018

AnyhowStep commented on Nov 18, 2018

RyanCavanaugh commented on Mar 13, 2019

AnyhowStep commented on May 24, 2019

jtbandes commented on Feb 16, 2022

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions