guest271314 (2019-03-08T17:23:53.000Z)
The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. That is not the goal of
this proposal.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

>From perspective here, the third example provides the output (in array
representation) which can be manipulated more extensively than the previous
two examples.

[2, .718281828459045] // example 1

[2.7, 18281828459045] // example 2

[2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values.

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?

On Fri, Mar 8, 2019 at 4:45 PM Jeremy Martin <jmar777 at gmail.com> wrote:

> Is it fair to suggest that transforming numeric values to and from arrays
> isn't the ultimate goal of this proposal? Based on your examples, it seems
> there are specific manipulations you would like to be able to perform to
> numeric values, and your contention is that these manipulations would be
> more straightforward if various components of that value (i.e., the
> individual digits, the decimal location, and the sign) were represented in
> a "more structured" way (i.e., an array). Is that much a fair assessment?
>
> If that's the case, could you expand on the specific manipulations
> themselves? Preferably something more explicit and scoped than linking out
> to one of these external references, if possible.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190308/2ff13647/attachment.html>
guest271314 at gmail.com (2019-03-08T19:19:48.000Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The goal of
this proposal *is not* asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in 

    ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"]

An additional perspective

> just a thought how about 123.001 being represented as [[1,2,3],[0,0,1]] and I may be missing the point I suppose but could extend that to 123.001 -> [[1],[1,2,3],[0,0,1]] and -123.001 -> [[0],[1,2,3],[0,0,1]] where [[Modifier],[Int],[Decimal]] – Bibberty Jan 30 at 3:53 https://stackoverflow.com/questions/54433007/number-integer-or-decimal-to-array-array-to-number-integer-or-decimal-witho#comment95675757_54433007

How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation, for several reasons, including but not limited to, again, consistency; and having to convert each element or index of the Array to a Number to further process or (re-)modify the output; and the "cost" of String conversion re calculation of .length; to illustrate that JavaScript floating-point numbers are still "broken", in the absence of a BigDecimal; etc.) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals (the "sign" of an integer or decimal)
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though that is not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. The closest that can cite is Intl.NumberFormat.prototype.formatToParts https://tc39.github.io/ecma402/#sec-Intl.NumberFormat.prototype.formatToParts. the resulting object contains values that are strings, and not expanded, or spread, to an array similar to example 3. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T19:10:14.959Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The goal of
this proposal *is not* asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in 

    ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"]

An additional perspective

> just a thought how about 123.001 being represented as [[1,2,3],[0,0,1]] and I may be missing the point I suppose but could extend that to 123.001 -> [[1],[1,2,3],[0,0,1]] and -123.001 -> [[0],[1,2,3],[0,0,1]] where [[Modifier],[Int],[Decimal]] – Bibberty Jan 30 at 3:53 https://stackoverflow.com/questions/54433007/number-integer-or-decimal-to-array-array-to-number-integer-or-decimal-witho#comment95675757_54433007

How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation, for several reasons, including but not limited to, again, consistency; and having to convert each element or index of the Array to a Number to further process or (re-)modify the output; and the "cost" of String conversion re calculation of .length; to illustrate that JavaScript floating-point numbers are still "broken", in the absence of a BigDecimal; etc.) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals (the "sign" of an integer or decimal)
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though that is not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T19:07:22.072Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The goal of
this proposal *is not* asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in 

    ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"]

An additional perspective

> just a thought how about 123.001 being represented as [[1,2,3],[0,0,1]] and I may be missing the point I suppose but could extend that to 123.001 -> [[1],[1,2,3],[0,0,1]] and -123.001 -> [[0],[1,2,3],[0,0,1]] where [[Modifier],[Int],[Decimal]] – Bibberty Jan 30 at 3:53 https://stackoverflow.com/questions/54433007/number-integer-or-decimal-to-array-array-to-number-integer-or-decimal-witho#comment95675757_54433007

How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation, for several reasons, including but not limited to, again, consistency; and having to convert each element or index of the Array to a Number to further process or (re-)modify the output; and the "cost" of String conversion re calculation of .length; to illustrate that JavaScript floating-point numbers are still "broken", in the absence of a BigDecimal; etc.) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though that is not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T18:52:43.331Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The goal of
this proposal *is not* asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in 

    ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"]

How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation, for several reasons, including but not limited to, again, consistency; and having to convert each element or index of the Array to a Number to further process or (re-)modify the output; and the "cost" of String conversion re calculation of .length; to illustrate that JavaScript floating-point numbers are still "broken", in the absence of a BigDecimal; etc.) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though that is not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T18:23:38.248Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in 

    ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"]

