What does 'extends' actually mean in typescript?

Question

I am not able to fully grasp the use of extends keyword in case of union types. Here is a code snippet explaining the confusion that I have.

class SomeClass {
    someClassProp: string;
};

class SomeExtendedClass extends SomeClass {
    someExtendedClassProp: string;
};

function someClassFunction<T extends SomeClass>(args: T): T {
    return args;
};

let someClass: SomeClass, someExtendedClass: SomeExtendedClass;

someClassFunction(someClass);
someClassFunction(someExtendedClass); // Works just fine(case 1)

type someType = 'a' | 'b';
type someExtendedType = someType | 'c';

function someTypeFunction<T extends someType>(args: T): T {
    return args;
};

let someType: someType, someExtendedType: someExtendedType;

someTypeFunction(someType);
someTypeFunction(someExtendedType); // Gives me an error(case 2)

So I was wondering why such design decisions are made and what are the implications of the same.

changing function someTypeFunction<T extends someType>(args: T): T {return args;}; to function someTypeFunction<T extends someExtendedType>(args: T): T {return args;}; works but I am not able to understand how this thing is actually working.

EDIT 1

type someType = 'a' | 'b';
type someOtherType = 'c';
type someUnionType = someType | someOtherType;

type someTypeCore<T extends someUnionType> = { type: T };

type someTypeObj<T extends someType> = { a: string } & someTypeCore<T>;
type someOtherTypeObj<T extends someOtherType> = { b: string, c: string } & someTypeCore<T>;

function typeAssertion<T extends someUnionType>(args: someTypeCore<T>): args is someTypeObj<T> {
    return (args as someTypeObj<T>).a !== undefined; // Gives an error
};

function someTypeFunction<T extends someUnionType>(args: someTypeCore<T>): T {
    if (typeAssertion(args)) {
        // Do something for someTypeObj 
    } else {
        // Do Something for someOtherTypeObj 
    };
    return args.type;
};

How do we resolve this.

Answer 1

The extends in the function constains T to be a subtype of the specified type. What a subtype means may be a bit surprising for unions.

You have to think of what a subtype relationship really means. When we say that SomeExtendedClass is a subclass of SomeClass the implication is that any instance of SomeExtendedClass is also an instance of SomeClass

So the set of all SomeClass instances contains the set of all SomeExtendedClass instances.

But if we take this view of subtypes to unions we see that the union with fewer memebers ("a" | "b") is actually subtype of the one with more members ("a" | "b" | "c") since all instances of "a" | "b" are instances of "a" | "b" | "c".

We intuitively think the subtype is the one that "has more stuff" but when thinking about unions this intuition fails us , we need to think about the subtype relationship in terms of sets.