From: "mame (Yusuke Endoh)" <noreply@...>
Date: 2021-08-20T18:26:54+00:00
Subject: [ruby-core:105025] [Ruby master Feature#18124] Hash shorthands (matching constructors and destructuring functionality in JS)

Issue #18124 has been updated by mame (Yusuke Endoh).


For "Destructuring", you can use one-line pattern matching since Ruby 3.0:

```
hash = {a: 'a', b: 'b'}
hash => { a:, b: }
p hash[:a] #=> "a"
```

For "Constructor", it is a long-running topic: #14579, #17292, and maybe other tickets I cannot remember. But as far as I recall, no one proposed this particular syntax `%C{ }`.

----------------------------------------
Feature #18124: Hash shorthands (matching constructors and destructuring functionality in JS)
https://bugs.ruby-lang.org/issues/18124#change-93432

* Author: myxoh (Nicolas Klein)
* Status: Open
* Priority: Normal
----------------------------------------
# **Suggestion:**
To implement two shorthand operators that allows you to destructure hash into local variables and construct local variables into a hash.

# **Context:**
Javascript and other languages have a similar feature. It's helpful, and I don't think there's anything stopping Ruby for supporting it.
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment
Ruby also supports destructuring from an array.

# **Syntax:**
## Destructuring:

```ruby
hash = {a: 'a', b: 'b'}
%D{ a, b } = hash
```
Would be equivalent to:

```ruby
hash = {a: 'a', b: 'b'}
a, b = hash[:a], hash[:b]
```

Hence

```ruby
a == 'a'
=> true
b = 'b'
=> true
```


It could also support the ** destructuring syntax
```ruby
hash = {a: 'a', b: 'b', c: 'c', d: 'd', e: 'e'}
%D{ a, b, **others } = hash
```

Would be equivalent to:

```ruby
hash = {a: 'a', b: 'b', c: 'c', d: 'd', e: 'e'}
a, b, others = hash[:a], hash[:b], hash.except(:a, :b)
```

Hence

```ruby
a == 'a'
=> true
b = 'b'
=> true
others = { c: 'c', d: 'd', e: 'e' }
=> true
```


## Constructor:
The constructor shorthand would allow you to create a hash where the symbol key has the same name as the variable.

For example:

```ruby
local_number = 1 
user = OStruct.new(name: 'john')
hash = %C{ local_var, user }
```

would be equivalent to:
```ruby
local_number = 1 
user =  OStruct.new(name: 'john')
hash = { local_number: local_number, user: user }
```




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

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>