Probabilistic Types

[greim]

Search Terms

Probabilistic, union, supertypes

Suggestion

If a union type contains a member which is a supertype of one or more other members, the supertype subsumes those other members, but the information isn't lost. Tooling can then use that information as a hint about the expected distribution of possible values within that type.

type MetaSyntacticVar = 'foo' | 'bar' | 'baz' | string;

For the purposes of type safety, the above type is simply string. However, tools may consider 'foo' | 'bar' | 'baz' to be the most likely values for MetaSyntacticVar. An IDE might use them for autocomplete. A linter (i.e. not tsc) might flag other values as a warning. Etc.

Use Cases

A backend service offers a range of options, and I want to statically model them as a union type. Sometimes, the service adds a new option. I must either generalize the type to a string, do a type cast and tolerate some type unsafety, or release code updates in sync with all backend updates.

Examples

type MetaSyntacticVar = 'foo' | 'bar' | 'baz' | string;

const name: MetaSyntacticVar = 'qux';
================================^ IDE suggests foo, bar, or baz as I type this
================================^^^ eslint flags this as a warning (if I opt in)

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.

[jcalz]

I imagine such a change would break existing TypeScript code; if a union of a literal type with its widened supertype doesn't collapse to the supertype, anything that operates on union members (such as distributive conditional types) could behave differently.

With current TS one might achieve something like what you're looking for with a helper function:

const MetaSyntacticVar = <T extends string, U extends "foo" | "bar" | "baz">(t: T | U) => t as T;
const intelliSense = MetaSyntacticVar("qux"); // <-- intellisense prompts "foo", "bar", "baz" too

Playground link

[greim]

Thanks for the reply, I changed the title from "Probabilistic Union Types" to just "Probabilistic Types".

'foo' | 'bar' | string simply collapses to string, and from then onward I agree it's just string in terms of what it is and how things operate on it. I'm not proposing to change that.

What I'm proposing instead is that a type T which has a set of N possible values, could carry hints about which of those values are more likely to occur. The type system would ignore those hints, but tooling such as intellisense could use them, and a declaration like 'foo' | 'bar' | string could be a way to add them. Maybe there could be others.

It's a wild idea perhaps, but was prompted by a real problem I was having which I described (in simplified form) in the use cases.

[DanielRosenwasser]

Seems related to #26277

[AlCalzone]

I don't remember in which issue this was discussed, but it was proposed this can be solved with branded tag types.

Edit: found it #33471

[greim]

@AlCalzone @orta - Yep, that issue addresses the exact problem I was having.

Thinking out loud, if you wanted to exactly specify the expected internal distribution of a type, you could add new syntax. Maybe something like:

type MetaSyntacticVar = 'foo'~4 | 'bar'~3 | 'baz'~2 | string~1;
// expect string 10% of the time, etc

Intellisense could use it for sorting, or linters could warn for values falling below certain thresholds. An IDE could even give feedback about how likely some logic branch would ever be executed, which would be useful during refactoring.