Project

General

Profile

Feature #14183

Updated by mame (Yusuke Endoh) almost 2 years ago

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 
 ``` 

 In other words, the following programs WILL NOT work: 

 ``` 
 # This will cause an ArgumentError because the method foo does not accept keyword argument 
 def foo(a, b, c, hsh) 
   p hsh[:key] 
 end 
 foo(1, 2, 3, key: 42) 

 # The following will work; you need to use keyword rest operator explicitly 
 def foo(a, b, c, **hsh) 
   p hsh[:key] 
 end 
 foo(1, 2, 3, key: 42) 

 # This will cause an ArgumentError because the method call does not pass keyword argument 
 def foo(a, b, c, key: 1) 
 end 
 h = {key: 42} 
 foo(1, 2, 3, h) 

 # The following will work; you need to use keyword rest operator explicitly 
 def foo(a, b, c, key: 1) 
 end 
 h = {key: 42} 
 foo(1, 2, 3, **h) 
 ``` 

 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.

Back