Unique type

[ruojianll]

🔍 Search Terms

"unique type"

✅ Viability Checklist

• 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 isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

Sometimes I just need a unique type as flags in my type calculations. If I use a string subtype or others it couldn't be identity well. Such as:

type Flag = 'Flag'
type MyType<T extends string|Flag>=T extends Flag? 'IsFlag':'A normal string'

In the code, Flag is also a string. I don't want to post some complex types which references each other and using flag types but it is really useful for me.
Define a pure unique type without any runtime content.

📃 Motivating Example

type Flag1 = unique('Flag')
type Flag2 = unique('Flag')

Flag1 is not Flag2 like unique symbols.
The unique types only extends itself for checking what it is.
Pass a text to unique keyword to create a unique type.

💻 Use Cases

1. What do you want to use this for?
   To control the type calculation especially in recursive type definitions.
2. What shortcomings exist with current approaches?
   If I define a unique symbol, it should produce a runtime symbol.
3. What workarounds are you using in the meantime?
   Write flag with string sub-type carefully.

[jcalz]

related #33038

[ruojianll]

@jcalz Shall we use it? Why was it closed?

[nmain]

See #55691 (comment)

[RyanCavanaugh]

declare const _flag: unique symbol;
type Flag = typeof _flag;
type MyType<T extends string|Flag>=T extends Flag? 'IsFlag':'A normal string'
type M1 = MyType<"Flag">;
type M2 = MyType<Flag>;

Putting unique in type space quickly gets weird for a bunch of reasons because generic instantiation becomes a much different operation from a simple substitution, e.g. if you have

type Pair<T> = { x: T, y: T };

// __very__ different from writing { x: unique, y: unique }
type S = Pair<unique>;

This would mean many common identities would no longer be true

[ruojianll]

type S = Pair<unique>;

It has an error Type expected. @RyanCavanaugh

declare const _flag: unique symbol; means there is a unique symbol constant _flag in execution context, but no. This is not type safe.