Proposal: Range Expression
# Naveen Chawla (6 years ago)
I like it. I might prefer it in square brackets e.g. [ x ... y ] ?
I like it. I might prefer it in square brackets e.g. [ x ... y ] ?
On Sun, 18 Aug 2019 at 23:24, Artem Kobzar <a.kobzar.nlt at gmail.com> wrote:
> ### Proposal: Range Expression
>
> The proposal based on one of the worst things in JavaScript Arrays.
>
> If i as developer want to make sequence of some numbers or characters then
> i need to use weird methods like `Array.from`, manual filling or
> imperative-style array filling.
>
> ```js
> const group1 = [1, 2, 3, 4, 5, ...]// manual filling
> const group2= Array.from({ length: 15 }).map((_, i) => i + 1);
> const group3 = [];
> for (let i = 0; i < 15; i++) group3[i] = i + 1;
> ```
>
> This ways to describe range sequence is huge and unreadable.
>
>
> So, my proposal is: range expression which help to create lazy iterable
> range sequence in declarative way.
>
> ```js
> const group0 = 1...15; // from 1 to 15
> const group1 = 15...1; // from 15 to 1
> const group2 = 1n...15n // from 'a' to 'z'
> const group3 = 'a'...'z' // from 'a' to 'z'
> const group4 = 82... // lazy collection of numbers
>
> for (const odd of 1...85) {
> // ...
> }
>
> // in combination with https://github.com/tc39/proposal-iterator-helpers
> const allEven = (1...100).filter(isEven);
> ```
>
> So, this operator is syntax sugar for the next generator which create lazy
> iterable sequence:
>
> ```js
> function* range(start, end, second) {
> validate(start, end, second)// type assertion of start, second and end
> const step = difference(start, second); // difference calculation
> let current = start;
> while(isNotEnd(current, end)) { // logic for negative step and different
> types
> yield current;
> current = next(current, step); // function which change current number
> | bigint | string by difference
> }
> }
> ```
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190819/e949d9cd/attachment.html># Cyril Auburtin (6 years ago)
I'd prefer to have it in slice-notation tc39/proposal-slice-notation#1
[...0:8] // [0,1,2,3,4,5,6,7]
I'd prefer to have it in slice-notation
https://github.com/tc39/proposal-slice-notation/issues/1#issuecomment-522227270
```js
[...0:8] // [0,1,2,3,4,5,6,7]
```
On Mon, Aug 19, 2019 at 9:34 AM Naveen Chawla <naveen.chwl at gmail.com> wrote:
> I like it. I might prefer it in square brackets e.g. [ x ... y ] ?
>
> On Sun, 18 Aug 2019 at 23:24, Artem Kobzar <a.kobzar.nlt at gmail.com> wrote:
>
>> ### Proposal: Range Expression
>>
>> The proposal based on one of the worst things in JavaScript Arrays.
>>
>> If i as developer want to make sequence of some numbers or characters
>> then i need to use weird methods like `Array.from`, manual filling or
>> imperative-style array filling.
>>
>> ```js
>> const group1 = [1, 2, 3, 4, 5, ...]// manual filling
>> const group2= Array.from({ length: 15 }).map((_, i) => i + 1);
>> const group3 = [];
>> for (let i = 0; i < 15; i++) group3[i] = i + 1;
>> ```
>>
>> This ways to describe range sequence is huge and unreadable.
>>
>>
>> So, my proposal is: range expression which help to create lazy iterable
>> range sequence in declarative way.
>>
>> ```js
>> const group0 = 1...15; // from 1 to 15
>> const group1 = 15...1; // from 15 to 1
>> const group2 = 1n...15n // from 'a' to 'z'
>> const group3 = 'a'...'z' // from 'a' to 'z'
>> const group4 = 82... // lazy collection of numbers
>>
>> for (const odd of 1...85) {
>> // ...
>> }
>>
>> // in combination with https://github.com/tc39/proposal-iterator-helpers
>> const allEven = (1...100).filter(isEven);
>> ```
>>
>> So, this operator is syntax sugar for the next generator which create
>> lazy iterable sequence:
>>
>> ```js
>> function* range(start, end, second) {
>> validate(start, end, second)// type assertion of start, second and end
>> const step = difference(start, second); // difference calculation
>> let current = start;
>> while(isNotEnd(current, end)) { // logic for negative step and
>> different types
>> yield current;
>> current = next(current, step); // function which change current
>> number | bigint | string by difference
>> }
>> }
>> ```
>> _______________________________________________
>> es-discuss mailing list
>> es-discuss at mozilla.org
>> https://mail.mozilla.org/listinfo/es-discuss
>>
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190819/59e9ff0d/attachment-0001.html># Cyril Auburtin (6 years ago)
Here is a PR for adding SliceExpression to proposal-slice-notation (that could probably be renamed proposal-slice-expression if it's accepted) tc39/proposal-slice-notation#32
Here is a PR for adding SliceExpression to proposal-slice-notation (that
could probably be renamed proposal-slice-expression if it's accepted)
https://github.com/tc39/proposal-slice-notation/pull/32
On Mon, Aug 19, 2019 at 10:29 AM Cyril Auburtin <cyril.auburtin at gmail.com>
wrote:
> I'd prefer to have it in slice-notation
> https://github.com/tc39/proposal-slice-notation/issues/1#issuecomment-522227270
>
> ```js
> [...0:8] // [0,1,2,3,4,5,6,7]
> ```
>
> On Mon, Aug 19, 2019 at 9:34 AM Naveen Chawla <naveen.chwl at gmail.com>
> wrote:
>
>> I like it. I might prefer it in square brackets e.g. [ x ... y ] ?
>>
>> On Sun, 18 Aug 2019 at 23:24, Artem Kobzar <a.kobzar.nlt at gmail.com>
>> wrote:
>>
>>> ### Proposal: Range Expression
>>>
>>> The proposal based on one of the worst things in JavaScript Arrays.
>>>
>>> If i as developer want to make sequence of some numbers or characters
>>> then i need to use weird methods like `Array.from`, manual filling or
>>> imperative-style array filling.
>>>
>>> ```js
>>> const group1 = [1, 2, 3, 4, 5, ...]// manual filling
>>> const group2= Array.from({ length: 15 }).map((_, i) => i + 1);
>>> const group3 = [];
>>> for (let i = 0; i < 15; i++) group3[i] = i + 1;
>>> ```
>>>
>>> This ways to describe range sequence is huge and unreadable.
>>>
>>>
>>> So, my proposal is: range expression which help to create lazy iterable
>>> range sequence in declarative way.
>>>
>>> ```js
>>> const group0 = 1...15; // from 1 to 15
>>> const group1 = 15...1; // from 15 to 1
>>> const group2 = 1n...15n // from 'a' to 'z'
>>> const group3 = 'a'...'z' // from 'a' to 'z'
>>> const group4 = 82... // lazy collection of numbers
>>>
>>> for (const odd of 1...85) {
>>> // ...
>>> }
>>>
>>> // in combination with https://github.com/tc39/proposal-iterator-helpers
>>> const allEven = (1...100).filter(isEven);
>>> ```
>>>
>>> So, this operator is syntax sugar for the next generator which create
>>> lazy iterable sequence:
>>>
>>> ```js
>>> function* range(start, end, second) {
>>> validate(start, end, second)// type assertion of start, second and end
>>> const step = difference(start, second); // difference calculation
>>> let current = start;
>>> while(isNotEnd(current, end)) { // logic for negative step and
>>> different types
>>> yield current;
>>> current = next(current, step); // function which change current
>>> number | bigint | string by difference
>>> }
>>> }
>>> ```
>>> _______________________________________________
>>> es-discuss mailing list
>>> es-discuss at mozilla.org
>>> https://mail.mozilla.org/listinfo/es-discuss
>>>
>> _______________________________________________
>> es-discuss mailing list
>> es-discuss at mozilla.org
>> https://mail.mozilla.org/listinfo/es-discuss
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190820/85a99007/attachment.html>
Proposal: Range Expression
The proposal based on one of the worst things in JavaScript Arrays.
If i as developer want to make sequence of some numbers or characters then i need to use weird methods like
Array.from, manual filling or imperative-style array filling.const group1 = [1, 2, 3, 4, 5, ...]// manual filling const group2= Array.from({ length: 15 }).map((_, i) => i + 1); const group3 = []; for (let i = 0; i < 15; i++) group3[i] = i + 1;This ways to describe range sequence is huge and unreadable.
So, my proposal is: range expression which help to create lazy iterable range sequence in declarative way.
const group0 = 1...15; // from 1 to 15 const group1 = 15...1; // from 15 to 1 const group2 = 1n...15n // from 'a' to 'z' const group3 = 'a'...'z' // from 'a' to 'z' const group4 = 82... // lazy collection of numbers for (const odd of 1...85) { // ... } // in combination with https://github.com/tc39/proposal-iterator-helpers const allEven = (1...100).filter(isEven);So, this operator is syntax sugar for the next generator which create lazy iterable sequence:
function* range(start, end, second) { validate(start, end, second)// type assertion of start, second and end const step = difference(start, second); // difference calculation let current = start; while(isNotEnd(current, end)) { // logic for negative step and different types yield current; current = next(current, step); // function which change current number | bigint | string by difference } }### Proposal: Range Expression The proposal based on one of the worst things in JavaScript Arrays. If i as developer want to make sequence of some numbers or characters then i need to use weird methods like `Array.from`, manual filling or imperative-style array filling. ```js const group1 = [1, 2, 3, 4, 5, ...]// manual filling const group2= Array.from({ length: 15 }).map((_, i) => i + 1); const group3 = []; for (let i = 0; i < 15; i++) group3[i] = i + 1; ``` This ways to describe range sequence is huge and unreadable. So, my proposal is: range expression which help to create lazy iterable range sequence in declarative way. ```js const group0 = 1...15; // from 1 to 15 const group1 = 15...1; // from 15 to 1 const group2 = 1n...15n // from 'a' to 'z' const group3 = 'a'...'z' // from 'a' to 'z' const group4 = 82... // lazy collection of numbers for (const odd of 1...85) { // ... } // in combination with https://github.com/tc39/proposal-iterator-helpers const allEven = (1...100).filter(isEven); ``` So, this operator is syntax sugar for the next generator which create lazy iterable sequence: ```js function* range(start, end, second) { validate(start, end, second)// type assertion of start, second and end const step = difference(start, second); // difference calculation let current = start; while(isNotEnd(current, end)) { // logic for negative step and different types yield current; current = next(current, step); // function which change current number | bigint | string by difference } } ``` -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190819/b4595054/attachment.html>