From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on dcvr.yhbt.net X-Spam-Level: X-Spam-ASN: AS4713 221.184.0.0/13 X-Spam-Status: No, score=-3.8 required=3.0 tests=AWL,BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_PASS shortcircuit=no autolearn=ham autolearn_force=no version=3.4.2 Received: from neon.ruby-lang.org (neon.ruby-lang.org [221.186.184.75]) by dcvr.yhbt.net (Postfix) with ESMTP id 656B61F9FA for ; Fri, 13 Dec 2019 17:45:46 +0000 (UTC) Received: from neon.ruby-lang.org (localhost [IPv6:::1]) by neon.ruby-lang.org (Postfix) with ESMTP id 38C23120959; Sat, 14 Dec 2019 02:45:29 +0900 (JST) Received: from o1678948x4.outbound-mail.sendgrid.net (o1678948x4.outbound-mail.sendgrid.net [167.89.48.4]) by neon.ruby-lang.org (Postfix) with ESMTPS id D22D412092F for ; Sat, 14 Dec 2019 02:45:26 +0900 (JST) Received: by filter0052p3iad2.sendgrid.net with SMTP id filter0052p3iad2-29913-5DF3CE39-73 2019-12-13 17:45:29.834216191 +0000 UTC m=+84237.538196529 Received: from herokuapp.com (unknown [54.161.218.171]) by ismtpd0065p1iad1.sendgrid.net (SG) with ESMTP id 162qGhZSRxusq1VfHn-gCQ for ; Fri, 13 Dec 2019 17:45:29.694 +0000 (UTC) Date: Fri, 13 Dec 2019 17:45:29 +0000 (UTC) From: merch-redmine@jeremyevans.net Message-ID: References: Mime-Version: 1.0 X-Redmine-MailingListIntegration-Message-Ids: 71872 X-Redmine-Project: ruby-trunk X-Redmine-Issue-Id: 14183 X-Redmine-Issue-Author: mame X-Redmine-Sender: jeremyevans0 X-Mailer: Redmine X-Redmine-Host: bugs.ruby-lang.org X-Redmine-Site: Ruby Issue Tracking System X-Auto-Response-Suppress: All Auto-Submitted: auto-generated X-SG-EID: =?us-ascii?Q?RVE3t853K5scBhbmJHUzZTFFeVC=2FZSUmHZ0Dc+26wcEi2CTgsF1oz0wTSSxGGN?= =?us-ascii?Q?BIpn6O+CgiTi3kcUxn2q40eo0K1nPiFLXr8sCFZ?= =?us-ascii?Q?0p4Ewro+hW0zsgrOmElX3J=2FBqB2YddUMrGyIBV2?= =?us-ascii?Q?Sthw1CqkofjTp7sGvaPWU7OlsVyt5aO9Z9ism93?= =?us-ascii?Q?wqfde41gFpqY93okAiZWg+ADFMyNI3VQiVw=3D=3D?= To: ruby-core@ruby-lang.org X-ML-Name: ruby-core X-Mail-Count: 96220 Subject: [ruby-core:96220] [Ruby master Feature#14183] "Real" keyword argument X-BeenThere: ruby-core@ruby-lang.org X-Mailman-Version: 2.1.15 Precedence: list Reply-To: Ruby developers List-Id: Ruby developers List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: ruby-core-bounces@ruby-lang.org Sender: "ruby-core" Issue #14183 has been updated by jeremyevans0 (Jeremy Evans). bughit (bug hit) wrote: > So after this improvement, nonsense like this: > > ```rb > foo(a: 1, 'a' => 2, 1 => 3, nil => 4, true => 5, Object.new => 6) > ``` > > becomes legal That was already legal if `foo` did not accept keyword arguments. :) As keyword argument splats have always been just plain hashes, and not a separate type, it makes sense that they can handle any keys a normal hash would handle. I'll admit that this stretches the definition of "keyword arguments", but Ruby has always been more pragmatic than dogmatic. > and useful functionality like this destructuring example > > ```rb > words > .select { |paragraph_id:, text:, **| paragraph_id > first_paragraph_id && !text.include?('foo') } > .map { |text:, timestamp:, **| {at: timestamp.to_i, content: "#{text} [#{timestamp}]"} } > .group_by { |at:, **| at % 1000 } > ``` > > becomes illegal. One person's "useful destructuring" is another person's "bad hack". Keyword arguments were not intended for destructuring, they only did so for backwards compatibility with existing callers passing hashes. That was determined to be a mistake, due to the problems it caused. Also, if you want the above to work, it is possible, you just need to make `words` be an object where blocks for those methods are called with keywords: ```ruby module KeywordEnumerable %w'select map group_by'.each do |meth| define_method(meth) do |&block| ret = super() do |h| block.call(**h) end ret.extend(KeywordEnumerable) if ret.is_a?(Array) ret end end end words.extend(KeywordEnumerable) ``` > Which programmers is this supposed to make happy, users or implementers? I can't imagine many users will be happy. In the long term, both. In the beginning, many users will be happy, and many users will be unhappy. That's true of most changes when you have many users. If you look at all of the bugs we were able to close due to separating keyword arguments, that should be an indication of users who will be happy the change was made. Ignoring backwards compatibility, do you think the previous way of handling keyword arguments was better? > If you're going to take away whatever rudimentary makeshift destructuring ruby had, then implement proper first-class destructuring. That's what pattern matching allows. Still experimental in 2.7, though. Also, the previous "rudimentary makeshift destructuring" is still possible, but you have to explicitly double splat the hash, it is no longer done implicitly. ---------------------------------------- Feature #14183: "Real" keyword argument https://bugs.ruby-lang.org/issues/14183#change-83112 * 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/