Make a method of a generic interface A<T> available only if T is of a certain type

[thorn0]

Let's look at the library Lodash for the example. Values of any type can be wrapped in _:

_({ a: 1 })
_([1,2,3])
_(x => x * x)

However, not all the methods of the wrapper make sense for any type of the wrapped value. For example, calling _(z),memoize() makes sense only if z is a function. So let's try to create a type definition for this situation:

interface Lodash {
    <T>(value: T): LodashWrapper<T>;
}
interface LodashWrapper<T> {
    memoize(): LodashWrapper<T>;
}

AFAIK for now it's not possible to write such a constraint for memoize that a call to it will type-check only when T is a function. Is it going to be possible in the future versions? Is there already an issue for this?

[DanielRosenwasser]

You could make a subclass of LodashWrapper

interface LodashFunctionWrapper<T> extends LodashWrapper<T> {
    memoize(): LodashFunctionWrapper<T>;
}

and add an overload whose parameter is constrained to functions

interface Lodash {
    <T extends Function>(x: T): LodashFunctionWrapper<T>;
}

This is already done to some extent in DefinitelyTyped's declaration file for lodash.

By the way, while I can help out with this now, in the future you should really post questions like this to StackOverflow or our Gitter room.

Hope that helps!

[thorn0]

I posted on SO, but didn't get an answer. And Lodash is just for example. My question is about a specific language feature, that's why I decided that it's okay to write here.

[thorn0]

And we can get LodashWrapper<Function> not only from a call to _. So we'll have to add an overload to all the other functions that return a wrapper if we use this approach.

[thorn0]

In the extreme, this feature could allow overloads like these:

interface Foo<T> {
    bar(): string if T extends Function;
    bar(): number; // otherwise
}

[thorn0]

Turns out there is already an issue for this: #1290.