Allow unique symbols to be interchangeable with types. Also assignability bug with `Symbol()`.

[rozzzly]

Now that we have #15473, when a symbol—which is guaranteed to be unique by the ES2015 spec—is assigned to a const variable, it can be used (via computed property syntax) in place of a normal property name.

Quick contrived example:

export const FOO = Symbol('FOO');
export const BAR = Symbol('BAR');

export interface Thing {
    [ FOO ]: boolean;
    [ BAR ]: number;
}

const thing: Thing = undefined;
const foo = thing[ FOO ]; // ☝️ hover shows type of `foo` as `boolean`
const bar = thing[ BAR ]; // ☝️ hover shows type of `bar` as `number`

I love this, it allows a symbol to act as a unique identifier. But it truth, a symbol represents a unique value, I want to use that unique value to describe a type.

Another quick contrived example:

export const FOO = Symbol('FOO');
export const BAR = Symbol('BAR');

export function fooOrBar(value: FOO | BAR): string { // ❌ Cannot find name 'FOO'.
                                                     // ❌ Cannot find name 'BAR'.
    if (value === FOO) return 'You gave me FOO!';
    else if (value === BAR) return 'You gave me BAR!';
    else throw TypeError('What was that!?');
}

Is that something anyone else would want? A lot of us will use a symbol to define a unique constant, I think it just makes sense to be able to use that constant to... refer to that constant.

---

On a side note, I think I may have found a bug. So while typing up this issue, I found that I am able to achieve the desired behavior by using an intersection with a "tagged" object literal:

export type FOO = symbol & { FOO: true };
export const FOO: FOO = Symbol('FOO'); // ❓️ no error
export type BAR = symbol & { BAR: true };
export const BAR: BAR = Symbol('BAR'); // ❓ no error

While this is nice for me because it achieves what I want, I don't think it should work. Heres why:

So if you hover over the Symbol() constructor you'll see this:

var Symbol: SymbolConstructor
(description?: string | number) => symbol

That's what I expected to see. You (optionally) give it a string | number description and it gives you a symbol in return. So why doesn't the compiler freakout when I assign it to something that is symbol & { FOO: true }? If IRRC the spec says that no properties can be set on a symbol. I can't find where it said that, but really quickly in my DevTools Console, I did this which seems to affirm my belief:

$> const foo = Symbol('foo')
undefined
$> foo
Symbol(foo)
$> foo.foo = true
true
$> foo
Symbol(foo)
$> foo.foo
undefined

Perhaps there some special assignability feature for typescript primitive symbol that I'm overlooking? I don't know. But if you do:

export type FOO = string & { FOO: true };
export const FOO: FOO = String('FOO'); // ❌ Type 'string' is not assignable to type 'FOO'.
                                       // ❌ Type 'string' is not assignable to type '{ FOO: true; }'.

Looking at the type info for the String() constructor, it's nearly identical:

const String: StringConstructor
(value?: any) => string

so why does it behave differently?

---

Just out of curiosity, I tried:

export const FOO: boolean = Symbol('FOO');

And got no errors. Something is definitely broken because symbol is acting like any.

Because you will ask, I am currently running: typescript@2.7.0-dev.20171226, I've also tested this on 2.7.0-insiders.20171214, but the playground correctly gives me errors.

[sylvanaar]

Just to add to the mystery a little.

export const FOO: FOO = Symbol('FOO') as symbol; //  Type 'symbol' is not assignable to type 'FOO'.
                                                 // Type 'symbol' is not assignable to type '{ FOO: true; }'.

And this one is a little crazy!

const NEVER: never = Symbol("Never?");

Type of NEVER is now symbol! Symbol() is quite powerful!

[DanielRosenwasser]

You can reference the type of the constant with typeof (the type query operator) in the following way:

const Foo = Symbol("foo");
type Foo = typeof foo;

[rozzzly]

@DanielRosenwasser not sure if we're on the same page here...

