From: "Eregon (Benoit Daloze)" <noreply@...>
Date: 2022-04-12T09:52:30+00:00
Subject: [ruby-core:108215] [Ruby master Feature#18690] Allow `Kernel#then` to take arguments

Issue #18690 has been updated by Eregon (Benoit Daloze).


The last example is just:
```ruby
p.call(honyarara, fugafugafuga, hogehogehoge)
```
isn't it? And that's a lot more readable IMHO.

I'm against this proposal, IMHO having multiple local variables for the same thing only increases confusion and hurt readability.
If `fugafugafuga` etc are long method calls/expressions, then they could be saved in local variables outside the `then` block and that would again be more readable.

Also `then` is an alias of `yield_self` which is literally `yield self`, so I think those semantics would be weird for `yield self`.

I think `then`/`yield_safe` makes sense in a method chain (to not need to break it in multiple lines/break the reading flow).
Extra variables/arguments as you show can just be declared before/outside-the-block as local variables. By definition they are independent of the method chain and so that seems always a better solution.

----------------------------------------
Feature #18690: Allow `Kernel#then` to take arguments
https://bugs.ruby-lang.org/issues/18690#change-97198

* Author: sawa (Tsuyoshi Sawada)
* Status: Open
* Priority: Normal
----------------------------------------
`Kernel#then` passes the receiver to the block as its first positional block parameter.

```ruby
1.5.then{|x| Math.atan(x)}
```

I would like to propose to let `then` take arguments, which would be passed to the block as the other block parameters.

```ruby
3.then(4){|x, y| Math.hypot(x, y)}
```

There are two uses. First, to separate bulky or repeated parameters from the routine. Instead of writing:

```ruby
honyarara.then{|x|
  foo(x)
  bar(fugafugafuga)
  baz(hogehogehoge)
  qux(x, fugafugafuga, hogehogehoge)
}
```

we can then write:

```ruby
honyarara.then(fugafugafuga, hogehogehoge){|x, y, z|
  foo(x)
  bar(y)
  baz(x)
  qux(x, y, z)
}
```

Second, to use a proc with multiple parameters when, for some reason, you do not want to define a method to do it:


```ruby
p = ->(x, y, z){
  foo(x)
  bar(y)
  baz(x)
  qux(x, y, z)
}

honyarara.then(fugafugafuga, hogehogehoge, &p)
```




-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>