Support shorthands when specializing generic functions at the type level

Suggestion

🔍 Search Terms

• shorthands
• generic
• specialization

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Basically support for syntax like this:

const someObject = {
  foo<number>,
  bar<string>
};

One can already specialize a generics cheaply like this:

const specializedFoo = foo<number>;

But this kind of specialization doesn't work well with shorthand syntax, so rather than writing what I suggested one has to write the more verbose:

const someObject = {
 foo: foo<string>,
 bar: bar<number>
};

Basically imo this convenience feature for specializing a generic should compose with other existing convenience syntax.

📃 Motivating Example

I have a little parser generator, problem is for many grammars the generic <T> type that most exported composable functions accept is inferred in incompatible ways between usages of those composable functions throughout a grammar, so having a way to return specialized functions, where the value of the type has been already been provided consistently for all those functions, would simplify some scenarios a lot.

But I can't write something like this:

const grammar = <T, U> ( fn: ({ match: match<T>, and: and<T>, ... }) => U ): U => {
	return fn ({
        match<T>,
        and<T>,
        ...
    });
};

I have to write this:

const grammar = <T, U> ( fn: ({ match: match<T>, and: and<T>, ... }) => U ): U => {
	return fn ({
        match: match<T>,
        and: and<T>,
        ...
    });
};

Arguably this kind of syntax should be supported for types also, so that I could even just write this, ideally:

const grammar = <T, U> ( fn: ({ match<T>, and<T>, ... }) => U ): U => {
	return fn ({
        match<T>,
        and<T>,
        ...
    });
};

💻 Use Cases

Simplifying the code in the example above.

Non viene indicato alcun file sorgente TypeScript, test o punto di ingresso; inizia esaminando gli esempi abbreviati proposti e il caso d’uso grammex collegato. Il lavoro sarà completo quando si sarà raggiunto un accordo su sintassi e semantica, sarà stato implementato il supporto per le funzioni generiche specializzate nelle forme abbreviate di oggetti e tipi e sarà stata aggiunta la copertura per gli esempi.