# Proposal: Range Expression

# Naveen Chawla (10 months 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 (10 months 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 (9 months 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 } }`