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=-4.1 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED, 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 4CE2620248 for ; Tue, 9 Apr 2019 03:20:20 +0000 (UTC) Received: from neon.ruby-lang.org (localhost [IPv6:::1]) by neon.ruby-lang.org (Postfix) with ESMTP id 0638D121156; Tue, 9 Apr 2019 12:20:15 +0900 (JST) Received: from o1678916x28.outbound-mail.sendgrid.net (o1678916x28.outbound-mail.sendgrid.net [167.89.16.28]) by neon.ruby-lang.org (Postfix) with ESMTPS id 293DB1210DA for ; Tue, 9 Apr 2019 12:20:12 +0900 (JST) Received: by filter0123p3las1.sendgrid.net with SMTP id filter0123p3las1-26776-5CAC0F6C-6 2019-04-09 03:20:12.257043991 +0000 UTC m=+13514.448288434 Received: from herokuapp.com (unknown [3.82.3.4]) by ismtpd0003p1iad1.sendgrid.net (SG) with ESMTP id u_O9CBKESCC2KWHWdzDXxQ for ; Tue, 09 Apr 2019 03:20:12.154 +0000 (UTC) Date: Tue, 09 Apr 2019 03:20:12 +0000 (UTC) From: merch-redmine@jeremyevans.net Message-ID: References: Mime-Version: 1.0 X-Redmine-MailingListIntegration-Message-Ids: 67701 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?BI4r2c2WwhEqH8wcnZpWHxYCEOdWnYr3ixtcN=2F8?= =?us-ascii?Q?NkveBeZ83dxDSNX2j+YgMjihiP5WpjJ+iWN3bow?= =?us-ascii?Q?0iZ4uSHzd1jA=2Fi15punfHx8sLslgrT6xG1+ahQP?= =?us-ascii?Q?OA3VqIa9Gp37PTP2RoT0N9dI+dGtymbD2lw=3D=3D?= To: ruby-core@ruby-lang.org X-ML-Name: ruby-core X-Mail-Count: 92217 Subject: [ruby-core:92217] [Ruby trunk 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). I have updated my branch (https://github.com/jeremyevans/ruby/commits/keyword-argument-separation) to restore backwards compatibility for methods using keyword arguments when calling with a final positional hash with mixed Symbol and non-Symbol keys. These calls are now handled like Ruby 2.6, splitting the hash into a positional hash for the non-Symbol keys and using the Symbol keys as keywords. A warning is added so that developers know they need to update their code, as in Ruby 3 this will always be treated as a positional argument without being split. Example (same behavior as Ruby 2.6 except for warnings): ```ruby def a(x=1, **h) [x, h] end a({:a=>1}) # (irb):5: warning: The last argument for `a' (defined at (irb):1) is used as the keyword parameter # => [1, {:a=>1}] a({"a"=>1}) # => [{"a"=>1}, {}] a({"a"=>1, :a=>1}) # (irb):7: warning: The last argument for `a' (defined at (irb):1) is split into positional and keyword parameters # => [{"a"=>1}, {:a=>1}] ``` I did not change the behavior for bare-keywords with Symbol and non-Symbol keys, only for positional hashes. Now that keywords can support non-Symbol keys (in this branch), I do not think it makes sense to restore backwards compatibility with Ruby 2.6 for those. I think that would only make sense if we are going to delay support for non-Symbol keys until Ruby 3. My Branch: ```ruby a(:a=>1) # =>[1, {:a=>1}] a("a"=>1) # => [1, {"a"=>1}] a("a"=>1, :a=>1) # => [1, {"a"=>1, :a=>1}] ``` Ruby 2.6: ``` a(:a=>1) # => [1, {:a=>1}] a("a"=>1) # => [{"a"=>1}, {}] a("a"=>1, :a=>1) # => [{"a"=>1}, {:a=>1}] ``` ---------------------------------------- Feature #14183: "Real" keyword argument https://bugs.ruby-lang.org/issues/14183#change-77553 * Author: mame (Yusuke Endoh) * Status: Open * 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/