Use extends on a variable declaration

[gincher]

Search Terms

extends, generic

Suggestion

Add self extends as a possible type for a variable, which acts like extends in generic - typechecks, but not sets a type.

Eg:

// Invalid
const func: self extends Function = "hello"; 

// Valid
const obj: self extends Object = {firstName: "John", lastName: "Doe"}; 
// typeof obj will return {firstName: string, lastName: string}

Use Cases

I want to extend Jest's matchers. Jest's website suggests duplicating code - creating an interface to extend the matchers interface, and separately, extend the matchers themselves.

What I did is create a function with a generic parameter that returns itself, and the generic is required (using <T extends ...>) to be a record with a function that returns Jest's CustomMatcherResult, which is to enforce the typing required for expect.extend(). Below, I extended Jest's Matchers interface with the object (after modifying it).

Examples

Currently can be achieved by:

// The function will simply return the first argument.
const PermissionExtends = <T extends Record<string, {guest: boolean, user: boolean, admin: boolean>}>(v: T) => v;
const permissions = PermissionExtends({
    readMessage: {guest: true, user: true, admin: true},
    writeMessage: {guest: false, user: true, admin: true},
    deleteMessage: {guest: false, user: false, admin: true}
});
type Permissions = keyof typeof permissions;
// Permissions = 'readMessage' | 'writeMessage' | 'deleteMessage'

Ideally:

const permissions: self extends Record<string, {guest: boolean, user: boolean, admin: boolean> = {
    readMessage: {guest: true, user: true, admin: true},
    writeMessage: {guest: false, user: true, admin: true},
    deleteMessage: {guest: false, user: false, admin: true}
};
type Permissions = keyof typeof permissions;
// Permissions = 'readMessage' | 'writeMessage' | 'deleteMessage'

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 isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[DanielRosenwasser]

I think this is a duplicate of #7481, but restricted to binding declarations.

[gincher]

@DanielRosenwasser I don't agree.

Correct me if I'm wrong, but it seems like #7481 OK with overriding the type, as asType<MyComponentActions>({selectSomething}) will have the type of MyComponentActions.

Not only that, but what I'm asking is the opposite.
If I were to use my suggestion with the example in the second reply in #7481,

const mapDispatchToProps: self extends MyComponentActions = {selectSomething};

It should throw an error, as the return type is not void, but Promise. Also, the type of mapDispatchToProps will be {selectSomething: (id: string) => Promise<void>} and not {selectSomething: (id: string) => void} as it would be in asType<MyComponentActions>({selectSomething})

[RyanCavanaugh]

Still marking as duplicate since OP isn't something we would do (type space syntax should be valid in all type locations, but this would be constrained to declaration positions). The use cases here are still fundamentally the same as #7481; I think you've misunderstood the linked issue.

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.