typeof Symbol('foo') // => symbol

I'm looking for the type of a symbol assigned to a constant to be mutually exclusive from other symbols.

Desired Behavior:

export const FOO = Symbol('FOO');
export const BAR = Symbol('BAR');

export function onlyFOO(value: FOO): void {
   // ...
}

onlyFOO(FOO); // ✔️ 
onlyFOO(BAR): // ❌ Type 'BAR' is not assignable to type 'FOO'.

[rozzzly]

okay, I went back and looked at the new unique keyword, and using that I was able to get what I wanted:

export const FOO: unique symbol = Symbol('FOO');
export const BAR: unique symbol = Symbol('BAR');

export function onlyFOO(value: typeof FOO): void {
   // ...
}

onlyFOO(FOO); // ✔️ 
onlyFOO(BAR): // ❌ Type 'unique symbol' is not assignable to type 'unique symbol'.

The error message: "Type 'unique symbol' is not assignable to type 'unique symbol'." sucks though. Would be nice if it contained the identifiers.

I thought perhaps defining a type alias for the type of the variable like so:

export const FOO: unique symbol = Symbol('FOO');
export type FOO = typeof FOO;
export const BAR: unique symbol = Symbol('BAR');
export type BAR = typeof BAR;

might cause the alias to show up in the assignment error message, but alas, it does not.

---

When I read #15473, I was thinking that because the declaration output of export const FOO = Symbol('FOO'); is export const FOO: unique symbol; therefore a const variable assignment where the right-hand side was simply the Symbol() constructor (ie: const FOO = Symbol('FOO');) would have the infered type of unique symbol.

I see why this isn't necessarily the case: in a declaration, you don't see the right-hand side of an assignment therefor the variable has to be explicitly marked as being unique.

[chriseppstein]

I also expected to be able to use the constant as a type in a similar way to string literals and so I think this pattern will be very common:

export const FOO: unique symbol = Symbol('FOO');
export type FOO = typeof FOO;

So common that I think it deserves some sugar to reduce the boilerplate. What do folks think about this?

export const type FOO = Symbol('FOO');

I don't see why such a declaration wouldn't also work for string and integer literals.

[rozzzly]

That would be so damn useful for typing redux actions!!

This is what I'm currently doing for any interested:

Expand to View (ommitted because it's super long... because it's redux)

_{./src/common/state/ui/share/actions.ts}

import { Shareable } from './state';
import { Action } from 'common/state/KnownActions';

export type SHARE = 'ui/share::SHARE';
export const SHARE: SHARE = 'ui/share::SHARE';

export interface SHARE_Action extends Action<SHARE> {
    type: SHARE;
    payload: Shareable;
}

export function share(shareable: Shareable): SHARE_Action {
    return {
        type: SHARE,
        payload: shareable
    };
}

export type DISMISS = 'ui/share::DISMISS';
export const DISMISS: DISMISS = 'ui/share::DISMISS';

export interface DISMISS_Action extends Action<DISMISS> {
    type: DISMISS;
}

export function dismiss(): DISMISS_Action {
    return {
        type: DISMISS,
    };
}

export type UIShareActions = (
    | SHARE_Action
    | DISMISS_Action
);

export type UIShareActionIDs = (
    | SHARE
    | DISMISS
);

export default {
    SHARE,
    share,
    DISMISS,
    dismiss
};

_{./src/common/state/KnownActions.ts}

export interface Action<T extends string> extends Action { // extends `redux`'s `Action` interface
    type: T;
    payload?: any;
    error?: Error;
    meta?: any;
}

export type KnownActions = (
    | SystemActions
    | UIActions
);

export type KnownActionsIDs = (
    | SystemActionIDs
    | UIActionIDs
);

super verbose, but has perfect type checking/completions

[mhegazy]

I am not sure i understand the issue really.. the examples you are referring to the type FOO as a unique symbol are working if you use typeof FOO instead.