[ruby-core:90913] [Ruby trunk Misc#15514] Add documentation for implicit array decomposition

[ruby-core:90913] [Ruby trunk Misc#15514] Add documentation for implicit array decomposition

[mail]

Issue #15514 has been reported by sos4nt (Stefan Schüßler).

----------------------------------------
Misc #15514: Add documentation for implicit array decomposition
https://bugs.ruby-lang.org/issues/15514

* Author: sos4nt (Stefan Schüßler)
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
The documentation for [Array Decomposition](http://ruby-doc.org/core/doc/syntax/assignment_rdoc.html#label-Array+Decomposition) says: _"[...] you can decompose an Array during assignment using parenthesis [sic]"_ and gives an example:

```ruby
(a, b) = [1, 2]

p a: a, b: b # prints {:a=>1, :b=>2}
```

But – as we all know – it's also possible _without_ parentheses, i.e.

```ruby
a, b = [1, 2]

p a: a , b: b #=> {:a=>1, :b=>2}
```

This also applies to block arguments when yielding multiple values vs. yielding a single array:

```ruby
def foo
  yield 1, 2
end

def bar
  yield [1, 2]
end

foo { |a, b| p a: a, b: b }
#=> {:a=>1, :b=>2}

bar { |a, b| p a: a, b: b }
#=> {:a=>1, :b=>2}
```

In both cases, parentheses are optional.

This implicit array decomposition could be quite surprising for newcomers. The documentation should cover it.



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

[ruby-core:90914] [Ruby trunk Misc#15514] Add documentation for implicit array decomposition

[shevegen]

Issue #15514 has been updated by shevegen (Robert A. Heiler).


Agreed.

----------------------------------------
Misc #15514: Add documentation for implicit array decomposition
https://bugs.ruby-lang.org/issues/15514#change-76105

* Author: sos4nt (Stefan Schüßler)
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
The documentation for [Array Decomposition](http://ruby-doc.org/core/doc/syntax/assignment_rdoc.html#label-Array+Decomposition) says: _"[...] you can decompose an Array during assignment using parenthesis [sic]"_ and gives an example:

```ruby
(a, b) = [1, 2]

p a: a, b: b # prints {:a=>1, :b=>2}
```

But – as we all know – it's also possible _without_ parentheses, i.e.

```ruby
a, b = [1, 2]

p a: a , b: b #=> {:a=>1, :b=>2}
```

This also applies to block arguments when yielding multiple values vs. yielding a single array:

```ruby
def foo
  yield 1, 2
end

def bar
  yield [1, 2]
end

foo { |a, b| p a: a, b: b }
#=> {:a=>1, :b=>2}

bar { |a, b| p a: a, b: b }
#=> {:a=>1, :b=>2}
```

In both cases, parentheses are optional.

This implicit array decomposition could be quite surprising for newcomers. The documentation should cover it.



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

[ruby-core:91004] [Ruby trunk Misc#15514] Add documentation for implicit array decomposition

[lisa.ugray]

Issue #15514 has been updated by lugray (Lisa Ugray).


If that's covered (and I agree it should be) it's also worth showing a case where they are not optional:
```
def baz
  yield [1, 2], 3
end

baz { |a, b, c| p a: a, b: b, c: c }
#=> {:a=>[1, 2], :b=>3, :c=>nil}

baz { |(a, b), c| p a: a, b: b, c: c }
#=> {:a=>1, :b=>2, :c=>3}
```


----------------------------------------
Misc #15514: Add documentation for implicit array decomposition
https://bugs.ruby-lang.org/issues/15514#change-76225

* Author: sos4nt (Stefan Schüßler)
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
The documentation for [Array Decomposition](http://ruby-doc.org/core/doc/syntax/assignment_rdoc.html#label-Array+Decomposition) says: _"[...] you can decompose an Array during assignment using parenthesis [sic]"_ and gives an example:

```ruby
(a, b) = [1, 2]

p a: a, b: b # prints {:a=>1, :b=>2}
```

But – as we all know – it's also possible _without_ parentheses, i.e.

```ruby
a, b = [1, 2]

p a: a , b: b #=> {:a=>1, :b=>2}
```

This also applies to block arguments when yielding multiple values vs. yielding a single array:

```ruby
def foo
  yield 1, 2
end

def bar
  yield [1, 2]
end

foo { |a, b| p a: a, b: b }
#=> {:a=>1, :b=>2}

bar { |a, b| p a: a, b: b }
#=> {:a=>1, :b=>2}
```

In both cases, parentheses are optional.

This implicit array decomposition could be quite surprising for newcomers. The documentation should cover it.



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