Expose inferred type for use in type annotations

Search Terms

infer inferred type annotation

Suggestion

When annotating the type of a variable, allow the variable to have access to the type that would've been inferred for the RHS, so that the author can build a type annation derived from that inferred value. This value could be exposed as the inferred keyword or similar.

Use Cases/Examples

// All properties in `deletable` are subject to being deleted, so we want
// the type to be a Partial of the would-have-been-inferred type.
// I don't think there's a great way to write this at the moment.
const deletable: Partial<inferred> = { a: true, b: false, c: "xyz" };

// The `mutable` property might be reassigned to, but all the other properties wont.
// So combined `Readonly` and `inferred`, with an exception for mutable.
type Legal = "initial" | "middle" | "final"
const partiallyMutable: Readonly<Omit<inferred, "mutable">> & { mutable: Legal } = { 
  x: "literally", 
  y: true,
  mutable: "initial",
  lotsOfOther: 47,
  literalPropsHere: "name"
}

// We want to verify assignability to the mapped type, to make sure that, as new 
// required keys are added, this object literal is updated. However, we also want the
// values at each key to be inferred narrowly as a literal type for use in the code that follows.
type RequiredKeys = "A" | "B" | "C"
const mustHaveAllKeys: inferred & { [K in RequiredKeys]: any } =  = {
  "A": true,
  "B": false,
  "C": "hi!"
}

// typeof mustHaveAllKeys.A should be true!

Related issues

• https://github.com/Microsoft/TypeScript/issues/24375
• https://github.com/microsoft/TypeScript/issues/17574

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.

Start by reviewing the related issues 24375 and 17574, then study how TypeScript handles inferred types and type annotations. Done means defining the inferred behavior for the shown examples and validating that the requested annotations type-check with the intended narrow and mapped types.