guest271314 (2019-06-17T04:42:04.000Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal and additional use case for ```nameof```

const x = nameof y; // "y"
const y = 1;

making the need for ```nameof``` moot given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;


without having to already know the name of the identifiers, as is required
by the original proposal, which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```.


On Mon, Jun 17, 2019 at 4:19 AM Frederick Stark <coagmano at gmail.com> wrote:

> guest271314, your examples are all completely incorrect anyway since all
> variable declarations (including let and const) are hoisted to the top of
> the scope, so when nameof y is evaluated, y is already declared in the
> scope.
>
> The special behaviour introduced with let and const is that they set up a
> "Temporal Dead Zone" where attempts to set or get their value before the
> line where they are declared in code throws an exception.
> Since nameof doesn't care about the value, only the name of the variable,
> it would not *need* to throw an exception.
> Of course, were this proposal to be taken seriously, it could be specced
> either way
>
> On Jun 17 2019, at 10:15 am, guest271314 <guest271314 at gmail.com> wrote:
>
> > - If `y` is directly visible in scope and is neither a parameter or
> destructured binding, `nameof y` should just evaluate to `"y"`. This
> should be agnostic to whether the binding has been declared yet, so in
> your example, `x` should be set to `"y"`.
>
> The 1st question at
> https://esdiscuss.org/topic/what-do-you-think-about-a-c-6-like-nameof-expression-for#content-33
> remains:
>
> Without having composed or previously read the source code, at line 1
> adjacent to ```nameof``` how does the user know that there will be later
> declared variable named ```y```?
>
>
>
> On Sun, Jun 16, 2019 at 7:04 AM Isiah Meadows <isiahmeadows at gmail.com>
> wrote:
>
> Here's my opinion:
>
> - If `y` is directly visible in scope and is neither a parameter or
> destructured binding, `nameof y` should just evaluate to `"y"`. This
> should be agnostic to whether the binding has been declared yet, so in
> your example, `x` should be set to `"y"`.
> - If `y` is entirely undeclared, it should be a runtime
> `ReferenceError` in the same way it is when accessing undefined
> globals. So in your second example, I'd expect it to throw before even
> attempting assignment
>
> -----
>
> Isiah Meadows
> contact at isiahmeadows.com
> www.isiahmeadows.com
>
> On Sun, Jun 16, 2019 at 12:00 AM guest271314 <guest271314 at gmail.com>
> wrote:
> >
> > ```
> > const x = nameof y
> > const y = 1;
> > ```
> >
> > At line 1 adjacent to ```nameof``` how does the user even know that
> there is a variable that will be declared named ```y```?
> >
> > What is the output of ```x``` where there is no variable named ```y```
> later declared?
> >
> > ```
> > const x = nameof y
> > const z = 1;
> > ```
> >
> > On Sun, Jun 16, 2019 at 12:03 AM Ron Buckton <Ron.Buckton at microsoft.com>
> wrote:
> >>
> >> > What should occur where the code is
> >>
> >> It would be "y" in all 3 places.
> >>
> >> > ... is a proposal for _more_ than only getting the _name_ of an
> _declared_ and _initialized_ variable?
> >>
> >> It is a proposal for getting the name of a _declared_ variable. Whether
> it is _initialized_ does not matter.
> >>
> >> > Should a ```RefefenceError``` _not_ be thrown simple because
> ```nameof``` is used?
> >>
> >> No, an error is not thrown. ECMAScript is much more nuanced. Block
> scoped variables from 'let' or 'const' exist and can be *referenced* (via
> closure or export, currently) anywhere within the same block scope, even
> before they are initialized. Until they have been *initialized* (the line
> of code contain the declaration has been reached and evaluated), they exist
> in a "Temporal Dead Zone" (TDZ). Attempting to *dereference* them (i.e.
> access or store a value) while in this TDZ is what results in the
> ReferenceError.
> >>
> >> At no point does the `nameof` operator *dereference* the variable, so
> no error need be thrown.
> >>
> >> From: guest271314
> >> Sent: Saturday, June 15, 4:29 PM
> >> Subject: Re: Re: What do you think about a C# 6 like nameof()
> expression for
> >> To: Ron Buckton
> >> Cc: es-discuss at mozilla.org
> >>
> >>
> >>
> >>
> >> What should occur where the code is
> >>
> >> ```
> >> const x = nameof y
> >> await new Promise(resolve => setTimeout(resolve, 100000)); // should x
> be "y" here?
> >> await new Promise(resolve => setTimeout(resolve, 200000)); // should x
> be "y" here?
> >> await Promise.all([new Promise(resolve => setTimeout(resolve, 300000)),
> ...doStuff()]); // should x be "y" here?
> >> const y = 1;
> >> ```
> >>
> >> ?
> >>
> >> The immediately invoked arrow function example (where a
> ```RefeferenceError``` is thrown) appears to demonstrate that to output the
> expected result of ```nameof``` within the context of the code example
> >>
> >> ```
> >> const x = nameof y
> >> const y = 1;
> >> ```
> >>
> >> is a proposal for _more_ than only getting the _name_ of an _declared_
> and _initialized_ variable?
> >>
> >> Should a ```RefefenceError``` _not_ be thrown simple because
> ```nameof``` is used?
> >>
> >> On Sat, Jun 15, 2019 at 11:16 PM Ron Buckton <Ron.Buckton at microsoft.com>
> wrote:
> >>
> >> ```
> >> const x = nameof y
> >> const y = 1;
> >> ```
> >>
> >> `x` would have the value “y”. It would not matter if `y` were
> initialized or had yet been reached during execution. It does not deviate
> from the purpose of `let` or `const`, because you are not accessing the
> value of the identifier.
> >>
> >> Also consider that this is legal ECMAScript in a module:
> >>
> >> ```
> >> export { y }
> >> const y = 1;
> >> ```
> >>
> >> The binding for `y` exists within the same block scope, it just has not
> yet been initialized. Exporting it via `export { y }`, closing over it via
> `() => y`, or accessing it via `nameof y` would all be the same. In all
> three cases you are accessing the *binding* of `y`, not the *value* of `y`.
> Even in the `() => y` case, you don’t access the *value* of `y` until you
> execute the function.
> >>
> >> From: guest271314 <guest271314 at gmail.com>
> >> Sent: Saturday, June 15, 2019 3:57 PM
> >> To: Ron Buckton <Ron.Buckton at microsoft.com>
> >> Cc: es-discuss at mozilla.org
> >> Subject: Re: Re: What do you think about a C# 6 like nameof()
> expression for
> >>
> >> > Sorry, I meant to say “not entirely correct”.
> >>
> >> You have not yet confirmed if in fact the expected output is
> referencing a variable declared using ```const``` on the current line
> _before_ initialization _on the next line_.
> >>
> >> That example appears to deviate from the purpose and usage of
> ```const```, beyond the scope of ```nameof```, and if were implemented, a
> ```ReferenceError``` should _not_ be thrown when a ```const``` variable
> that has yet to be initialized _on the next line_ is referred to _on the
> current line_?
> >>
> >> Aside from that example, the code which essentially already implements
> ```nameof``` should be able to be found in the code which implements
> ```ReferenceError``` relevant to ```const```.
> >>
> >> On Sat, Jun 15, 2019 at 10:47 PM Ron Buckton <Ron.Buckton at microsoft.com>
> wrote:
> >>
> >> Sorry, I meant to say “not entirely correct”.
> >>
> >> From: Ron Buckton
> >> Sent: Saturday, June 15, 2019 3:03 PM
> >> To: guest271314 <guest271314 at gmail.com>
> >> Cc: es-discuss at mozilla.org
> >> Subject: RE: Re: What do you think about a C# 6 like nameof()
> expression for
> >>
> >> > At that point in the example code the identifer ```y``` does not
> exist.
> >>
> >> That is not entirely incorrect. The identifier `y` exists, but its
> binding has not been initialized, otherwise you couldn’t refer to y in this
> case:
> >>
> >>
> >>
> >>
> > _______________________________________________
> > es-discuss mailing list
> > es-discuss at mozilla.org
> > https://mail.mozilla.org/listinfo/es-discuss
>
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190617/348054ae/attachment-0001.html>
guest271314 at gmail.com (2019-06-17T05:37:49.979Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

The original proposal does not appear to be automated; the user does not acquire knowledge of the variables that they do not already know. Proven by the fact that the user MUST write the variable name adjacent to ```nameof``` themselves as a literal identifier.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible - without _standardized_ identifiers where no user deviates from said naming convention).

If the proposal is based on automation it seems sensible to simply get all of the identifer names (```let```, ```const```, 
 ```class```, etc.) in the current scope first, with optional name and line number; while also being able to handle the case of ```(protoPropertyIsSet(msg, nameof msg.expiration_utc_time)) {... }```.

guest271314 at gmail.com (2019-06-17T05:14:33.420Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

The original proposal does not appear to be automated; the user does not acquire knowledge of the variables that they do not already know. Proven by the fact that the user MUST write the variable name adjacent to ```nameof``` themselves as a literal identifier.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible - without _standardized_ identifiers where no user deviates from said naming convention).

If the proposal is based on automation it seems sensible to simply get all of the identifer names (```let```, ```const```, 
 ```class````, etc.) in the current scope first, with optional name and line number; while also being able to handle the case of ```(protoPropertyIsSet(msg, nameof msg.expiration_utc_time)) {... }```.

