Repository: TypeScript
Issue: Generic Constraint using implements or equals 
Labels: Suggestion,Awaiting More Feedback

When working with types and one wants to capture generic typescript types and runtime information in one go, without using experimental decorators, which also has limitations when its comes to type categorization upfront, as it would require extract routines to evaluate if interface uses valid types subset of types when the interface is defined.

One doesn't want to evaluate at the level of string literals here, but at the level of primitive types.

What I would like to propose is a new key call it equal, which would check that the type equals or maybe implements, which perform the same logic as extends, but would not evaluate string | boolean
primitives at literal level or deconstructed level of that type, basically stop there. Almost like named typing in a way.

## Search Terms
generic type implements instead of extends
generic implements  

## Suggestion

// This depends on who you read this statement, T equals boolean or string explicity
// T implements boolean | string pars

```.ts
interface TSType<T equals boolean | string | number | null | undefined | readonly>
{
__tsType : T
}

type rr = TSType<true> // invalid type
type rr = TSType<false> // invalid type
type rr = TSType<'sdf'> // invalid type
type rr = TSType<234> // invalid type
type rr = TSType<234 | string> // invalid type
type rr = TSType<'sdf' | string> // invalid type
type rr = TSType<true | boolean> // invalid type




type rr = TSType<boolean> // valid types
type rr = TSType<string> // valid types
type rr = TSType<number> // valid types
type rr = TSType<undefined> // valid types
type rr = TSType<null> // valid types
type rr = TSType<readonly> // valid types
type rr = TSType<number | readonly> // valid types
type rr = TSType<string | number | readonly | undefined> // valid types
```

## Extract routine for ensuring decorators class for type mixing , conform to specific set of constraints
This method, however, like all others for nested records and arrays, makes it a whole lot more complicate to evaluate the typings. I am actually think of proposing a symbol type, which has identifiers, for structure, which allows simpler ability to iterator nested record structures..
```.ts
MeetsConstraints<T extends Record<string, any>, 
TNullable extends null | never,
TRequired extends undefined | never,
TReadonly extends readonly | never
//Default, but there is no mechanism for this, yet as not standard, would have use annotation type interrogation, if implemented in the future.
 = {
 [K in keyof T] T[K] implement TNullable | TRequired | TReadonly ? 'T' : never
}[keyof T]

// typically this would be extends constraint for some other class or generic
type valid = MeetsConstraints<...> extends 'T' ? 'good' : TError('bad')
```

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).