Default method generic doesn't apply from class generic

[cajoy]

Code

class TestClass<T_MODEL = any> {
    create<T_DATA = T_MODEL>(data: T_DATA) {
        // todo
    }
}

const testString = new TestClass<string>()

testString.create(1) // Ok, but should be error
testString.create<number>(1) // Ok

const testNumber = new TestClass<number>()

testNumber.create(1) // Ok

Expected behavior:

By method default generic should use generic from the class

Actual behavior:

while it ignores default value: create<T_DATA = T_MODEL> and applies any

[ghost]

A default for a type parameter in a function only applies if a type can't be inferred. (Note that it's not using any, it's using number, which can be inferred from the argument.) If you want T_DATA to always be T_MODEL, just replace it with that to have a non-generic signature.

[cajoy]

I am building REST api layer.. but data could be different and response could be different for the same method.

So what I want is to define default type of request and type of response.

But sometimes there is a need of overwriting it... I can create custom method to handle it but thought I can do it just with generics as everything else is the same

[ghost]

So, you want a parameter that's not T_MODEL to be allowed, but only if the user supplies an explicit type argument? I don't think that's something we support; you can just add a second method createWithUnusualData like you said, or just allow any data in the original method.

[cajoy]

I see.. basically it is not possible right now,

here is my definitions to illustrate what I mean:

export declare class RestApi<T_MODEL = any, T_MODEL_LIST = T_MODEL[]> extends Api {
    create<T_RESPONSE = T_MODEL, T_REQUEST = T_MODEL>(data: T_REQUEST, options?: any): Promise<T_RESPONSE>;
    update<T_RESPONSE = T_MODEL, T_REQUEST = T_MODEL>(id: number | string, data: T_REQUEST, options?: any): Promise<T_RESPONSE>;
    findById<T_RESPONSE = T_MODEL>(id: string | number, options?: any): Promise<T_RESPONSE>;
    findAll<T_RESPONSE = T_MODEL_LIST>(options?: any): Promise<T_RESPONSE>;
    find<T_RESPONSE = T_MODEL_LIST>(params: Object, options?: any): Promise<T_RESPONSE>;
    updateAttributes<T_RESPONSE = T_MODEL, T_REQUEST = T_MODEL>(id: number | string, data: T_REQUEST, options?: any): Promise<T_RESPONSE>;
    destroy<T_RESPONSE = T_MODEL>(id: number | string, options?: any): Promise<T_RESPONSE>;
}

So I define instance like

const api = new RestApi<string>()

then I can do type-checking like:

api.create('string') //ok
api.create(11) // also ok, while shouldn't be
api.create<number>(11) // also ok but no type-checking as I understand

[ghost]

There's still type-checking even if you provide explicit type arguments. So api.create<number>("") would fail. The only difference explicit type arguments make is that we don't bother with type inference.

[mhegazy]

If you want to do both, verify an upper bound, and set a default, use extends T = T.. e.g.:

class TestClass<T_MODEL = any> {
    create<T_DATA extends T_MODEL = T_MODEL>(data: T_DATA) {
        // todo
    }
}

this will give an error on both:

testString.create(1) ;
testString.create<number>(1);

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.