Issue #14183 has been updated by zverok (Victor Shepelev).


> In most cases a Hash#[] approach will be more concise since you don't have to repeat the keys. For example:

```ruby
.select { |h| h[:paragraph_id] > 0 && !h[:text].include?('foo') }
.map { |h| {at: h[:timestamp].to_i, content: "#{h[:text]} [#{h[:timestamp]}]"} }
.group_by { |h| h[:at] % 1000 }
```

Doesn't it look a lot like "pre-keyword args" method for you? For me, it does :) 

The thing with "deconstruction" is not character economy (it is almost never the thing, unless you are playing code golf competition), but concepts economy. With "my" version, you are specifying what the block expects in block definition. Add to the code cases like "parameter used several times", "parameter is required", "parameter has non-`nil` default value", and "just a hash" version becomes total mess while keyword args one stays clear and readable. And, as for me, it is not a "hack" or "side-effect of keyword args mess", but one of the primary features.

This reasoning is totally in line with "why we need keyword arguments (for methods)". The thing is, yes, with blocks most of the time _you don't have control over the caller_, and also, lot of the time block is passed to `Enumerable` or other core methods (`tap` and `then`, `File.open` etc.).

I'd say (just a noise in the air, I don't expect something would be changed 3 weeks before final release, nor I am optimistic about my voice being heard for upcoming 3.0) that the same way non-lambda proc has "implicit (arrays) unpacking" as a part of its definition, probably "hash unpacking into keyword args" (probably with a strict boundary limitation: like, only if proc accepts ONLY keyword args, and value passed is ONLY a hash) should be part of it.

----------------------------------------
Feature #14183: "Real" keyword argument
https://bugs.ruby-lang.org/issues/14183#change-83012

* Author: mame (Yusuke Endoh)
* Status: Closed
* Priority: Normal
* Assignee: 
* Target version: Next Major
----------------------------------------
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.

---Files--------------------------------
vm_args.diff (4.19 KB)
vm_args_v2.diff (4.18 KB)


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