[ruby-core:99673] [Ruby master Bug#16853] calling bla(hash, **kw) with a string-based hash passes the strings into **kw (worked < 2.7)

Issue #16853 has been updated by Dan0042 (Daniel DeLorme).


> > When it comes to optimization, though, I would assume that the keywords are all symbols would open a lot more doors.
>
> No, it just added more checks as every call with keyword arguments would need to check all keys are Symbols.

If a Hash contains only Symbol keys I can easily imagine an optimized implementation that takes advantage of Symbol specifics to be more efficient that the general implementation. This would translate to increased efficiency for every method call that uses keyword arguments. Then double-splatting a hash could be optimized by just checking if the hash uses the Symbol-only implementation. Really, I think the current approach closes the door on a lot of potential optimizations.

> FWIW I also find the `where("table.id" => 42)` example unconvincing.
> That could work just fine with `def where(conditions)`, no need and it seems no much gains for keyword arguments there.

Exactly, AFAIU one of the of goals of "real" keyword arguments was to make a clearer distinction between "keywords" and "just a hash". And to me keywords really mean named arguments, in other words they're supposed to resolve to a local variable in a method. Since `"table.id"` can never be a local variable it should not be a keyword argument; it's the definition of a "data" hash. Now it feels like keyword arguments have just become a different way to pass around hash data; the boundary between keyword and hash has become _more_ blurred.

----------------------------------------
Bug #16853: calling bla(hash, **kw) with a string-based hash passes the strings into **kw (worked < 2.7)
https://bugs.ruby-lang.org/issues/16853#change-87160

* Author: sylvain.joyeux (Sylvain Joyeux)
* Status: Rejected
* Priority: Normal
* ruby -v: 2.7.1p83
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
The following code

~~~
def bla(hash = {}, **kw)
    puts "H: #{hash}"
    puts "K: #{kw}"
end

bla "some" => "string"
~~~

**silently** outputs the following (no warnings about deprecation of keyword parameters-from-hash)

~~~
H: {}
K: {"some"=>"string"}
~~~

While 2.6.5 (and versions before it) gave

~~~
H: {"some"=>"string"}
K: {}
~~~

I would expect "the warning" that started appearing in 2.7, and **definitely** not having strings in a keyword argument hash.



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>