guest271314 at gmail.com (2019-06-17T05:14:05.601Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

The original proposal does not appear to be automated; the user does not acquire knowledge of the variables that they do not already know. Proven by the fact that the user MUST write the variable name adjacent to ```nameof``` themselves as a literal identifier.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible - without _standardized_ identifiers where no user deviates from said naming convention).

If the proposal is based on automation it seems sensible to simply get all of the identifer names (```let```, ```const```, etc.) in the current scope first, with optional name and line number; while also being able to handle the case of ```(protoPropertyIsSet(msg, nameof msg.expiration_utc_time)) {... }```.

guest271314 at gmail.com (2019-06-17T05:05:50.876Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

The original proposal does not appear to be automated; the user does not acquire knowledge of the variables that they do not already know. Proven by the fact that the user MUST write the variable name adjacent to ```nameof``` themselves as a literal identifier.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible - without _standardized_ identifiers where no user deviates from said naming convention).

If the proposal is based on automation it seems sensible to simple get all of the identifer names (```let```, ```const```, etc.) in the current scope first, with optional name and line number; while also being able to handle the case of ```(protoPropertyIsSet(msg, nameof msg.expiration_utc_time)) {... }```.

guest271314 at gmail.com (2019-06-17T05:04:14.493Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

The original proposal does not appear to be automated; the user does not acquire knowledge of the variables that they do not already know. Proven by the fact that the user MUST write the variable name adjacent to ```nameof``` themselves as a literal identifier.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible - without _standardized_ identifiers where no user deviates from said naming convention).

