Literal Comparison for Conditional Types

Search Terms

compare type to value literal, conditional type literals, type is literal, complex schemas

Suggestion

The ability to compare a type against an example of that type, for use in complex type aliases and interfaces.

Use Cases

When designing a complex schema for an object, the actual fields contained by the object can branch in many different ways.

Of course, it's possible to approach the problem by using nullable types for fields that are not present in all cases. This results in a readable type in the error inspection window, but lots of unnecessarily defensive code that would have been solved by a fully typed schema.

It's also possible to create a discriminated union consisting of every branch--but what if you have a lot of branches? It becomes undesirably repetitive and the error inspection window is a wall of text.

Examples

Take for example, the type of a Pipeline:

type Action = 'Data Selection' | 'Data Cleanup' | 'Train' | 'Store' | 'Deploy'
type Status = 'running' | 'finished' | 'error'
type PipelineStep = {
	name: Action
	status: Status
	tags: Array<string>
        // `never` actually always results in a type check error right now
	message: PipelineStep['status'] is 'Error' ? string : never 
	path: PipelineStep['name'] is 'Data Selection' | 'Store' ? string : never
	trainingID: PipelineStep['name'] is 'Train' ? string : never
	endpoint: PipelineStep['name'] is 'Deploy' ? string : never
} 

Contrasted with the current syntax and discriminated unions:

type PipelineStep = {
	name: Action
	status: Exclude<Status, 'Error'>
	tags: Array<String>
} | {
	name: Action
	status: 'Error'
	tags: Array<string>
	message: string
} | // I give up

The number of branches is multiplicative in nature. In this case, the most complex schema could have a maximum of 6 (Actions) x 3 (Status) possible branches.
After optimization, it becomes:

type StepStatus = {
	status: Exclude<Status, 'Error'>
} | {
	status: 'Error'
	message: string
}

type DataSelectionStep = {
	name: 'Data Selection'
	path: string
}
type TrainingStep = { 
	name: 'Training'
	trainingID: string
}
type StoreStep = {
	name: 'Store'
	path: string
}
type DeployStep = { 
	name: 'Deploy'
	endpoint: string
}

type PipelineStep = (DataSelectionStep | TrainingStep | StoreStep | DeployStep | {
	name: Exclude<Action, 'Training' | 'Data Selection' | 'Store' | 'Deploy'>
}) & StepStatus & {
	tags: Array<String>
}

which isn't really much better...

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.

Aucun fichier, test ou point d’entrée n’est nommé. Commencez par examiner la partie du vérificateur de types de TypeScript responsable des types conditionnels et comparez la proposition au comportement existant des unions discriminées ; le travail serait considéré comme terminé lorsqu’une syntaxe prise en charge de comparaison entre un type et un littéral gérerait les exemples sans modifier le JavaScript généré.