Activity

1. Nicolas Stepien (nstepien)

   changed the title [-]`as const` objects should have unique symbols[/-] [+]Symbols in `as const` objects should be unique symbols[/+] on May 2, 2023
2. fatcerberus commented on May 2, 2023

   

   Bruce Pascoe (fatcerberus)

   on May 2, 2023

   More actions

   Possibly related: #53276
3. nstepien commented on May 2, 2023

   

   Nicolas Stepien (nstepien)

   on May 2, 2023

   Author

   More actions

   Bruce Pascoe (@fatcerberus) I'm not convinced this issue is related.
4. Ryan Cavanaugh (RyanCavanaugh)

   added

   SuggestionAn idea for TypeScriptAn idea for TypeScript

   In DiscussionNot yet reached consensusNot yet reached consensus

   on May 2, 2023
5. fatcerberus commented on May 2, 2023

   

   Bruce Pascoe (fatcerberus)

   on May 2, 2023

   Last edited by fatcerberus

   More actions

   Nicolas Stepien (@nstepien) Note I said "related", not "duplicate".

   That said, I think the limitation here is that unique symbols explicitly have type typeof x, which implies there must be an x in scope that can be used with typeof. Given an anonymous object literal containing Symbol() calls, there's nothing for typeof to refer back to.

   👍React with 👍1Reacted by Nicolas Stepien
6. nstepien commented on May 2, 2023

   

   Nicolas Stepien (nstepien)

   on May 2, 2023

   Author

   More actions

   Given

   const obj = { x: Symbol() } as const

   , would it be possible for its type to be typeof obj.x?

   Although that wouldn't work in a case like

   fn({ [dynamicKey]: Symbol() } as const)

   as there is no specific name to refer back to.

   Maybe unique symbol is good enough.
7. nstepien commented on May 3, 2023

   

   Nicolas Stepien (nstepien)

   on May 3, 2023

   Author

   More actions

   I wonder if TS could use the description when available, i.e. Symbol('desc')'s type could be typeof Symbol('desc')
   or unique symbol 'desc'.
8. rotu commented on Nov 24, 2023

   

   Dan Rose (rotu)

   on Nov 24, 2023

   More actions

   could be typeof Symbol('desc') or unique symbol 'desc'.

   That's expressible as declare const mySymbol: symbol & {readonly description:'desc'}. Unfortunately, you have to give up uniqueness. (unique symbol) & {readonly description:'desc'} silently ignores the uniqueness. And {readonly description:'desc'} & (unique symbol) errors "'unique symbol' types are not allowed here."

   Trying to fix this with an explicit annotation fails:

   // ERROR: Type 'symbol' is not assignable to type 'unique symbol'.
   const myEnum: {readonly a:unique symbol} = { a: Symbol() };

   The best I achieve is with a cast:

   const myEnum = { a: Symbol() } as { readonly a: unique symbol }

   But this doesn't provide the type safety you seek because unique symbols decay too easily:

   const myEnum = { a: Symbol() } as { readonly a: unique symbol }
   const anotherEnum = { a: Symbol() } as { readonly a: unique symbol }
   
   let b = myEnum.a
   b = anotherEnum.a // OOPS! NO ERROR!

   👀React with 👀1Reacted by Nicolas Stepien
9. rotu commented on Nov 25, 2023

   

   Dan Rose (rotu)

   on Nov 25, 2023

   More actions

   Wrote up some of the related issue in #56535 (namely that the type system disregards the description passed in to the Symbol constructor, even if it's a string literal)
10. JacobLey commented on Feb 12, 2024

    

    Jacob Ley (JacobLey)

    on Feb 12, 2024

    More actions

    +1 to this feature request.

    Running into a similar issue where I would like the type generic to prefer a unique symbol.

    e.g.

    const doGenericThing = <T extends symbol>(val: T): { val: T } => {
        return { val };
    };
    

    Doesn't use unique symbol by default:

    // { val: symbol }
    const notUnique = doGenericThing(Symbol('abc'));
    

    Can assign to a const first, which works but requires a technically unnecessary variable declaration

    const uniqueSym = Symbol('abc');
    // { val: typeof uniqueSym }
    const unique = doGenericThing(uniqueSym);
    

    Appending as const seems like a very reasonable approach to have it use a unique symbol.

    // Not yet legal
    const standaloneUnique = doGenericThing(Symbol('abc') as const);
    

    Possibly off topic, but I wouldn't expect any of this unique functionality to apply to Symbol.for, unless symbols were to start tracking their description (see issue linked above).

    However it appears that is not the case:

    const sym = Symbol.for('abc');
    const restrictToSym = (val: typeof sym) => {};
    
    // _should_ work, but treated as a separate unique symbol
    restrictToSym(Symbol.for('abc'));