Issue #19328 has been updated by jeremyevans0 (Jeremy Evans). Considering: * That separating keyword and positional arguments was done for good reasons (as explained in the "Why we're deprecating the automatic conversion" section of the page you linked to), * That reverting the change would reintroduce all of the previous problems that Ruby 2 keyword arguments had, * That the separation happened 3 released versions ago and is now well established, and * That the vast majority of gems have upgraded to support keyword argument separation, I estimate that this feature request has a 0% change of approval. ---------------------------------------- Feature #19328: Please bring back the use of Hash objects for keyword arguments https://bugs.ruby-lang.org/issues/19328#change-101152 * Author: randallcoding (Randall Coding) * Status: Open * Priority: Normal ---------------------------------------- The change in 3.0 (linked here https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-ke...) no longer automatically converts Hash objects into keyword arguments. This takes Ruby away from what it has always been about: being as intuitive and developer friendly as possible. The solution given to make a hash into keywords is to perform a double splat (**) on the hash object. This is confusing and esoteric, not to mention will require a lot of old code to be re-written. For example I have code that was written like this ``` ruby def Foo(a:, b:) puts a + b end ``` which I can call by simply using ``` ruby myhash = {a:3, b:5} Foo(myhash) ``` Look at the clarity, simplicity and convenience. The interpreter takes care of the messy and unnecessary bits and our code is easily understandable by other humans. But now for the same function we need to write ``` ruby Foo(**myhash) ``` We have to add superficial extra strokes (from the human perspective) to achieve what our intelligent interpreter once knew we wanted with less hassle. Let's not become like those other language! Please keep Ruby intuitive, convenient and developer friendly and make this feature what is was before. -- https://bugs.ruby-lang.org/

Issue #19328 has been updated by Eregon (Benoit Daloze). Status changed from Open to Rejected This would mean breaking code working on 3.0/3.1/3.2, of course that's not acceptable. Adding `**` there is not a big deal and it makes a lot of sense once you understand keyword arguments are now separated from positional arguments. ---------------------------------------- Feature #19328: Please bring back the use of Hash objects for keyword arguments https://bugs.ruby-lang.org/issues/19328#change-101158 * Author: randallcoding (Randall Coding) * Status: Rejected * Priority: Normal ---------------------------------------- The change in 3.0 (linked here https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-ke...) no longer automatically converts Hash objects into keyword arguments. This takes Ruby away from what it has always been about: being as intuitive and developer friendly as possible. The solution given to make a hash into keywords is to perform a double splat (**) on the hash object. This is confusing and esoteric, not to mention will require a lot of old code to be re-written. For example I have code that was written like this ``` ruby def Foo(a:, b:) puts a + b end ``` which I can call by simply using ``` ruby myhash = {a:3, b:5} Foo(myhash) ``` Look at the clarity, simplicity and convenience. The interpreter takes care of the messy and unnecessary bits and our code is easily understandable by other humans. But now for the same function we need to write ``` ruby Foo(**myhash) ``` We have to add superficial extra strokes (from the human perspective) to achieve what our intelligent interpreter once knew we wanted with less hassle. Let's not become like those other language! Please keep Ruby intuitive, convenient and developer friendly and make this feature what is was before. -- https://bugs.ruby-lang.org/