Re: Sealed & Frozen Object/Array Syntax

2017-07-17 Thread Andreas Rossberg 
https://web.archive.org/web/20110509070204/http://wiki.ecmascript.org:80/doku.php?id=strawman:records
https://web.archive.org/web/20110509070209/http://wiki.ecmascript.org:80/doku.php?id=strawman:tuples

On 17 July 2017 at 10:51, Keith Cirkel  wrote:

> As functional programming because more mainstream - developers are leaning
> more and more on immutability - with tools like immutable.js. However there
> exists perfectly good solutions inside of JS with Object.seal &
> Object.freeze.
>
> I propose making a short syntax to allow for creating of sealed/frozen
> objects that looks like this:
>
> ```js
> {| foo: 1 |} // same as Object.seal({ foo: 1 })
> {# foo: 1 #} // same as Object.freeze({ foo: 1 })
>
> [| 1, 2, 3 |] // same as Object.seal([ 1, 2, 3 ])
> [# 1, 2, 3 #] // same as Object.freeze([ 1, 2, 3 ])
>
> // Deep frozen objects becomes a case of using frozen notation all the way
> down:
> {# foo: {# bar: 1 #} #} // same as Object.freeze({ foo: Object.freeze({
> bar: 1 }) })
> [# [# 1, 2 #], [# 3, 4 #] #] // same as Object.freeze([Object.freeze([1,2]),
> Object.freeze([3, 4]])
> ```
>
> This short syntax allows for a much more expressive way of writing/reading
> sealed & frozen objects. I look forward to a discussion about this.
>
> ___
> es-discuss mailing list
> es-discuss@mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
>
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss

Re: Sealed & Frozen Object/Array Syntax

