Type assertions using Exact, Subset, Superset

[ORESoftware]

I have suffered several times with the limitations of casting like so:

res.json(<Foo>{foo:'bar'});

the above cast/assertion will work even if the anonymous object does not have all the fields in type Foo.
For example, this question I had: https://stackoverflow.com/questions/53328459/prevent-compilation-unless-all-fields-exist

This feature request is for something like this:

res.json(Exact<Foo>{foo:'bar'});
res.json(Subset<Foo>{foo:'bar'});
res.json(Superset<Foo>{foo:'bar'});

note this is similar to the existing construct Partial, as in Partial<T>, hopefully the above are self-explanatory. I am not sure if both Subset<> and Superset<> make sense, but one of them should.

[NN---]

Exact types #12936

[weswigham]

Also #26064

[ORESoftware]

Looking at this again, I think both Subset<T> and Superset<T> make sense. Examples:

const v = {foo:'bar'};
const vprime = Subset<T>v;

Subset<T> acts like an assertion: the assertion is that vprime cannot have any fields that are not in T. What is returned is only what's in v, not what's in T.

next we have Superset:

const v = {foo:'bar', zoom:'zam'};
const vprime = Superset<T>v;

Superset acts like an assertion: it asserts that vprime contains all the fields in T. The type of v is returned from the assertion, not T.

[jack-williams]

Does this work?

type Subset<L, R extends L> = L

type Superset<L extends R, R> = L

interface T {
    foo: 'foo';
    bar: 'bar';
}

const v: { foo: 'foo' } = {
    foo: 'foo'
};

const v2: { foo: 'foo'; bar: 'bar', baz: 'baz' } = {
    foo: 'foo', bar: 'bar', baz: 'baz'
};

const vprime1: Subset<typeof v, T> = v; // ok
const vprime2: Superset<typeof v, T> = v; // notok

const vprime2_1: Subset<typeof v2, T> = v2; // notok
const vprime2_2: Superset<typeof v2, T> = v2; // ok

[ORESoftware]

@jack-williams probably, except I am looking to use it with an anonymous object, like so:

type T = ...

doMyThang((err, val) => {
    res.json(<T>val.x);
});

it needs to be an assertion like that...AKA doing it this way instead kinda takes all my joy away:

type T = ...
doMyThang((err, val) => {
   const x : T = val.x;    ///  << superfluous code that I don't want to write or see
    res.json(x);
});

Doing it with anonymous objects is the higher level goal I think.