Incremental type narrowing, enabling gradual object initialization

Search Terms

delayed initialization, gradual initialization

Suggestion

What if, on every assignment to either a value or a property, that the type of that value is narrowed? It's probably easiest explained with an example:

Use Cases

It means that this code for gradually initializing an object would just work:

type Person = { firstName: string, surname: string }

function f() : Person {
    const p : Partial<Person> = {}

    p.firstName = ""
    p.surname = ""

    return p; // Error: Type 'Partial<Person>' is not assignable to type 'Person'
}

Currently this code does not type check because the compiler doesn't change the type of p after the assignments to its properties.

My thinking is that, for any value x of type X : { a : unknown },

x.a = "some string"

would result in x having its type narrowed to:

X & { a : string }

This means that the partial initialization example would work. If it works for variables as well as properties then so would this:

function f(mode: "read" | "read/write") {
    // ... Code ...
}

let s: string;

s = "read"

f(s)

Examples

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.

El issue no nombra ningún archivo de implementación, prueba ni punto de entrada del compilador. Comienza revisando el comportamiento de narrowing existente para los ejemplos proporcionados de inicialización de objetos y asignación de variables; se consideraría terminado cuando hubiera un diseño acordado y cobertura de pruebas para el narrowing de asignaciones solicitado.