Optional Type Chaining

Suggestion

🔍 Search Terms

optional type chaining syntax

✅ Viability 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, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Support optional chaining syntax for types

📃 Motivating Example

The following pattern is so common that optional chaining syntax was introduced into JS:

type DeeplyNullableObject = undefined | {
  key?: {
    nestedKey?: {
      deeplyNestedKey?: 'value'
    }
  }
}

const deeplyNullableObject: DeeplyNullableObject = {}

// cumbersome
deeplyNullableObject
  ? deeplyNullableObject['key']
    ? deeplyNullableObject['key']['nestedKey']
      ? deeplyNullableObject['key']['nestedKey']['deeplyNestedKey']
      : undefined
    : undefined
  : undefined

// convenient!
deeplyNullableObject?.['key']?.['nestedKey']?.['deeplyNestedKey']

However, in TypeScript, accessing deeplyNullableObject?.key?.nestedKey?.deeplyNestedKey's type is still cumbersome (even with TypeScript's super helpful NonNullable utility type):

// cumbersome
type DeeplyNestedValue = NonNullable<
  NonNullable<
    NonNullable<
      DeeplyNullableObject
    >['key']
  >['nestedKey']
>['deeplyNestedKey']

💻 Use Cases

Supporting optional chaining syntax for types would make working with these types just as easy as it is for their runtime counterparts:

// convenient!
type DeeplyNestedValue = DeeplyNullableObject?.['key']?.['nestedKey']?.['deeplyNestedKey']

It also allows developers to easily convert some runtime values declared using optional chaining to types by simply applying typeof, which is always satisfying and feels well within the spirit of TypeScript being elegantly consistent with JavaScript:

type DeeplyNestedValue = typeof deeplyNullableObject?.['key']?.['nestedKey']?.['deeplyNestedKey']

Inizia esaminando gli esempi proposti di concatenamento opzionale dei tipi e gli obiettivi di progettazione collegati di TypeScript. L'issue non indica file di implementazione, punti di ingresso o test, quindi identificare le aree rilevanti del sistema dei tipi e del parser farebbe parte dell'indagine iniziale. Per considerarla completata sarebbero necessari un design concordato, oltre all'implementazione e alla copertura per le espressioni di tipo mostrate.