[#102652] [Ruby master Bug#17664] Behavior of sockets changed in Ruby 3.0 to non-blocking — ciconia@...
Issue #17664 has been reported by ciconia (Sharon Rosner).
23 messages
2021/02/28
[ruby-core:102600] [Ruby master Bug#17105] A single `return` can return to two different places in a proc inside a lambda inside a method
From:
merch-redmine@...
Date:
2021-02-25 02:22:35 UTC
List:
ruby-core #102600
Issue #17105 has been updated by jeremyevans0 (Jeremy Evans).
I added a pull request to fix this: https://github.com/ruby/ruby/pull/4223
----------------------------------------
Bug #17105: A single `return` can return to two different places in a proc inside a lambda inside a method
https://bugs.ruby-lang.org/issues/17105#change-90583
* Author: Eregon (Benoit Daloze)
* Status: Open
* Priority: Normal
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
A single `return` in the source code might return to 2 different lexical places.
That seems wrong to me, as AFAIK all other control flow language constructs always jump to a single place.
```ruby
def m(call_proc)
r = -> {
# This single return in the source might exit the lambda or the method!
proc = Proc.new { return :return }
if call_proc
proc.call
:after_in_lambda
else
proc
end
}.call # returns here if call_proc
if call_proc
[:after_in_method, r]
else
r.call
:never_reached
end
end
p m(true) # => [:after_in_method, :return]
p m(false) # :return
```
We're trying to figure out the semantics of `return` inside a proc in
https://github.com/oracle/truffleruby/issues/1488#issuecomment-669185675
and this behavior doesn't seem to make much sense.
@headius also seems to agree:
> I would consider that behavior to be incorrect; once the proc has escaped from the lambda, its return target is no longer valid. It should not return to a different place.
> https://github.com/jruby/jruby/issues/6350#issuecomment-669603740
So:
* is this behavior intentional? or is it a bug?
* what are actually the semantics of `return` inside a proc?
The semantics seem incredibly complicated to a point developers have no idea where `return` actually goes.
Also it must get even more complicated if one defines a `lambda` method as the block in `lambda { return }` is then non-deterministically a proc or lambda.
--
https://bugs.ruby-lang.org/
Unsubscribe: <mailto:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>