From: merch-redmine@... Date: 2017-12-14T08:27:10+00:00 Subject: [ruby-core:84258] [Ruby trunk Bug#14183] "Real" keyword argument Issue #14183 has been updated by jeremyevans0 (Jeremy Evans). For a method definition like: ~~~ def foo(hsh={}) end ~~~ Will either of the following continue to work?: ~~~ foo(key: val) foo(:key => val) ~~~ One performance issue with keyword arguments is that keyword splats allocate a hash per splat, even if no keywords are used. In performance sensitive code, allocations can be avoided using a shared frozen hash as the default argument: ~~~ OPTS = {}.freeze def foo(hsh=OPTS) bar(1, hsh) end def bar(val, hsh=OPTS) end ~~~ By doing this, calling `foo` without keyword arguments does not allocate any hashes even if the hash is passed to other methods. If you use keyword arguments, you have to do: ~~~ def foo(**hsh) bar(1, **hsh) end def bar(val, **hsh) end ~~~ Which I believe allocates a multiple new hashes per method call, one in the caller and one in the callee. Example: ~~~ require 'objspace' GC.start GC.disable OPTS = {} def hashes start = ObjectSpace.count_objects[:T_HASH] yield ObjectSpace.count_objects[:T_HASH] - start - 1 end def foo(opts=OPTS) bar(opts) end def bar(opts=OPTS) baz(opts) end def baz(opts=OPTS) end def koo(**opts) kar(**opts) end def kar(**opts) kaz(**opts) end def kaz(**opts) end p hashes{foo} p hashes{foo(OPTS)} p hashes{koo} p hashes{koo(**OPTS)} # Output 0 0 5 6 ~~~ I humbly request that unless keyword splats can be made to avoid allocation, then at least make: ~~~ def foo(hsh) end foo(:key => val) ~~~ still function as it has since ruby 1.8, since that can be considered a hash and not a keyword argument. ---------------------------------------- Bug #14183: "Real" keyword argument https://bugs.ruby-lang.org/issues/14183#change-68407 * Author: mame (Yusuke Endoh) * Status: Open * Priority: Normal * Assignee: * Target version: Next Major * ruby -v: * Backport: 2.3: UNKNOWN, 2.4: UNKNOWN ---------------------------------------- In RubyWorld Conference 2017 and RubyConf 2017, Matz officially said that Ruby 3.0 will have "real" keyword arguments. AFAIK there is no ticket about it, so I'm creating this (based on my understanding). In Ruby 2, the keyword argument is a normal argument that is a Hash object (whose keys are all symbols) and is passed as the last argument. This design is chosen because of compatibility, but it is fairly complex, and has been a source of many corner cases where the behavior is not intuitive. (Some related tickets: #8040, #8316, #9898, #10856, #11236, #11967, #12104, #12717, #12821, #13336, #13647, #14130) In Ruby 3, a keyword argument will be completely separated from normal arguments. (Like a block parameter that is also completely separated from normal arguments.) This change will break compatibility; if you want to pass or accept keyword argument, you always need to use bare `sym: val` or double-splat `**` syntax: ``` # The following calls pass keyword arguments foo(..., key: val) foo(..., **hsh) foo(..., key: val, **hsh) # The following calls pass **normal** arguments foo(..., {key: val}) foo(..., hsh) foo(..., {key: val, **hsh}) # The following method definitions accept keyword argument def foo(..., key: val) end def foo(..., **hsh) end # The following method definitions accept **normal** argument def foo(..., hsh) end ``` I think here is a transition path: * Ruby 2.6 (or 2.7?) will output a warning when a normal argument is interpreted as keyword argument, or vice versa. * Ruby 3.0 will use the new semantics. -- https://bugs.ruby-lang.org/ Unsubscribe: