[ruby-core:121184] [Ruby master Feature#21160] Local return from proc

[ruby-core:121184] [Ruby master Feature#21160] Local return from proc

[JustJosh (Joshua Stowers) via ruby-core]

Issue #21160 has been reported by JustJosh (Joshua Stowers).

----------------------------------------
Feature #21160: Local return from proc
https://bugs.ruby-lang.org/issues/21160

* Author: JustJosh (Joshua Stowers)
* Status: Open
----------------------------------------
When writing DSL-style helper methods, I often store block arguments as procs to use as callbacks.
Using `return` in a proc will return from the context it was created in, which is unsuitable in the following example.
Since procs cannot be converted to lambdas, I end up using `next` to return a value from them early.

Example:
``` ruby
fulfills_promise :generate_large_image do |image_data|
  next false if image_data.nil?

  puts 'Saving image..'
  # etc.
end
```

This works but confuses most readers.

I propose introducing an alias for it that is more appropriate for this use case.
Perhaps `pass` or `continue`?

It's worth noting that `return` would work with `fulfills_promise :foo, -> (bar) do`, though it detracts a bit from a DSL's expressiveness.




-- 
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/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:121185] [Ruby master Feature#21160] Local return from proc

[ufuk (Ufuk Kayserilioglu) via ruby-core]

Issue #21160 has been updated by ufuk (Ufuk Kayserilioglu).


`next` isn't necessarily the correct thing to use here, `break` is:
```ruby
foo = fulfills_promise :generate_large_image do |image_data|
  break false if image_data.nil?

  puts 'Saving image..'
  # etc.
end

foo #=> false
```

And the name exactly conveys the concept of breaking out of the block, in my opinion.

For example:
```ruby
result = (1..100).each do |num|
  break num if num > 3
  puts num
end

puts "Got result #{result}"
```
will print
```
1
2
3
Got result 4

----------------------------------------
Feature #21160: Local return from proc
https://bugs.ruby-lang.org/issues/21160#change-112120

* Author: JustJosh (Joshua Stowers)
* Status: Open
----------------------------------------
When writing DSL-style helper methods, I often store block arguments as procs to use as callbacks.
Using `return` in a proc will return from the context it was created in, which is unsuitable in the following example.
Since procs cannot be converted to lambdas, I end up using `next` to return a value from them early.

Example:
``` ruby
fulfills_promise :generate_large_image do |image_data|
  next false if image_data.nil?

  puts 'Saving image..'
  # etc.
end
```

This works but confuses most readers.

I propose introducing an alias for it that is more appropriate for this use case.
Perhaps `pass` or `continue`?

It's worth noting that `return` would work with `fulfills_promise :foo, -> (bar) do`, though it detracts a bit from a DSL's expressiveness.




-- 
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/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:121186] [Ruby master Feature#21160] Local return from proc

[JustJosh (Joshua Stowers) via ruby-core]

Issue #21160 has been updated by JustJosh (Joshua Stowers).


ufuk (Ufuk Kayserilioglu) wrote in #note-1:
> `next` isn't necessarily the correct thing to use here, `break` is:

I've tried `break` without success - I get `LocalJumpError: break from proc-closure`

Here is a more complete example of what I am doing:
```ruby
class Example
  def self.fulfills_promise(promise_name, &block)
    @@promise_callbacks ||= {}
    @@promise_callbacks[promise_name] = block
  end

  def self.fulfill_promise(promise_name, data)
    puts "Fulfilling promise: #{promise_name}"

    callback = @@promise_callbacks[promise_name]

    if callback.call(data)
      puts 'Complete!'
    else
      puts 'Failed!'
    end
  end

  fulfills_promise :generate_large_image do |image_data|
    puts 'Will finalize large image...'
    break false # Indicate something went wrong
    puts 'Finalized!'
    true
  end
end


Example.fulfill_promise(:generate_large_image, 'image data')
```

----------------------------------------
Feature #21160: Local return from proc
https://bugs.ruby-lang.org/issues/21160#change-112121

* Author: JustJosh (Joshua Stowers)
* Status: Open
----------------------------------------
When writing DSL-style helper methods, I often store block arguments as procs to use as callbacks.
Using `return` in a proc will return from the context it was created in, which is unsuitable in the following example.
Since procs cannot be converted to lambdas, I end up using `next` to return a value from them early.

Example:
``` ruby
fulfills_promise :generate_large_image do |image_data|
  next false if image_data.nil?

  puts 'Saving image..'
  # etc.
end
```

This works but confuses most readers.

I propose introducing an alias for it that is more appropriate for this use case.
Perhaps `pass` or `continue`?

It's worth noting that `return` would work with `fulfills_promise :foo, -> (bar) do`, though it detracts a bit from a DSL's expressiveness.




-- 
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/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:121188] [Ruby master Feature#21160] Local return from proc

[nobu (Nobuyoshi Nakada) via ruby-core]

Issue #21160 has been updated by nobu (Nobuyoshi Nakada).


Why not rescue `LocalJumpError`?

```ruby
  def self.fulfill_promise(promise_name, data)
    puts "Fulfilling promise: #{promise_name}"

    callback = @@promise_callbacks[promise_name]

    begin
      complete = callback.call(data)
    rescue LocalJumpError => e
      complete = e.exit_value
    end
    if complete
      puts 'Complete!'
    else
      puts 'Failed!'
    end
  end
```

This works with both of `return` and `break` in already released versions of Ruby, and even your DSL does not need to change.
If we were add a new keyword, you would have to wait for the end of this year at least.

----------------------------------------
Feature #21160: Local return from proc
https://bugs.ruby-lang.org/issues/21160#change-112123

* Author: JustJosh (Joshua Stowers)
* Status: Open
----------------------------------------
When writing DSL-style helper methods, I often store block arguments as procs to use as callbacks.
Using `return` in a proc will return from the context it was created in, which is unsuitable in the following example.
Since procs cannot be converted to lambdas, I end up using `next` to return a value from them early.

Example:
``` ruby
fulfills_promise :generate_large_image do |image_data|
  next false if image_data.nil?

  puts 'Saving image..'
  # etc.
end
```

This works but confuses most readers.

I propose introducing an alias for it that is more appropriate for this use case.
Perhaps `pass` or `continue`?

It's worth noting that `return` would work with `fulfills_promise :foo, -> (bar) do`, though it detracts a bit from a DSL's expressiveness.




-- 
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/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:121200] [Ruby master Feature#21160] Local return from proc

[JustJosh (Joshua Stowers) via ruby-core]

Issue #21160 has been updated by JustJosh (Joshua Stowers).


nobu (Nobuyoshi Nakada) wrote in #note-3:
> Why not rescue `LocalJumpError`?

That is definitely a better solution than requiring developers to use `next`.
Thank you for the suggestion.

As I understand it, the reason `break` doesn't work in my example is because the proc is "orphaned."
Ref: https://docs.ruby-lang.org/en/3.3/Proc.html#class-Proc-label-Orphaned+Proc
If an orphan-friendly implementation or alternative to `break` is worth considering, I would be happy to take a shot.


----------------------------------------
Feature #21160: Local return from proc
https://bugs.ruby-lang.org/issues/21160#change-112138

* Author: JustJosh (Joshua Stowers)
* Status: Open
----------------------------------------
When writing DSL-style helper methods, I often store block arguments as procs to use as callbacks.
Using `return` in a proc will return from the context it was created in, which is unsuitable in the following example.
Since procs cannot be converted to lambdas, I end up using `next` to return a value from them early.

Example:
``` ruby
fulfills_promise :generate_large_image do |image_data|
  next false if image_data.nil?

  puts 'Saving image..'
  # etc.
end
```

This works but confuses most readers.

I propose introducing an alias for it that is more appropriate for this use case.
Perhaps `pass` or `continue`?

It's worth noting that `return` would work with `fulfills_promise :foo, -> (bar) do`, though it detracts a bit from a DSL's expressiveness.




-- 
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/lists/ruby-core.ml.ruby-lang.org/