guest271314 (2019-06-17T04:42:04.000Z)
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```.