2017-07-17 Thread Isiah Meadows 
How about no. That is a very wasteful way to model immutable data
(which isn't used by most JS developers to begin with), and it's also
a very bad way to model the syntax. You also have a potential syntax
conflict (requires a substantial cover grammar to avoid) with stage-2
private fields:

```js
class C {
#foo = 1;
list() { return [#foo#] }
}
```

In general, we *should* be making it easier for decently good
libraries (e.g. Immutable.js, mori) to integrate with the language,
not provide nice-to-haves that only haphazardly replace them.
-

Isiah Meadows
m...@isiahmeadows.com

Looking for web consulting? Or a new website?
Send me an email and we can get started.
www.isiahmeadows.com


On Mon, Jul 17, 2017 at 4:51 AM, Keith Cirkel
 wrote:
> As functional programming because more mainstream - developers are leaning
> more and more on immutability - with tools like immutable.js. However there
> exists perfectly good solutions inside of JS with Object.seal &
> Object.freeze.
>
> I propose making a short syntax to allow for creating of sealed/frozen
> objects that looks like this:
>
> ```js
> {| foo: 1 |} // same as Object.seal({ foo: 1 })
> {# foo: 1 #} // same as Object.freeze({ foo: 1 })
>
> [| 1, 2, 3 |] // same as Object.seal([ 1, 2, 3 ])
> [# 1, 2, 3 #] // same as Object.freeze([ 1, 2, 3 ])
>
> // Deep frozen objects becomes a case of using frozen notation all the way
> down:
> {# foo: {# bar: 1 #} #} // same as Object.freeze({ foo: Object.freeze({ bar:
> 1 }) })
> [# [# 1, 2 #], [# 3, 4 #] #] // same as Object.freeze([Object.freeze([1,2]),
> Object.freeze([3, 4]])
> ```
>
> This short syntax allows for a much more expressive way of writing/reading
> sealed & frozen objects. I look forward to a discussion about this.
>
> ___
> es-discuss mailing list
> es-discuss@mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss

Re: Sealed & Frozen Object/Array Syntax

2017-07-17 Thread J Decker 
On Mon, Jul 17, 2017 at 2:19 AM, Michał Wadas  wrote:

> However there exists perfectly good solutions inside of JS with
> Object.seal & Object.freeze.
>
> Actually these solutions are very bad for immutable data structures,
> because creating deep copy of object on every modification cause very
>

If you're mutating an immutable object you're kinda breaking the rules and
it shouldn't have been immutable in the first place.


> significant overhead. This overhead can be significant even in optimized
> Haskell implementations (link
> ) and for imperative
> languages it's even worser.
>
> Immutable.js use many of tricks to avoid deep copying.
>
> On Mon, Jul 17, 2017 at 10:51 AM, Keith Cirkel <
> esdisc...@keithcirkel.co.uk> wrote:
>
>> As functional programming because more mainstream - developers are
>> leaning more and more on immutability - with tools like immutable.js.
>> However there exists perfectly good solutions inside of JS with Object.seal
>> & Object.freeze.
>>
>> I propose making a short syntax to allow for creating of sealed/frozen
>> objects that looks like this:
>>
>> ```js
>> {| foo: 1 |} // same as Object.seal({ foo: 1 })
>> {# foo: 1 #} // same as Object.freeze({ foo: 1 })
>>
>> [| 1, 2, 3 |] // same as Object.seal([ 1, 2, 3 ])
>> [# 1, 2, 3 #] // same as Object.freeze([ 1, 2, 3 ])
>>
>> // Deep frozen objects becomes a case of using frozen notation all the
>> way down:
>> {# foo: {# bar: 1 #} #} // same as Object.freeze({ foo: Object.freeze({
>> bar: 1 }) })
>> [# [# 1, 2 #], [# 3, 4 #] #] // same as Object.freeze([Object.freeze([1,2]),
>> Object.freeze([3, 4]])
>> ```
>>
>> This short syntax allows for a much more expressive way of
>> writing/reading sealed & frozen objects. I look forward to a discussion
>> about this.
>>
>> ___
>> es-discuss mailing list
>> es-discuss@mozilla.org
>> https://mail.mozilla.org/listinfo/es-discuss
>>
>>
>
> ___
> es-discuss mailing list
> es-discuss@mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
>
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss

Re: Sealed & Frozen Object/Array Syntax

2017-07-17 Thread Michał Wadas 
However there exists perfectly good solutions inside of JS with Object.seal
& Object.freeze.

Actually these solutions are very bad for immutable data structures,
because creating deep copy of object on every modification cause very
significant overhead. This overhead can be significant even in optimized
Haskell implementations (link
) and for imperative
languages it's even worser.

Immutable.js use many of tricks to avoid deep copying.

On Mon, Jul 17, 2017 at 10:51 AM, Keith Cirkel 
wrote:

> As functional programming because more mainstream - developers are leaning
> more and more on immutability - with tools like immutable.js. However there
> exists perfectly good solutions inside of JS with Object.seal &
> Object.freeze.
>
> I propose making a short syntax to allow for creating of sealed/frozen
> objects that looks like this:
>
> ```js
> {| foo: 1 |} // same as Object.seal({ foo: 1 })
> {# foo: 1 #} // same as Object.freeze({ foo: 1 })
>
> [| 1, 2, 3 |] // same as Object.seal([ 1, 2, 3 ])
> [# 1, 2, 3 #] // same as Object.freeze([ 1, 2, 3 ])
>
> // Deep frozen objects becomes a case of using frozen notation all the way
> down:
> {# foo: {# bar: 1 #} #} // same as Object.freeze({ foo: Object.freeze({
> bar: 1 }) })
> [# [# 1, 2 #], [# 3, 4 #] #] // same as Object.freeze([Object.freeze([1,2]),
> Object.freeze([3, 4]])
> ```
>
> This short syntax allows for a much more expressive way of writing/reading
> sealed & frozen objects. I look forward to a discussion about this.
>
> ___
> es-discuss mailing list
> es-discuss@mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
>
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss

Sealed & Frozen Object/Array Syntax

2017-07-17 Thread Keith Cirkel 
As functional programming because more mainstream - developers are leaning
more and more on immutability - with tools like immutable.js. However there
exists perfectly good solutions inside of JS with Object.seal &
Object.freeze.

I propose making a short syntax to allow for creating of sealed/frozen
objects that looks like this:

```js
{| foo: 1 |} // same as Object.seal({ foo: 1 })
{# foo: 1 #} // same as Object.freeze({ foo: 1 })

[| 1, 2, 3 |] // same as Object.seal([ 1, 2, 3 ])
[# 1, 2, 3 #] // same as Object.freeze([ 1, 2, 3 ])

// Deep frozen objects becomes a case of using frozen notation all the way
down:
{# foo: {# bar: 1 #} #} // same as Object.freeze({ foo: Object.freeze({
bar: 1 }) })
[# [# 1, 2 #], [# 3, 4 #] #] // same as
Object.freeze([Object.freeze([1,2]), Object.freeze([3, 4]])
```

This short syntax allows for a much more expressive way of writing/reading
sealed & frozen objects. I look forward to a discussion about this.
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss