Anonymous block forwarding

[straight-shoota]

Ruby 3.1 introduced anonymous block forwarding. An anonymous block argument can be forwarded to another method call using & as block argument. This is effectively just syntax sugar for forwarding the block explicitly via a block that yields. So it's a bit more concise.

def bar(&)
  foo(&)
end

equivalent to:

def bar(&)
  foo { |*args| yield *args }
end

This feature would not be a huge thing, but a nice little convenience feature.

[HertzDevil]

Ruby 3.2 adds anonymous single and double splats on top of &:

def foo(*args, **opts)
  [args, opts]
end

def bar(*, **)
  foo(*, **)
end

bar(1, 2, x: 3, y: 4) # => [[1, 2], {:x=>3, :y=>4}]

They also work inside array and hash literals:

def foo(*)
  [1, *, 5]
end

foo(2, 3, 4) # => [1, 2, 3, 4, 5]

def bar(**)
  {a: 1, **, d: 4}
end

bar(b: 2, c: 3) # => {:a=>1, :b=>2, :c=>3, :d=>4}

At this point it is probably too late for us since a bare single splat in Crystal already indicates a lack of extra positional parameters.

[straight-shoota]

At this point it is probably too late for us since a bare single splat in Crystal already indicates a lack of extra positional parameters.

I guess technically it would be unambiguous. If * us used as any anonymous forward anywhere in the body, it's a catch-all, otherwise not.
But that would be confusing when you can't tell from the signature. That's the same problem we currently have with blocks and yield, #8764).

Plus, it's simply unnecessary. You can just give it a name and use that. Requires no special syntax.

That's different with & of course because you can't give it a name and simply forward it that way. That would capture the block, turning it into a proc which won't work with yield then.