The field of a generic is omitted for the function parameter but should be addible

[chrissisura]

Suggestion

🔍 Search Terms

Generics
Narrow Extension

✅ Viability Checklist

My suggestion meets these guidelines:

• 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 feature would agree with the rest of TypeScript's Design Goals.

• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)

⭐ Suggestion

It would be really nice if you can extend an object with one/selection of keys, in which the types of that keys don't get extended.
The problem with this extension is, that it doesn't allow for a pipe, where you omit some part of it, as it gets added in that pipe with the correct type (e.g. string), but as the generic could be an extension of string you can no longer put it back together.
Maybe there is a workaround for this, but I couldn't find anything online

📃 Motivating Example

export class TemplateFormatter<TemplateInput> {
  bar(templateInput: TemplateInput): void {
    console.log(templateInput)
  }
}

const foo = <
  T extends NARRORTYPE {a: string}
>(
  b: TemplateFormatter<T>
) => (
  payload: Omit<T, 'a'>
): void => {
  const a = 'someString'
  b.bar({ ...payload, a })
}

💻 Use Cases

This would allow for some really nice currying and pipes, in which objects can be put together nicely with good levels of abstractions.

[RyanCavanaugh]

Some examples of legal and nonlegal calls to foo would provide a ton of context. What is the intended interpretation of NARRORTYPE ?

[chrissisura]

Intended interpretation of NARROWTYPE

T should have a field a with the type string. The way typescript extends this field a it can have any extension of string, but there should also be a way to match exactly that type.

The reason I want to have a type variable is so that I can use a specific version of my TemplateFormatter, so that I can infer the type of the payload variable.

Examples for foo calls

legal:

const foobar = foo(new TemplateFormatter<{a: string, b: number}>())
const b = 5
foobar(b)

nonlegal:

foo(new TemplateFormatter<{b: number}>())
foo(new TemplateFormatter<{a: number, b: string}>())
foo(new TemplateFormatter<{a: Extends<string>, b: number}>())

[RyanCavanaugh]

const foobar = foo(new TemplateFormatter<{a: string, b: number}>())
const b = 5
foobar(b)

Why would this be legal? Do you mean foobar({ b }) ? What is Extends<string> ?

It seems like this does what you want:

const foo2 = <T,>(b: TemplateFormatter<T & { a: string }>) => (payload: T): void => {
  const a = 'someString'
  b.bar({ ...payload, a })
}