guest271314 (2019-03-12T16:54:41.000Z)
guest271314 at gmail.com (2019-03-12T17:12:07.198Z)
> That's the premise that I'm challenging. Why is it simpler, and how does > it, *in any appreciable way*, improve upon whatever you're asserting is > "broken"? The same way that Intl.NumberFormat.prototype.formatToParts does. Though takes the concept one step further by *spreading* each digit to an array - as a JavaScript number not as a JavaScript String. If the number has a decimal, the decimal portion is set at a single element of an array. If the decimal begins with a 0, continue until the first non-zero number is reached, include that number in the decimal portion within the array, and the remainder of the decimal portion is spread to remainder of array elements Example: var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] arrayToNumber(n); // 100.00015 The proposal improves what is broken by not returning broken results relevant to decimal numbers. The proposal allows users to get and set any portion of a number using indexes of an array, which can then be converted back to a number. If you are failing to interpret that as useful, that is your own issue. You might as well state that Intl.NumberFormat.prototype.formatToParts does not have any use. And further, JavaScript number implementation is fine just the way that it is currently implemented, unless *you *decide that any proposal is useful. The array format is a simple data structure. Can be converted to JSON; can be extended to include a description of each digit that is a user gets or sets; e.g., n[0].description // {digit: 1, place: 'hundreds', decimalSibling: true,...etc.} > With respect, your test cases confuse the issue more than they clarify. > Questions on how you'd use this structure aside (which are still > important), your test cases *don't actually produce a structure in which > digits are accessible by nth index* (e.g., the 0-grouping behavior). FYI "respect" is irrelevant to the proposal. Do not need or care about what you consider "respect". You cannot offend this user. Not sure what you mean? What are you confused about relevant to the test cases? The code at the OP includes 1) the original proof of concept; 2) code by Stack Overflow user Shidersz <https://stackoverflow.com/users/10366495/shidersz> which fixed two bugs in the original code. Yes, the code at the OP does produce the expected result. You are misconstruing the proposal. The code already returns the expected result. Do not ask for approval for anything. Just do and let the aftermath settle to its own level. The proposal is asking you people who claim to be specification authors to _name_ each element of the resulting array, for consistency, again, the example var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] as an array users obviously do not have additional data about the values in the array. What do you call the 0 at index 1? What do you call the 5 at index 4? Before incorporating the output into an object, similar to Intl.NumberFormat.prototype.formatToParts - and including the original array in the object, or Map - am asking for standardization of the names of each digit in a _spread_ number in an array. Number to array, array to number is just the first part of the procedure. The part relevant to actually _naming_ the parts, for disambiguation, is what propose here. If you are not interested, that is fine. Do not necessarily need you to do anything. Will do for self as have and continue to do independently, and name the discrete portions of the number arbitrarily, without your input. Again, if you do not gather that this proposal is similar to and extends the functionality of Intl.NumberFormat.prototype.formatToParts, perhaps you should try to use that feature, note that "integer" and "fraction" and "minusSign" are possible return values at output, then lobby for the feature Intl.NumberFormat.prototype.formatToParts to be removed from tc39/Ecma specification, for the same reasons that you are citing at this proposal, which would then make your statement > That's the premise that I'm challenging. _consistent_. Otherwise, you have only proffered standard western academic conjecture, which can be set aside where an individual is not beholden to or reliant on western academic conjecture to proceed with anything they decide to do.
guest271314 at gmail.com (2019-03-12T17:10:57.541Z)
> That's the premise that I'm challenging. Why is it simpler, and how does > it, *in any appreciable way*, improve upon whatever you're asserting is > "broken"? The same way that Intl.NumberFormat.prototype.formatToParts does. Though takes the concept one step further by *spreading* each digit to an array - as a JavaScript number not as a JavaScript String. If the number has a decimal, the decimal portion is set at a single element of an array. If the decimal begins with a 0, continue until the first non-zero number is reached, include that number in the decimal portion within the array, and the remainder of the decimal portion is spread to remainder of array elements Example: var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] arrayToNumber(n); // 100.00015 The proposal improves what is broken by not returning broken results relevant to decimal numbers. The proposal allows users to get and set any portion of a number using indexes of an array, which can then be converted back to a number. If you are failing to interpret that as useful, that is your own issue. You might as well state that Intl.NumberFormat.prototype.formatToParts does not have any use. And further, JavaScript number implementation is fine just the way that it is currently implemented, unless *you *decide that any proposal is useful. The array format is a simple data structure. Can be converted to JSON; can be extended to include a description of each digit that is a user gets or sets; e.g., n[0].description // {digit: 1, place: 'hundreds', decimalSibling: true,...etc.} > With respect, your test cases confuse the issue more than they clarify. > Questions on how you'd use this structure aside (which are still > important), your test cases *don't actually produce a structure in which > digits are accessible by nth index* (e.g., the 0-grouping behavior). FYI "respect" is irrelevant to the proposal. Do not need or care about what you consider "respect". You cannot offend this user. Not sure what you mean? What are you confused about relevant to the test cases? The code at the OP includes 1) the original proof of concept; 2) code by Stack Overflow user Shidersz <https://stackoverflow.com/users/10366495/shidersz> which fixed two bugs in the original code. Yes, the code at the OP does produce the expected result. You are misconstruing the proposal. The code already returns the expected result. Do not ask for approval for anything. Just do and let the aftermath settle to its own level. The proposal is asking you people who claim to be specification authors to _name_ each element of the resulting array, for consistency, again, the example var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] as an array users obviously do not have additional data about the values in the array. What do you call the 0 at index 1? What do you call the 5 at index 4? Before incorporating the output into an object, similar to Intl.NumberFormat.prototype.formatToParts - and including the original array in the object, or Map - am asking for standardization of the names of each digit in a _spread_ number in an array. Number to array, array to number is just the first part of the procedure. The part relevant to actually _naming_ the parts, for disambiguation, is what propose here. If you are not interested, that is fine. Do not necessarily need you to do anything. Will do for self as have and continue to do independently, and name the discrete portions of the number arbitrarily, without your input. Again, if you do not gather that this proposal is similar to and extends the functionality of Intl.NumberFormat.prototype.formatToParts, perhaps you should try to use that feature, note that "integer" and "fraction" and "minusSign" are possible return values at output, then lobby for the feature Intl.NumberFormat.prototype.formatToParts to be removed from tc39/Ecma specification, for the same reasons that you are citing at this proposal, which would then make your statement > premise that I'm challenging _consistent_. Otherwise, you have only proffered standard western academic conjecture, which can be set aside where an individual is not beholden to or reliant on western academic conjecture to proceed with anything they decide to do.
guest271314 at gmail.com (2019-03-12T17:09:20.522Z)
> That's the premise that I'm challenging. Why is it simpler, and how does > it, *in any appreciable way*, improve upon whatever you're asserting is > "broken"? The same way that Intl.NumberFormat.prototype.formatToParts does. Though takes the concept one step further by *spreading* each digit to an array - as a JavaScript number not as a JavaScript String. If the number has a decimal, the decimal portion is set at a single element of an array. If the decimal begins with a 0, continue until the first non-zero number is reached, include that number in the decimal portion within the array, and the remainder of the decimal portion is spread to remainder of array elements Example: var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] arrayToNumber(n); // 100.00015 The proposal improves what is broken by not returning broken results relevant to decimal numbers. The proposal allows users to get and set any portion of a number using indexes of an array, which can then be converted back to a number. If you are failing to interpret that as useful, that is your own issue. You might as well state that Intl.NumberFormat.prototype.formatToParts does not have any use. And further, JavaScript number implementation is fine just the way that it is currently implemented, unless *you *decide that any proposal is useful. The array format is a simple data structure. Can be converted to JSON; can be extended to include a description of each digit that is a user gets or sets; e.g., n[0].description // {digit: 1, place: 'hundreds', decimalSibling: true,...etc.} > With respect, your test cases confuse the issue more than they clarify. > Questions on how you'd use this structure aside (which are still > important), your test cases *don't actually produce a structure in which > digits are accessible by nth index* (e.g., the 0-grouping behavior). FYI "respect" is irrelevant to the proposal. Do not need or care about what you consider "respect". You cannot offend this user. Not sure what you mean? What are you confused about relevant to the test cases? The code at the OP includes 1) the original proof of concept; 2) code by Stack Overflow user Shidersz <https://stackoverflow.com/users/10366495/shidersz> which fixed two bugs in the original code. Yes, the code at the OP does produce the expected result. You are misconstruing the proposal. The code already returns the expected result. Do not ask for approval for anything. Just do and let the aftermath settle to its own level. The proposal is asking you people who claim to be specification authors to _name_ each element of the resulting array, for consistency, again, the example var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] as an array users obviously do not have additional data about the values in the array. What do you call the 0 at index 1? What do you call the 5 at index 4? Before incorporating the output into an object, similar to Intl.NumberFormat.prototype.formatToParts - and including the original array in the object, or Map - am asking for standardization of the names of each digit in a _spread_ number in an array. Number to array, array to number is just the first part of the procedure. The part relevant to actually _naming_ the parts, for disambiguation, is what propose here. If you are not interested, that is fine. Do not necessarily need you to do anything. Will do for self as have and continue to do independently, and name the discrete portions of the number arbitrarily, without your input. Again, if you do not gather that this proposal is similar to and extends the functionality of Intl.NumberFormat.prototype.formatToParts, perhaps you should try to use that feature, note that "integer" and "fraction" and "minusSign" are possible return values at output, then lobby for the feature Intl.NumberFormat.prototype.formatToParts to be removed from tc39/Ecma specification, for the same reasons that you are citing at this proposal, which would then make your statement > premise that I'm challenging _consistent_. Otherwise, you have only proffered standard western academic conjecture, which can be set aside where an individual is not beholden to or reliant on western academic conjecture to proceed with anything they decide to.
guest271314 at gmail.com (2019-03-12T17:02:04.097Z)
> That's the premise that I'm challenging. Why is it simpler, and how does > it, *in any appreciable way*, improve upon whatever you're asserting is > "broken"? The same way that Intl.NumberFormat.prototype.formatToParts does. Though takes the concept one step further by *spreading* each digit to an array. If the number has a decimal, the decimal portion is set at a single element of an array. If the decimal begins with a 0, continue until the first non-zero number is reached, include that number in the decimal portion within the array, and the remainder of the decimal portion is spread to remainder of array elements Example: var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] arrayToNumber(n); // 100.00015 The proposal improves what is broken by not returning broken results relevant to decimal numbers. The proposal allows users to get and set any portion of a number using indexes of an array, which can then be converted back to a number. If you are failing to interpret that as useful, that is your own issue. You might as well state that Intl.NumberFormat.prototype.formatToParts does not have any use. And further, JavaScript number implementation is fine just the way that it is currently implemented, unless *you *decide that any proposal is useful. The array format is a simple data structure. Can be converted to JSON; can be extended to include a description of each digit that is a user gets or sets; e.g., n[0].description // {digit: 1, place: 'hundreds', decimalSibling: true,...etc.} > With respect, your test cases confuse the issue more than they clarify. > Questions on how you'd use this structure aside (which are still > important), your test cases *don't actually produce a structure in which > digits are accessible by nth index* (e.g., the 0-grouping behavior). FYI "respect" is irrelevant to the proposal. Do not need or care about what you consider "respect". You cannot offend this user. Not sure what you mean? What are you confused about relevant to the test cases? The code at the OP includes 1) the original proof of concept; 2) code by Stack Overflow user Shidersz <https://stackoverflow.com/users/10366495/shidersz> which fixed two bugs in the original code. Yes, the code at the OP does produce the expected result. You are misconstruing the proposal. The code already returns the expected result. Do not ask for approval for anything. Just do and let the aftermath settle to its own level. The proposal is asking you people who claim to be specification authors to _name_ each element of the resulting array, for consistency, again, the example var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] as an array users obviously do not have additional data about the values in the array. What do you call the 0 at index 1? What do you call the 5 at index 4? Before incorporating the output into an object, similar to Intl.NumberFormat.prototype.formatToParts - and including the original array in the object, or Map - am asking for standardization of the names of each digit in a _spread_ number in an array. Number to array, array to number is just the first part of the procedure. The part relevant to actually _naming_ the parts, for disambiguation, is what propose here. If you are not interested, that is fine. Do not necessarily need you to do anything. Will do for self as have and continue to do independently, and name the discrete portions of the number arbitrarily, without your input. Again, if you do not gather that this proposal is similar to and extends the functionality of Intl.NumberFormat.prototype.formatToParts, perhaps you should try to use that feature, note that "integer" and "fraction" and "minusSign" are possible return values at output, then lobby for the feature Intl.NumberFormat.prototype.formatToParts to be removed from tc39/Ecma specification, for the same reasons that you are citing at this proposal, which would then make your statement > premise that I'm challenging _consistent_. Otherwise, you have only proffered standard western academic conjecture, which can be set aside where an individual is not beholden to or reliant on western academic conjecture to proceed with anything they decide to.
guest271314 at gmail.com (2019-03-12T17:01:12.206Z)
> That's the premise that I'm challenging. Why is it simpler, and how does > it, *in any appreciable way*, improve upon whatever you're asserting is > "broken"? The same way that Intl.NumberFormat.prototype.formatToParts does. Though takes the concept one step further by *spreading* each digit to an array. If the number has a decimal, the decimal portion is set at a single element of an array. If the decimal begins with a 0, continue until the first non-zero number is reached, include that number in the decimal portion within the array, and the remainder of the decimal portion is spread to remainder of array elements Example: var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] arrayToNumber(n); // 100.00015 The proposal improves what is broken by not returning broken results relevant to decimal numbers. The proposal allows users to get and set any portion of a number using indexes of an array, which can then be converted back to a number. If you are failing to interpret that as useful, that is your own issue. You might as well state that Intl.NumberFormat.prototype.formatToParts does not have any use. And further, JavaScript number implementation is fine just the way that it is currently implemented, unless *you *decide that any proposal is useful. The array format is a simple data structure. Can be converted to JSON; can be extended to include a description of each digit that is a user gets or sets; e.g., n[0].description // {digit: 1, place: 'hundreds', decimalSibling: true,...etc.} > With respect, your test cases confuse the issue more than they clarify. > Questions on how you'd use this structure aside (which are still > important), your test cases *don't actually produce a structure in which > digits are accessible by nth index* (e.g., the 0-grouping behavior). FYI "respect" is irrelevant to the proposal. Do not need or care about what you consider "respect". You cannot offend this user. Not sure what you mean? What are you confused about relevant to the test cases? The code at the OP includes 1) the original proof of concept; 2) code by Stack Overflow user Shidersz <https://stackoverflow.com/users/10366495/shidersz> which fixed two bugs in the original code. Yes, the code at the OP does produce the expected result. You are misconstruing the proposal. The code already returns the expected result. Do not ask for approval for anything. Just do and let the aftermath settle to its own level. The proposal is asking you people who claim to be specification authors to _name_ each element of the resulting array, for consistency, again, the example var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] as an array users obviously do not have additional data about the values in the array. What do you call the 0 at index 1? What do you call the 5 at index 4? Before incorporating the output into an object, similar to Intl.NumberFormat.prototype.formatToParts - and including the original array in the object, or Map - am asking for standardization of the names of each digit in a _spread_ number in an array. Number to array, array to number is just the first part of the procedure. The part relevant to actually _naming_ the parts, for disambiguation, is what propose here. If you are not interested, that is fine. Do not necessarily need you to do anything. Will do for self as have and continue to do independently, and name the discrete portions of the number arbitrarily, without your input. Again, if you do not gather that this proposal is similar to and extends the functionality of Intl.NumberFormat.prototype.formatToParts, perhaps you should try to use that feature, note that "integer" and "fraction" and "minusSign" are possible return values at output, then lobby for the feature to be removed from tc39/Ecma specification, for the same reasons that you are citing at this proposal, which would then make your > premise that I'm challenging consistent. Otherwise, you have only offered standard western academic conjecture, which can be set aside where an individual is not beholden to or reliant on western academic conjecture to proceed with anything they decide to.
guest271314 at gmail.com (2019-03-12T16:58:09.277Z)
> That's the premise that I'm challenging. Why is it simpler, and how does > it, *in any appreciable way*, improve upon whatever you're asserting is > "broken"? The same way that Intl.NumberFormat.prototype.formatToParts does. Though takes the concept one step further by *spreading* each digit to an array. If the number has a decimal, the decimal portion is set at a single element of an array. If the decimal begins with a 0, continue until the first non-zero number is reached, include that number in the decimal portion within the array, and the remainder of the decimal portion is spread to remainder of array elements Example: var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] arrayToNumber(n); // 100.00015 The proposal improves what is broken by not returning broken results relevant to decimal numbers. The proposal allows users to get and set any portion of a number using indexes of an array, which can then be converted back to a number. If you are failing to interpret that as useful, that is your own issue. You might as well state that Intl.NumberFormat.prototype.formatToParts does not have any use. And further, JavaScript number implementation is fine just the way that it is currently implemented, unless *you *decide that any proposal is useful. The array format is a simple data structure. Can be converted to JSON; can be extended to include a description of each digit that is a user gets or sets; e.g., n[0].description // {digit: 1, place: 'hundreds', decimalSibling: true,...etc.} > With respect, your test cases confuse the issue more than they clarify. > Questions on how you'd use this structure aside (which are still > important), your test cases *don't actually produce a structure in which > digits are accessible by nth index* (e.g., the 0-grouping behavior). Not sure what you mean? What are you confused about relevant to the test cases? The code at the OP includes 1) the original proof of concept; 2) code by Stack Overflow user Shidersz <https://stackoverflow.com/users/10366495/shidersz> which fixed two bugs in the original code. Yes, the code at the OP does produce the expected result. You are misconstruing the proposal. The code already returns the expected result. Do not ask for approval for anything. Just do and let the aftermath settle to its own level. The proposal is asking you people who claim to be specification authors to _name_ each element of the resulting array, for consistency, again, the example var n = numberToArray(100.00015); // [1, 0, 0, 0.0001, 5] as an array users obviously do not have additional data about the values in the array. What do you call the 0 at index 1? What do you call the 5 at index 4? Before incorporating the output into an object, similar to Intl.NumberFormat.prototype.formatToParts - and including the original array in the object, or Map - am asking for standardization of the names of each digit in a _spread_ number in an array. Number to array, array to number is just the first part of the procedure. The part relevant to actually _naming_ the parts, for disambiguation, is what propose here. If you are not interested, that is fine. Do not necessarily need you to do anything. Will do for self as have and continue to do independently, and name the discrete portions of the number arbitrarily, without your input. Again, if you do not gather that this proposal is similar to and extends the functionality of Intl.NumberFormat.prototype.formatToParts, perhaps you should try to use that feature, note that "integer" and "fraction" and "minusSign" are possible return values at output, then lobby for the feature to be removed from Ecma specification, for the same reasons that you are citing at this proposal, which would then make your premise that I'm challenging consistent. Otherwise, you have only offered standard western academic conjecture, which can be set aside where an individual is not beholden to or reliant on western academic conjecture to proceed with anything they decide to. With respect, "respect" is irrelevant to the proposal. Do not need or care about what you consider "respect". You cannot offend this user.