How to skip define type on multiple generics class

Question

I have a class with multiple generic properties defined like this:

export class MainClass<
    A = string,
    B = number,
    C = boolean> {
    propA: A
    propB: B
    propC: C
}

It works fine if I fully define 3 types:

let mainClass = new MainClass<string, string, string>

But later I want to create a new instance and only define the 3rd type:

let mainClass2 = new MainClass< , ,custom-type>

Can we omit defining any generic (it gets the default type) and only define the ones we need?

Answer 1

The only way I can think of is to create subclasses that take different type arguments.

I have illustrated your <,,type> example below. The type annotations are only there to show you what you (effectively) get - you don't need to add the annotations in real life here.

class MainClass<A = string, B = number, C = boolean> {
    propA: A
    propB: B
    propC: C
}

class MainClassB<
    C = boolean> extends MainClass<string, number, C> {
}

let example1: MainClass<string, string, string> = new MainClass<string, string, string>();

let example2: MainClass<string, number, number> = new MainClassB<number>();

The basic concept is that the subclass takes whatever combination of type arguments you want, and returns a class with the three properties of MainClass. You can create various combinations if you want to support the various one or two default situations (eliminating the combinations that can be satisfied by the original type argument order).

Full Example

I have jammed a function in that accepts MainClass to show all the resulting types are structurally compatible:

class MainClass<A = string, B = number, C = boolean> {
    propA: A
    propB: B
    propC: C
}

class MainClassC<C> extends MainClass<string, number, C> {
}

class MainClassAC<A, C> extends MainClass<A, number, C> {
}

class MainClassBC<B, C = boolean> extends MainClass<string, B, C> {
}

function processMainClass(input: MainClass) {
    console.log(input.propA, input.propB, input.propC);
}

let a = new MainClass<string>();
processMainClass(a);

let b = new MainClassBC<number>();
processMainClass(b);

let c = new MainClassC<boolean>();
processMainClass(c);

let ab = new MainClass<string, number>();
processMainClass(ab);

let ac = new MainClassAC<string, boolean>();
processMainClass(ac);

let bc = new MainClassBC<number, boolean>();
processMainClass(bc);

let abc = new MainClass<string, number, boolean>();
processMainClass(abc);