Issue #15526 has been updated by janfri (Jan Friedrich). zverok (Victor Shepelev) wrote: > 1) Ruby has very consistent "argument **deconstruction**" rules. Basically, "it is deconstructed the same way it is constructed", e.g., if you can _call_ (construct) with arguments like `meth(a, *b, c: 1, d: 2, **e)`, you can also _receive_ (deconstruct) arguments exactly the same way: `a, *b, c:, d: nil, **e`. > > 2) The deconstruction is fully enabled in arguments (including keyword arguments) to procs and methods > > 3) Initially (before keyword arguments), the variable assignment had the same "expressive power", e.g. you could define a method like > > ```ruby > def meth(a, b, *rest) > ``` > ...and you could assign variables the same way: > > ```ruby > a, b, *rest = [1, 2, 3, 4] > ``` > > 4) When keyword arguments were introduced, there was no matching syntax for variable assignment. If it **would** exist, it most probably **should** look this way (same as arguments, remember): > > ```ruby > a:, b:, **kwrest = {a: 1, b: 2, c: 3, d: 4} > ``` > It obviously looks confusing (and would probably be hard for the parser), and I believe that's the reason it was NOT added to the language. > > 5) I don't think adding "orphan feature" (looking like nothing else in the language) just for the sake of this particular case would be ever accepted; and I don't think it should. > > 6) In the meantime, "chainable" code style (with `Enumerable` and `#then`) allows to embrace argument deconstruction in its full force: > ```ruby > config.then { |host:, port: 8080, **rest| > ``` > ...which is NOT the main (and obviously not the only) reason to use this style, just a nice side-effect of its consistency with the rest of the language. +1 Great analysis. ---------------------------------------- Feature #15526: New way to destruct an object hash https://bugs.ruby-lang.org/issues/15526#change-76267 * Author: alissonbruno.sa (Alisson Santos) * Status: Open * Priority: Normal * Assignee: * Target version: ---------------------------------------- JavaScript has a nice a neat way to destruct objects. ~~~ javascript const person = { name: "John Doe", age: 33 }; const { name, age } = person; ~~~ Erlang has a similar way to destruct a tuple: ~~~ erlang Person = {"John Doe", 33} {Name, Age} = Person ~~~ I think it's very handy and would be nice if we have something similar in Ruby. ~~~ ruby config = { host: 'localhost', port: 3000 } { host, port } = config ~~~ I know Ruby has Hash#values_at, but I think this way it's more readable and understandable What do you guys think? -- 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>