[#108552] [Ruby master Bug#18782] Race conditions in autoload when loading the same feature with multiple threads. — "ioquatix (Samuel Williams)" <noreply@...>
Issue #18782 has been reported by ioquatix (Samuel Williams).
11 messages
2022/05/14
[ruby-core:108505] [Ruby master Feature#18690] Allow `Kernel#then` to take arguments
From:
"zverok (Victor Shepelev)" <noreply@...>
Date:
2022-05-10 18:16:24 UTC
List:
ruby-core #108505
Issue #18690 has been updated by zverok (Victor Shepelev).
As a (maybe useful) sidenote, if we'll try to think in "useful atomic constructs" instead of "making existing multi-purpose", `Enumerator#with_object` is _almost_ what might help here:
```ruby
3.then.with_object(4) { |x, y| p [x, y] }
# prints [3, 4] -- as we need, it passes both to the block!
#=> 4 -- but returns the object, not the block's result
```
So, to "return the result", we need to go a long way:
```ruby
3.then.with_object(4).map { |x, y| x + y }.first
# => 7
# ...and with several objects, it becomes even more cumbersome:
3.then.with_object(4).with_object(5).map { |(x, y), z| x + y + z }.first
```
I _feel_ like some good atomic solution might be here somewhere, though :)
----------------------------------------
Feature #18690: Allow `Kernel#then` to take arguments
https://bugs.ruby-lang.org/issues/18690#change-97549
* 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>