[ruby-core:114007] [Ruby master Misc#19740] Block taking methods can't differentiate between a non-local return and a throw
From:
"Eregon (Benoit Daloze) via ruby-core" <ruby-core@...>
Date:
2023-06-22 18:21:31 UTC
List:
ruby-core #114007
Issue #19740 has been updated by Eregon (Benoit Daloze).
I'm not sure it's good to be able to differentiate, because then it could be a mess if different gems consider return/throw/break differently, e.g. if Rails wants to commit on `return` but some other library only wants to commit on "natural return", or some difference in how they treat `throw`, etc.
Personally if I would design such a transaction API I would only commit on natural return, I think people shouldn't "escape" the block via return/break/throw if they want to commit it.
But I can also see the other side of the argument as discussed in https://github.com/ruby/timeout/pull/30, with the expected vs exceptional control flow.
----------------------------------------
Misc #19740: Block taking methods can't differentiate between a non-local return and a throw
https://bugs.ruby-lang.org/issues/19740#change-103667
* Author: byroot (Jean Boussier)
* Status: Open
* Priority: Normal
----------------------------------------
Opening this as Misc, as at this stage I don't have a fully formed feature request.
Ref: https://github.com/ruby/ruby/commit/1a3bcf103c582b20e9ea70dfed0ee68b24243f55
Ref: https://github.com/ruby/timeout/pull/30
Ref: https://github.com/rails/rails/pull/29333
### Context
Rails has this problem in the Active Record transaction API.
The way it works is that it yields to a block, and if no error was raised the SQL transaction is committed, otherwise it's rolled back:
```ruby
User.transaction do
do_thing
end # COMMIT
```
or
```ruby
User.transaction do
raise SomeError
end # ROLLBACK
```
The problem is that there are more ways a method can be exited:
```ruby
User.transaction do
return # non-local exit
end
```
```ruby
User.transaction do
throw :something
end
```
In the case of a non-local return, we'd want to commit the transaction, but in the case of a throw, particularly since it's internally used by `Timeout.timeout` since Ruby 2.1, we'd rather consider that an error and rollback.
But as far as I'm aware, there is not way to distinguish the two cases.
```ruby
def transaction
returned = false
yield
returned = true
ensure
if $!
# error was raised
elsif returned
# no uniwnd
else
# non-local return or throw, don't know
end
end
```
I think it could be useful to have a way to access the currently thrown object, similar to `$!` for such cases, or some other way to tell what is going on.
There is some discussion going on in https://github.com/ruby/timeout/pull/30 about whether `Timeout` should throw or raise, and that may solve part of the problem, but regardless of where this leads, I think being able to check if something is being thrown would be valuable.
cc @matthewd
FYI @jeremyevans0 @Eregon
--
https://bugs.ruby-lang.org/
______________________________________________
ruby-core mailing list -- ruby-core@ml.ruby-lang.org
To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/