Generic constraint of the form `<T extends E>` where `E` is an `enum`?

If you don't need the type of T in your function, then you are right is doesn't need to be generic.

However, in the file you linked the type is used within the class.

Here's the relevant bits, with other stuff trimmed away:

abstract class ComputedEditorOption<K1 extends EditorOption, V> implements IEditorOption<K1, V> {

    public readonly id: K1;

    constructor(id: K1, deps: EditorOption[] | null = null) {
        this.id = id;
        //...
    }
}

This says that an id of type EditorOption is passed to the constructor. This is saved in the generic class type K1. Later when you access the id property, it will return the same enum option that was passed to the constructor. This requires generics in order to capture a subtype of an enum (a specific value of that enum), and use it in the return value of that function, or the instance of a class.

To clarify with your own example:

function f1(arg: MyEnum): { id: MyEnum } {
    return { id: arg }
}

const a1 = f1(MyEnum.A) // Type: MyEnum
const b1 = f1(MyEnum.B) // Type: MyEnum

When you type the argument as MyEnum here, you can't use the enum that was provided in the return type, so the best you can do is type the return value as MyEnum, because you can't know which value of that enum was provided.

But when you use a generic:

function f2<T extends MyEnum>(arg: T): { id: T } {
    return { id: arg }
}

const a2 = f2(MyEnum.A) // Type: MyEnum.A
const b2 = f2(MyEnum.B) // Type: MyEnum.B

Now you can use the exactly provided type of the argument in the return type.

This is, more or less, what the code you linked is doing.

Playground

If a type extends an enum, it means that type can be:

• one specific value of the enum
• some subset of values of the enum
• all possible values of the enum

Let's say that our enum has three values:

enum E {
    X,
    Y,
    Z
}

function f<T extends E>(val: T) {}

When calling function f, you can only pass it one value of E at a time. But that does not mean that the generic T can only be one value of E. If manually specifying the generic T, all of these are valid:

f<E>(E.X);
f<E.X>(E.X);
f<E.X | E.Y>(E.X);
f<Exclude<E, E.Y>>(E.X);

In every case E.X is assignable to T (that is, E.X is equal to or more narrow than T) and T extends E (that is, T is equal to or more narrow than E).

Playground Link