Providing only some types for generic type in typescript

I would like to know if there is a shorthand for specifying only some optional types for generic types in typescript. For example if I have a class with optional types:

class GenericClass<A extends Type1 = Type1, B extends Type2 = Type2, C extends Type3 = Type3>

Then I'd like to define a subclass such as: class Subclass extends GenericClass<TypeB>
, which would be a shorthand for class Subclass extends GenericClass<Type1, TypeB, Type3>, but it doesn't work. Instead it tries to infer TypeB as a subtype of Type1 which gives an error. It is also allowed in this example, however, to leave out Type3 and let typescript infer it. Something like this would be useful for me in defining generic react components, where I want to specify the type of state, but not the props.

So am I correct that all preceding optional types must be provided when specifying an optional type. Or is there a way to do as I am trying?

For optional function arguments you can just specify undefined for the preceding optionals, this doesn't work for generics but I did try, using void instead but that also didn't work. I also tried using a syntax like Subclass extends GenericClass<B = TypeB> but that also doesn't work.

I've seen some suggestions for replacing optional function arguments with an interface, like:

interface Args { a?: number, b?: string, c?: any}
function myFunc(Args) {}

which can then be called like myFunc({b: "value"}); and avoids having to do myFunc(undefined, "value");. This feels like a poor alternative, but maybe it is possible to do something like this for generic types? I'm not sure what that would look like though.

another thing I tried is overloading the type like type GenericClass<B extends Type2> = GenericClass<Type1, B, Type3>. This doesn't work, unless I type it with a different name, like GenericClassB

TypeScript doesn't currently have the feature you're looking for, at least as of TS5.1. Generic type arguments can only be omitted if they have defaults and you are not allowed to skip any. There are a few open feature requests which, if implemented, would probably do what you want:

• There's partial type argument inference as requested in microsoft/TypeScript#26242. Part of that proposal would be to allow a "sigil" or "placeholder" type so you could write something like GenericClass<*, TypeB, *> or GenericClass<_, TypeB, _> or the like.

• There's also named type arguments as requested in microsoft/TypeScript#38913, where you could write GenericClass<B=TypeB>, or as requested in microsoft/TypeScript#54254 where you could write something like GenericClass<B: TypeB> or maybe GenericClass<{B: TypeB}>.

• Finally, the workaround you mention whereby you use a single type parameter constrained to an Args type with all optional properties works except TypeScript is unable to infer from index access types; that is, it can infer A from a value of type A, but it cannot infer T extends {a: any} from a value of type T["a"]. There is an open feature request at microsoft/TypeScript#51612 which would do this, but again, it's not part of the language yet.

There might be some hope for one or both of the most recent two issues mentioned being fixed. In fact there is a pull request at microsoft/TypeScript#53017 which implements the last one, but I don't know if it will be merged. (A much older pull request at microsoft/TypeScript#20126 also implemented it, but it was abandoned.)

But until then you will need to use workarounds.

not sure how you can go about it with classes, I usually just use type and you can do this:

type Tuple3<a,b,c> = [a,b,c]

const t3: Tuple3<number, string, string> = [3, 'apple', 'banana']

type NamedTuple2<a,b> = Tuple3<string,a,b>

const namedT2: NamedTuple2<number, string> = ['fruites', 2,...

Playground Link