From: merch-redmine@jeremyevans.net
To: ruby-core@ruby-lang.org
Subject: [ruby-core:94872] [Ruby master Misc#16157] What is the correct and *portable* way to do generic delegation?
Date: Mon, 09 Sep 2019 19:36:53 +0000 (UTC) [thread overview]
Message-ID: <redmine.journal-81488.20190909193652.06911a69a6a62cfa@ruby-lang.org> (raw)
In-Reply-To: redmine.issue-16157.20190909141042@ruby-lang.org
Issue #16157 has been updated by jeremyevans0 (Jeremy Evans).
Dan0042 (Daniel DeLorme) wrote:
> I've compiled your delegate-keyword-argument-separation branch to test this. BTW in your example it should be `respond_to?(:pass_positional_hash, true)`
>
> The portability result is... Almost there, but not quite. In 2.6 and 2.7, `o.empty?` cannot distinguish between `foo()` and `foo({})`. This results in the discrepancies found below via this test script.
Thank you for working on this and providing the detailed example. I think your analysis is correct. We could handle this in 2.7 by introducing a method to check for whether positional->keyword hash conversion was done, but as we cannot change the behavior in 2.0-2.6, it looks like we cannot use the same method definition to delegate to all possible target method definitions with all possible arguments and be backwards compatible with <2.7. For best compatibility, you will need separate method definitions for <2.7 and 2.7+:
```ruby
class Proxy < BasicObject
def initialize(target)
@target = target
end
if ::RUBY_VERSION < '2.7'
def method_missing(*a, &b)
@target.send(*a, &b) rescue $!
end
else
def method_missing(*a, **o, &b)
@target.send(*a, **o, &b) rescue $!
end
pass_positional_hash(:method_missing) if respond_to?(:pass_positional_hash, true)
end
end
class Test
def args(*a) a end
def arg(a) a end
def opts(**o) o end
def arg0o(a=nil, **o) [a,o] end
def arg1o(a, **o) [a,o] end
end
e = Object.new
def e.write(*args) $stdout.print("warn! ") end
$stderr = e
opt = {}
hash = {k:42}
proxy = Proxy.new(Test.new)
p proxy.args(42)
p proxy.arg(42)
p proxy.arg({k:42})
p proxy.arg({})
p proxy.opts(k: 42)
p proxy.arg0o(hash)
p proxy.arg0o(hash, **{})
p proxy.arg0o(hash, **opt)
```
This results in the following behavior for 2.6.4 and 2.7.0 with the delegate-keyword-argument-separation branch:
```
ruby 2.6.4p104 │ ruby 2.7.0-delegate-keyword-argument-separation
[42] │ [42]
42 │ 42
{:k=>42} │ {:k=>42}
{} │ {}
{:k=>42} │ {:k=>42}
[nil, {:k=>42}] │ warn! warn! [nil, {:k=>42}]
[nil, {:k=>42}] │ [{:k=>42}, {}]
[{:k=>42}, {}] │ [{:k=>42}, {}]
```
The only behavior difference is for `**{}`, which was ignored by the parser in 2.6, and is not likely to appear in production code. The only warning in 2.7 is for `proxy.arg0o(hash)`, which correctly warns in 2.7 as the behavior will change in 3.0 to be the same as `proxy.arg0o(hash, **opt)` in 2.6.
Note that could use metaprogramming to reduce the duplication:
```ruby
class Proxy < BasicObject
def initialize(target)
@target = target
end
kw = ", **kw" if ::RUBY_VERSION >= '2.7'
class_eval(<<-END, __FILE__, __LINE__+1)
def method_missing(*a#{kw}, &b)
@target.send(*a#{kw}, &b) rescue $!
end
END
pass_positional_hash(:method_missing) if respond_to?(:pass_positional_hash, true)
end
```
----------------------------------------
Misc #16157: What is the correct and *portable* way to do generic delegation?
https://bugs.ruby-lang.org/issues/16157#change-81488
* Author: Dan0042 (Daniel DeLorme)
* Status: Open
* Priority: Normal
* Assignee:
----------------------------------------
With the keyword argument changes in 2.7 we must now specify keyword arguments explicitly when doing generic delegation. But this change is not compatible with 2.6, where it adds an empty hash to the argument list of methods that do not need/accept keyword arguments.
To illustrate the problem:
```ruby
class ProxyWithoutKW < BasicObject
def initialize(target)
@target = target
end
def method_missing(*a, &b)
@target.send(*a, &b)
end
end
class ProxyWithKW < BasicObject
def initialize(target)
@target = target
end
def method_missing(*a, **o, &b)
@target.send(*a, **o, &b)
end
end
class Test
def args(*a) a end
def arg(a) a end
def opts(**o) o end
end
# 2.6 2.7 3.0
ProxyWithoutKW.new(Test.new).args(42) # [42] [42] [42] ok
ProxyWithoutKW.new(Test.new).arg(42) # 42 42 42 ok
ProxyWithoutKW.new(Test.new).opts(k: 42) # {:k=>42} {:k=>42} +warn [{:k=>42}] incompatible with >= 2.7
ProxyWithKW.new(Test.new).args(42) # [42, {}] [42] [42] incompatible with <= 2.6
ProxyWithKW.new(Test.new).arg(42) # error 42 42 incompatible with <= 2.6
ProxyWithKW.new(Test.new).opts(k: 42) # {:k=>42} {:k=>42} +warn {:k=>42} must ignore warning? cannot use pass_positional_hash in 2.6
```
I don't know how to solve this, so I'm asking for the **official** correct way to write portable delegation code. And by **portable** I mean code that can be used in gems that target ruby 2.6 and above.
--
https://bugs.ruby-lang.org/
next prev parent reply other threads:[~2019-09-09 19:37 UTC|newest]
Thread overview: 25+ messages / expand[flat|nested] mbox.gz Atom feed top
[not found] <redmine.issue-16157.20190909141042@ruby-lang.org>
2019-09-09 14:10 ` [ruby-core:94860] [Ruby master Misc#16157] What is the correct and *portable* way to do generic delegation? daniel
2019-09-09 14:22 ` [ruby-core:94861] " merch-redmine
2019-09-09 17:09 ` [ruby-core:94865] " daniel
2019-09-09 19:36 ` merch-redmine [this message]
2019-09-10 14:41 ` [ruby-core:94888] " daniel
2019-09-10 16:37 ` [ruby-core:94889] " merch-redmine
2019-09-10 19:14 ` [ruby-core:94894] " daniel
2019-09-10 20:09 ` [ruby-core:94895] " merch-redmine
2019-09-11 15:36 ` [ruby-core:94904] " daniel
2019-09-11 21:25 ` [ruby-core:94909] " merch-redmine
2019-09-11 23:20 ` [ruby-core:94912] " merch-redmine
2019-09-12 2:05 ` [ruby-core:94916] " daniel
2019-09-12 12:53 ` [ruby-core:94922] " daniel
2019-09-12 15:40 ` [ruby-core:94923] " merch-redmine
2019-09-12 19:57 ` [ruby-core:94924] " daniel
2019-09-13 14:55 ` [ruby-core:94927] " daniel
2019-09-13 15:15 ` [ruby-core:94928] " merch-redmine
2019-09-13 17:00 ` [ruby-core:94931] " daniel
2019-09-13 17:54 ` [ruby-core:94933] " merch-redmine
2019-10-14 18:10 ` [ruby-core:95317] " merch-redmine
2019-10-15 5:37 ` [ruby-core:95326] " eregontp
2019-10-15 7:23 ` [ruby-core:95328] " eregontp
2019-10-15 15:16 ` [ruby-core:95337] " merch-redmine
2019-10-15 15:49 ` [ruby-core:95339] " eregontp
2019-10-15 16:28 ` [ruby-core:95341] " merch-redmine
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
List information: https://www.ruby-lang.org/en/community/mailing-lists/
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=redmine.journal-81488.20190909193652.06911a69a6a62cfa@ruby-lang.org \
--to=ruby-core@ruby-lang.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).