[ruby-core:92481] [Ruby trunk Feature#15236] add support for hash shorthand

[tleish@gmail.com]

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


+1

I also vote for this option for both hashes and named params.  After using Es6 and going back to Ruby, the ruby way felt clunky to me.

There are multiple reasons why this would be advantageous.

## Readability: 

I like the named params that was added to Ruby.  It allows flexibility in the order of the params.  but often struggle in convincing myself to use them because of readability.   Code examples often show the following:

```ruby
my_hash = {name: 'joe', age: 8}

# or

my_method(name: 'Joe', age: 8)
```

But in the real world, the values are usually stored in other variables and 95% of the time the code looks like this:

```ruby
my_hash = {name: name, age: age}

# or

my_method(name: name, age: age)
```

The above code does not ready well with it's redundant words.  With the change suggested, it reads so much better:

```ruby
my_hash = {name, age}

# or

my_method(name, age)
```

If the variable is different than the param name, then it easily communicates that:

```ruby
my_hash = {name, age: calculate_age}

# or

my_method(name, age: calculate_age)
```

## Refactoring

If a method is implemented without keyword arguments:

```ruby
def my_method(name, age); end

my_method(name, age)
```

And then later it is decided to refactor using ruby keywords

```ruby
def my_method(name:, age:, address: nil); end
```

This of course is a breaking change.  All locations which use this method now need to be updated to use the new convention.

```ruby
my_method(name: name, age: age)
```

However, for instances where the method was was implemented using variables of the same as the parameters (which often they are), then the change is non-breaking.

```ruby
my_method(name, age) # no change required
```



----------------------------------------
Feature #15236: add support for hash shorthand
https://bugs.ruby-lang.org/issues/15236#change-77827

* Author: ignatiusreza (Ignatius Reza Lesmana)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
PR in github: https://github.com/ruby/ruby/pull/1990

inspired by javascript support for object literal shorthand notation `{ a }`, which will be expanded into `{ a: a }`..

to avoid ambiguity, this shorthand is only supported when hash is defined with `{ }` notation.. in other situation where the brackets is optional, e.g. function call, we still need to write it in full (`m(a : a)` instead of `m(a)`, or `m(a, b, c: c)` instead of `m(a, b, c)`..



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