How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation, for several reasons, including but not limited to, again, consistency; and having to convert each element or index of the Array to a Number to further process or (re-)modify the output; and the "cost" of String conversion re calculation of .length; to illustrate that JavaScript floating-point numbers are still "broken", in the absence of a BigDecimal; etc.) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though that is not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T18:07:22.545Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in 

    ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"]

. 

How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation, for several reasons, including but not limited to, again, consistency; and having to convert each element or index of the Array to a Number to further process or (re-)modify the output; and the "cost" of String conversion re calculation of .length; to illustrate that JavaScript floating-point numbers are still "broken", in the absence of a BigDecimal; etc.) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though that is not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T18:05:43.834Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in 

    ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"]

. 

How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation, for several reasons, including but not limited to, again, consistency; and having to convert each element or index of the Array to a Number to further process or (re-)modify the output) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though that is not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T18:02:34.994Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

(Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"])


How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though that is not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T18:01:20.198Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

(Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"])


How should those three (or four, including the String conversion method that was specifically and explicitly avoided during own experimentation) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:59:58.715Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

(Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"])


How should those three (or four, including the String conversion method that was specifically avoided during own experimentation) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:57:56.630Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

(Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"])


How should those three (or four, including the String conversion method that was specifically avoided during own experimentation) examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is also no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:51:23.335Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3

(Note, a 4th possible output, using the approach at https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-18, without any other modifications, would result in ["2", ".", "7", "1", "8", "2", "8", "1", "8", "2", "8", "4", "5", "9"])


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is also no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:42:02.852Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input/Output <---> Output/Input

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is also no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:39:48.702Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment. Developers in the wild can call the procedure whatever they want right now and will not be incorrect, as no specification or standard defines the procedure or the possible outputs. Specification composition for JavaScript language is what this body is allegedly about, correct?

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input <----------> Output

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is also no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:37:09.505Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment.

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input <----------> Output

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion. If you folks want to take up the coding part relevant to adding methods to Number and/or Math and Array, that is fine. Though not the gist of this proposal. The proposal suggests that the outputs should be *specified* in a clear manner.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is also no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:35:07.901Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment.

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed; e.g.,

    Input <----------> Output

    -123               [-1,-2,-3]



Goal: For consistency and uniformity as to what the output is, to avoid confusion.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is also no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:32:51.431Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment.

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed. Goal: For consistency and uniformity as to what the output is, to avoid confusion.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values. Also, there is also no *standard* for the procedure in code; and no *standard* for how the various possible outputs are *named*. E.g., how does a developer differentiate between the output at example 1 from the output at example 3, *by convention, or common name*?

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:30:15.634Z)
> Is it fair to suggest that transforming numeric values to and from arrays isn't the ultimate goal of this proposal? 

That is a fair assessment.

> Based on your examples, it seems there are specific manipulations you would like to be able to perform to numeric values, and your contention is that these manipulations would be more straightforward if various components of that value (i.e., the individual digits, the decimal location, and the sign) were represented in a "more structured" way (i.e., an array). Is that much a fair assessment?

Yes, that is also a fair assessment.

The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed. Goal: For consistency and uniformity as to what the output is, to avoid confusion.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values.

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:28:42.721Z)
The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output. Also, representation of negative integers and decimals
could be addressed. Goal: For consistency and uniformity as to what the output is, to avoid confusion.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values.

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?
guest271314 at gmail.com (2019-03-08T17:26:55.439Z)
The code for "transforming" numeric values to array and array to numeric
value has at least one complete implementation. The the goal of
this proposal is not asking for code to achieve the requirement.

The goal of this proposal is to suggest to this body to take up the task of
defining the various manners in which that transformation can be achieved,
as illustrated at the example for the number *e* at
https://esdiscuss.org/topic/fwd-proposal-1-number-integer-or-decimal-to-array-2-array-to-number-integer-or-decimal#content-21
.

From perspective here, the third example provides the output (in array representation) which can be manipulated more extensively than the previous
two examples.

    [2, .718281828459045] // example 1

    [2.7, 18281828459045] // example 2

    [2, 0.7, 1, 8, 2, 8, 1, 8, 2, 8, 4, 5, 9] // example 3


How should those three examples be named for disambiguation as to the
output?

If this body does decide to take up the matter of actually defining Number
and/or Math, and Array methods to perform the conversions, it would be
helpful if each of the three (and potentially more) possible outputs have a
clearly defined name for that output.

AFAIK, there is no prior art relevant to conversion or "transforming"
JavaScript numeric values to array and array to numeric values.

Does the above make sense to you relevant to the purpose of this proposal
and what this proposal actually suggests?