If the proposal is based on automation it seems sensible to simple get all of the identifer names (```let```, ```const```, etc.) in the current scope first, with optional name and line number. 

guest271314 at gmail.com (2019-06-17T05:03:31.642Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

The original proposal does not appear to be automated; the user does not acquire knowledge of the variables that they do not already know. Proven by the fact that the user MUST write the variable name adjacent to ```nameof``` themselves as a literal identifier.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible - without _standardized_ identifiers where no user deviates from said naming convention).

If the proposal is based on automation it seems sensible to simple get all of the identifer names (```let```, ``const```, etc.) in the current scope first, with optional name and line number. 

guest271314 at gmail.com (2019-06-17T04:57:07.423Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

The original proposal does not appear to be automated; the user does not acquire knowledge of the variables that they do not already know. Proven by the fact that the user MUST write the variable name adjacent to ```nameof``` themselves as a literal identifier.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible - without _standardized_ identifiers where no user deviates from said naming convention).
guest271314 at gmail.com (2019-06-17T04:52:29.353Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible - without _standardized_ identifiers where no user deviates from said naming convention).
guest271314 at gmail.com (2019-06-17T04:51:26.506Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError``` what the identifier name is if they did not already know by _first_ writing or reading the code; that is, virtually impossible,).
guest271314 at gmail.com (2019-06-17T04:50:07.158Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess e.g., ```try..catch```, ```ReferenceError````, what the identifier name is if they did not already know by writing or reading the code).
guest271314 at gmail.com (2019-06-17T04:48:24.585Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot - given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess what the identifier name is if they did not already know by writing or reading the code).
guest271314 at gmail.com (2019-06-17T04:47:53.379Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

```
// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,
Math.floor(Math.random() * 1000)));
const y = 1;
```

without having to _already know the name of the identifiers_, as is _required_
by the original proposal; which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```. 

```nameof```, if anything, should provide a detail to coding that the user does not already know or have to know in order to _not_ have an error thrown by referencing a non-existent identifier (where the user would have to guess what the identifier name is if they did not already know by writing or reading the code).
guest271314 at gmail.com (2019-06-17T04:44:13.893Z)
The user MUST _already_ know the _exact_ identifier name or an error will
be thrown for the original proposal use cases and additional use case for ```nameof```

```
const x = nameof y; // "y"
const y = 1;
```

making the need for ```nameof``` moot given that the user cannot then
rationally state that the identifier as a _string_ will somehow be
mispelled if they are able to write the _exact_ name of the identifer at
```nameof``` 100% of the time.

That leaves the use case of getting ALL of the names of the identifiers in
the current scope

// NAMEOF is always dynamic list of let, const declarations in current scope
console.log(NAMEOF); // ["x", "y"]; [{name:"x", line:5}, {name:"y", line:7}]
// should resolve be in the list even if not declared using const or let?
await new Promise(resolve => setTimeout(resolve,

Math.floor(Math.random() * 1000)));
const x = nameof y
await new Promise(resolve => setTimeout(resolve,

Math.floor(Math.random() * 1000)));
const y = 1;


without having to already know the name of the identifiers, as is required
by the original proposal, which essentially negates itself as the string
literal ```'y'``` is briefer than ```nameof y```.