[ruby-core:69012] [Ruby trunk - Feature #11105] [Open] ES6-like hash literals

[ruby-core:69012] [Ruby trunk - Feature #11105] [Open] ES6-like hash literals

[shugo]

Issue #11105 has been reported by Shugo Maeda.

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69013] Re: [Ruby trunk - Feature #11105] [Open] ES6-like hash literals

[Matthew Kerwin]

[-- Attachment #1: Type: text/plain, Size: 250 bytes --]

​Shugo Maeda wrote:
> Why not support ECMAScript6-like hash literals?
>

Does it make code easier to read, or just easier to write? Personally I
find it a bit confusing/obfuscated.​

-- 
  Matthew Kerwin
  http://matthew.kerwin.net.au/

[-- Attachment #2: Type: text/html, Size: 1007 bytes --]

[ruby-core:69014] Problem with redmine (was: Re: [Ruby trunk - Feature #11105] [Open] ES6-like hash literals)

["Martin J. Dürst"]

I tried to reply to Shugo on bugs.ruby-lang.org. However, I got the 
following validation message:

"% Done is not included in the list"

I do not know why I would have to indicate "% Done" on a feature that we 
only just started discussing. I also don't know where/how I would be 
indicating this (I could easily set the percentage to 0 if I knew where 
to do that).

Regards,    Martin.

On 2015/04/29 09:32, shugo@ruby-lang.org wrote:
> Issue #11105 has been reported by Shugo Maeda.
>
> ----------------------------------------
> Feature #11105: ES6-like hash literals
> https://bugs.ruby-lang.org/issues/11105
>
> * Author: Shugo Maeda
> * Status: Open
> * Priority: Normal
> * Assignee:
> ----------------------------------------
> Why not support ECMAScript6-like hash literals?
>
> For example,
>
>      {x, y}
>
> is equivalent to:
>
>      {x: x, y: y}
>
> For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:
>
>      a = 1
>      B = 2
>      $c = 3
>      @d = 4
>      @@e = 5
>      p({a, B, $c, @d, @@e, f: 6})
>      #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}
>
>
> ---Files--------------------------------
> 0001-support-ES6-like-hash-literals.patch (3.88 KB)
>
>

[ruby-core:69015] Re: [Ruby trunk - Feature #11105] [Open] ES6-like hash literals

[Vít Ondruch]

I really miss the times where hash rockets, e.g. `{:x => x, :y => y}`,
was the only option. I find `{x: x, y: y}` less readable and `{x, y}` is
totally unreadable IMO.


Vít


P.S. And yes, Redmine is broken :/


Dne 29.4.2015 v 02:32 shugo@ruby-lang.org napsal(a):
> Issue #11105 has been reported by Shugo Maeda.
>
> ----------------------------------------
> Feature #11105: ES6-like hash literals
> https://bugs.ruby-lang.org/issues/11105
>
> * Author: Shugo Maeda
> * Status: Open
> * Priority: Normal
> * Assignee: 
> ----------------------------------------
> Why not support ECMAScript6-like hash literals?
>
> For example,
>
>     {x, y}
>
> is equivalent to:
>
>     {x: x, y: y}
>
> For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:
>
>     a = 1
>     B = 2
>     $c = 3
>     @d = 4
>     @@e = 5
>     p({a, B, $c, @d, @@e, f: 6})
>     #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}
>
>
> ---Files--------------------------------
> 0001-support-ES6-like-hash-literals.patch (3.88 KB)
>
>

[ruby-core:69019] Re: Problem with redmine (was: Re: [Ruby trunk - Feature #11105] [Open] ES6-like hash literals)

[SHIBATA Hiroshi]

Hi Martin.

I fixed this issue. it is caused by latest version of redmine.
Please try to report again.

Thanks.

On Wed, Apr 29, 2015 at 2:02 PM, "Martin J. Dürst"
<duerst@it.aoyama.ac.jp> wrote:
> I tried to reply to Shugo on bugs.ruby-lang.org. However, I got the
> following validation message:
>
> "% Done is not included in the list"
>
> I do not know why I would have to indicate "% Done" on a feature that we
> only just started discussing. I also don't know where/how I would be
> indicating this (I could easily set the percentage to 0 if I knew where to
> do that).
>
> Regards,    Martin.
>
> On 2015/04/29 09:32, shugo@ruby-lang.org wrote:
>>
>> Issue #11105 has been reported by Shugo Maeda.
>>
>> ----------------------------------------
>> Feature #11105: ES6-like hash literals
>> https://bugs.ruby-lang.org/issues/11105
>>
>> * Author: Shugo Maeda
>> * Status: Open
>> * Priority: Normal
>> * Assignee:
>> ----------------------------------------
>> Why not support ECMAScript6-like hash literals?
>>
>> For example,
>>
>>      {x, y}
>>
>> is equivalent to:
>>
>>      {x: x, y: y}
>>
>> For convenience, the prefix of global, instance, and class variables
>> should be removed from the key name as follows:
>>
>>      a = 1
>>      B = 2
>>      $c = 3
>>      @d = 4
>>      @@e = 5
>>      p({a, B, $c, @d, @@e, f: 6})
>>      #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}
>>
>>
>> ---Files--------------------------------
>> 0001-support-ES6-like-hash-literals.patch (3.88 KB)
>>
>>
>



-- 
SHIBATA Hiroshi shibata.hiroshi@gmail.com
http://www.hsbt.org/

[ruby-core:69021] [Ruby trunk - Feature #11105] ES6-like hash literals

[shugo]

Issue #11105 has been updated by Shugo Maeda.


2015-04-29 10:19 GMT+09:00 Matthew Kerwin <matthew@kerwin.net.au>:
> Shugo Maeda wrote:
>> Why not support ECMAScript6-like hash literals?
>> 
>
> Does it make code easier to read, or just easier to write? Personally I find
> it a bit confusing/obfuscated.

The proposed syntax contributes to readability because it reduces redundancy and
tells us that a key has the same name as the corresponding variable.

For example, it is obvious that only name has a different name from
the corresponding variable in the following code:

    h = {
      name: username,
      password,
      e_mail
    }


----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52277

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69023] Re: [Ruby trunk - Feature #11105] ES6-like hash literals

[Besnik Ruka]

[-- Attachment #1: Type: text/plain, Size: 2502 bytes --]

It does look easier to read but feels like it would be harder to write and
debug.

What if you're typing in a hurry, or doing a lot of copy/paste and somehow
you accidentally omit a key? Currently the interpreter would raise a syntax
error immediately, but with this you would get cryptic logic bugs where the
size of the hash is correct, but the key you want is missing.

Also this pretty much means you can't have an expression as the value i.e.
  h = {
    name.upcase,
    email
  }

Another issue might be that this basically ties your hash to the naming of
your variables:

  def sanitize_name(name, email)
    name = name.upcase
    return { name, email }
  end

Which looks fine, but if later on i decide to go back and rename my local
variable, I'd have to go find everywhere i've used that hash and make sure
the key is changed properly. Not sure I want that kind of coupling.

None of these are deal breakers, but things to consider.

On Wed, Apr 29, 2015 at 9:06 AM, <shugo@ruby-lang.org> wrote:

> Issue #11105 has been updated by Shugo Maeda.
>
>
> 2015-04-29 10:19 GMT+09:00 Matthew Kerwin <matthew@kerwin.net.au>:
> > Shugo Maeda wrote:
> >> Why not support ECMAScript6-like hash literals?
> >>
> >
> > Does it make code easier to read, or just easier to write? Personally I
> find
> > it a bit confusing/obfuscated.
>
> The proposed syntax contributes to readability because it reduces
> redundancy and
> tells us that a key has the same name as the corresponding variable.
>
> For example, it is obvious that only name has a different name from
> the corresponding variable in the following code:
>
>     h = {
>       name: username,
>       password,
>       e_mail
>     }
>
>
> ----------------------------------------
> Feature #11105: ES6-like hash literals
> https://bugs.ruby-lang.org/issues/11105#change-52277
>
> * Author: Shugo Maeda
> * Status: Open
> * Priority: Normal
> * Assignee:
> ----------------------------------------
> Why not support ECMAScript6-like hash literals?
>
> For example,
>
>     {x, y}
>
> is equivalent to:
>
>     {x: x, y: y}
>
> For convenience, the prefix of global, instance, and class variables
> should be removed from the key name as follows:
>
>     a = 1
>     B = 2
>     $c = 3
>     @d = 4
>     @@e = 5
>     p({a, B, $c, @d, @@e, f: 6})
>     #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}
>
>
> ---Files--------------------------------
> 0001-support-ES6-like-hash-literals.patch (3.88 KB)
>
>
> --
> https://bugs.ruby-lang.org/
>

[-- Attachment #2: Type: text/html, Size: 3666 bytes --]

[ruby-core:69024] [Ruby trunk - Feature #11105] ES6-like hash literals

[rr.rosas]

Issue #11105 has been updated by Rodrigo Rosenfeld Rosas.


I use that a lot with CoffeeScript and would love to be able to do the same with Ruby. +1

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52280

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69025] [Ruby trunk - Feature #11105] ES6-like hash literals

[mame]

Issue #11105 has been updated by Yusuke Endoh.


-1.

{x, y} is a conventional notation of a mathematical set.
When I read it, I expect it to be equivalent to { x => true, y => true }.

-- 
Yusuke Endoh <mame@ruby-lang.org>

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52281

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69026] [Ruby trunk - Feature #11105] ES6-like hash literals

[matz]

Issue #11105 has been updated by Yukihiro Matsumoto.


Question:

What if we have variables with same name and different prefixes? e.g.

a = 1
@a = 2
$a = 3

Matz.

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52282

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69027] Re: [Ruby trunk - Feature #11105] ES6-like hash literals

[Alfredo Bravo Cuero]

[-- Attachment #1: Type: text/plain, Size: 1299 bytes --]

Hola matz


Alfredo Bravo Cuero (@abracu)
Open Source culture advocate and Ruby on Rails Developer 
| Skype: yo@alfredobravocuero.co | Cel +573192837240

Enviado desde mi iPad

> El 29/04/2015, a las 9:36 p.m., matz@ruby-lang.org escribió:
> 
> Issue #11105 has been updated by Yukihiro Matsumoto.
> 
> 
> Question:
> 
> What if we have variables with same name and different prefixes? e.g.
> 
> a = 1
> @a = 2
> $a = 3
> 
> Matz.
> 
> ----------------------------------------
> Feature #11105: ES6-like hash literals
> https://bugs.ruby-lang.org/issues/11105#change-52282
> 
> * Author: Shugo Maeda
> * Status: Open
> * Priority: Normal
> * Assignee: 
> ----------------------------------------
> Why not support ECMAScript6-like hash literals?
> 
> For example,
> 
>    {x, y}
> 
> is equivalent to:
> 
>    {x: x, y: y}
> 
> For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:
> 
>    a = 1
>    B = 2
>    $c = 3
>    @d = 4
>    @@e = 5
>    p({a, B, $c, @d, @@e, f: 6})
>    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}
> 
> 
> ---Files--------------------------------
> 0001-support-ES6-like-hash-literals.patch (3.88 KB)
> 
> 
> -- 
> https://bugs.ruby-lang.org/

[-- Attachment #2: Type: text/html, Size: 2757 bytes --]

[ruby-core:69028] [Ruby trunk - Feature #11105] ES6-like hash literals

[shugo]

Issue #11105 has been updated by Shugo Maeda.


Yukihiro Matsumoto wrote:
> What if we have variables with same name and different prefixes? e.g.
> 
> a = 1
> @a = 2
> $a = 3

The last one is used with warnings:

```
lexington:ruby$ cat x.rb
a = 1
@a = 2
$a = 3
p({a, @a, $a})
lexington:ruby$ ./ruby x.rb
x.rb:4: warning: duplicated key at line 4 ignored: :a
x.rb:4: warning: duplicated key at line 4 ignored: :a
{:a=>3}
```


----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52284

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69029] [Ruby trunk - Feature #11105] ES6-like hash literals

[shugo]

Issue #11105 has been updated by Shugo Maeda.


Yusuke Endoh wrote:
> {x, y} is a conventional notation of a mathematical set.
> When I read it, I expect it to be equivalent to { x => true, y => true }.

{x, y} looks like a set of variable bindings, so it's reasonable that each key is a variable name and each value is its value.


----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52285

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69032] Re: [Ruby trunk - Feature #11105] ES6-like hash literals

[Carlos Agarie]

As Yusuke Endoh said, I'd expect this notation to create a Set, not a Hash...

-----
Carlos Agarie
+55 11 97320-3878 | @carlos_agarie


2015-04-29 23:55 GMT-03:00  <shugo@ruby-lang.org>:
> Issue #11105 has been updated by Shugo Maeda.
>
>
> Yusuke Endoh wrote:
>> {x, y} is a conventional notation of a mathematical set.
>> When I read it, I expect it to be equivalent to { x => true, y => true }.
>
> {x, y} looks like a set of variable bindings, so it's reasonable that each key is a variable name and each value is its value.
>
>
> ----------------------------------------
> Feature #11105: ES6-like hash literals
> https://bugs.ruby-lang.org/issues/11105#change-52285
>
> * Author: Shugo Maeda
> * Status: Open
> * Priority: Normal
> * Assignee:
> ----------------------------------------
> Why not support ECMAScript6-like hash literals?
>
> For example,
>
>     {x, y}
>
> is equivalent to:
>
>     {x: x, y: y}
>
> For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:
>
>     a = 1
>     B = 2
>     $c = 3
>     @d = 4
>     @@e = 5
>     p({a, B, $c, @d, @@e, f: 6})
>     #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}
>
>
> ---Files--------------------------------
> 0001-support-ES6-like-hash-literals.patch (3.88 KB)
>
>
> --
> https://bugs.ruby-lang.org/

[ruby-core:69078] [Ruby trunk - Feature #11105] ES6-like hash literals

[rr.rosas]

Issue #11105 has been updated by Rodrigo Rosenfeld Rosas.


Yukihiro Matsumoto wrote:
> Question:
> 
> What if we have variables with same name and different prefixes? e.g.
> 
> a = 1
> @a = 2
> $a = 3

CoffeeScript would compile to this:

~~~
@a=1; a=2; {@a, a} => {a: this.a, a: a}
~~~

If the same happens in Ruby, this is what I get in IRB:

~~~
> {a: 1, a: 2}
(irb):2: warning: duplicated key at line 2 ignored: :a
=> {:a=>2}
~~~

Sounds good to me.

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52325

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69106] [Ruby trunk - Feature #11105] ES6-like hash literals

[nobu]

Issue #11105 has been updated by Nobuyoshi Nakada.


Shugo Maeda wrote:
> ```
> lexington:ruby$ cat x.rb
> a = 1
> @a = 2
> $a = 3
> p({a, @a, $a})
> lexington:ruby$ ./ruby x.rb
> x.rb:4: warning: duplicated key at line 4 ignored: :a
> x.rb:4: warning: duplicated key at line 4 ignored: :a
> {:a=>3}
> ```

Why they make the same symbol?
`a`, `@a` and `$a` are irrelevant, separate variables.
I'd expect `{:a=>1, :@a=>2, :$a=>3}` without any warnings.

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52351

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69190] [Ruby trunk - Feature #11105] ES6-like hash literals

[shugo]

Issue #11105 has been updated by Shugo Maeda.


Nobuyoshi Nakada wrote:
> > lexington:ruby$ ./ruby x.rb
> > x.rb:4: warning: duplicated key at line 4 ignored: :a
> > x.rb:4: warning: duplicated key at line 4 ignored: :a
> > {:a=>3}
> > ```
> 
> Why they make the same symbol?
> `a`, `@a` and `$a` are irrelevant, separate variables.
> I'd expect `{:a=>1, :@a=>2, :$a=>3}` without any warnings.

Because I don't come up with any use case of such ugly key names.
I believe code like {a, @a} should not be used in real world applications.


----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52447

* Author: Shugo Maeda
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:69191] [Ruby trunk - Feature #11105] [Rejected] ES6-like hash literals

[matz]

Issue #11105 has been updated by Yukihiro Matsumoto.

Status changed from Open to Rejected

I am not positive about this syntax mostly because it appears to be set syntax, or old style hash in 1.8.
Once ES6 syntax become more popular, there will be chance for this change in the future.

Matz.


----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-52448

* Author: Shugo Maeda
* Status: Rejected
* Priority: Normal
* Assignee: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:81727] [Ruby trunk Feature#11105] ES6-like hash literals

[tleish]

Issue #11105 has been updated by tleish (Tony Fenleish).


+1

While it might be odd or new for some, using this in ES6 has been very nice.  I am often wishing this was supported in Ruby.  The cognitive load is so much nicer and less redundant.

I wish it could be reconsidered.

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-65427

* Author: shugo (Shugo Maeda)
* Status: Rejected
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:82458] [Ruby trunk Feature#11105] ES6-like hash literals

[knu]

Issue #11105 has been updated by knu (Akinori MUSHA).


This syntax is now widely known and popular in the JavaScript/ES world.  It is frequently used in everyday code and we've grown used to it.

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-66268

* Author: shugo (Shugo Maeda)
* Status: Rejected
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:82460] [Ruby trunk Feature#11105] ES6-like hash literals

[xkernigh]

Issue #11105 has been updated by kernigh (George Koehler).


This ES6 syntax for hash literals looks strange to me. I have never seen it before today, but I have not written JavaScript for a few years, and I am not using Ruby for web development.

Two things puzzle me:

1. What is the key in `{@a}`? I want `:@a` as the key, others want `:a`. I don't expect Ruby to change `a` into `@a`. For example, `object.instance_variable_get :a` raises NameError, but `object.instance_variable_get :@a` works.
2. Should `{print}` call the method `print` if there's no local variable? That's what `{print: print}` would do.

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-66270

* Author: shugo (Shugo Maeda)
* Status: Rejected
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:82466] [Ruby trunk Feature#11105] ES6-like hash literals

[nobu]

Issue #11105 has been updated by nobu (Nobuyoshi Nakada).


It makes many conflicts with the current syntax.
I don't think it is easy to resolve.

----------------------------------------
Feature #11105: ES6-like hash literals
https://bugs.ruby-lang.org/issues/11105#change-66276

* Author: shugo (Shugo Maeda)
* Status: Rejected
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Why not support ECMAScript6-like hash literals?

For example,

    {x, y}

is equivalent to:

    {x: x, y: y}

For convenience, the prefix of global, instance, and class variables should be removed from the key name as follows:

    a = 1
    B = 2
    $c = 3
    @d = 4
    @@e = 5
    p({a, B, $c, @d, @@e, f: 6})
    #=> {:a=>1, :B=>2, :c=>3, :d=>4, :e=>5, :f=>6}


---Files--------------------------------
0001-support-ES6-like-hash-literals.patch (3.88 KB)


-- 
https://bugs.ruby-lang.org/