Ruby: Overloading Yield Function

Question

I noticed while learning Ruby that both of these uses of the each method work and produce the same output, and I was wondering how Ruby makes this happen (and how I can make it happen for my own functions):

my_array = [["hello","goodbye"],["picture","perfect"]]

my_array.each do |array|

  puts array[0] + " " + array[1]

end

my_array.each do |first, second|

  puts first + " " + second

end

My understanding is that when writing the definition of a method that accepts a code block, the yield method is utilized to pass arguments to the code block and call the block. But how can you utilize the yield method such that it passes different arguments depending on the provided code block? In the example case, it appears that the yield method passes the individual array elements when two parameters (i.e., first, second) are used within the block, and it passes the arrays themselves when one parameter is used within the block (i.e., array).

@RoneyMichael Correct me if I'm wrong, but I don't think that's a solution. The splat operator is intended for use with parameters, not arguments. And my question is regarding how I structure my yield statements and what arguments I pass to them. — voltair
– voltair, Commented Mar 19, 2013 at 6:34

mu is too short · Accepted Answer · 2013-03-19 06:46:06Z

1

Neither each not yield are doing anything special here, that's just how block arguments work. Consider this simple example:

def f(x) yield x end

and now we can see what happens:

>> f([1,2]) { |a| puts a.inspect }
[1, 2]
>> f([1,2]) { |a, b| puts "#{a} - #{b}" }
1 - 2
>> f([1,2]) { |a, b, c| puts "#{a} - #{b} - #{c}" }
1 - 2 -

You'll see similar destructing in assignments:

a, b = [1, 2]

You can also do it explicitly with a splat:

a, b = *[1, 2]

or like this:

def g(x) yield *x end
g([1, 2]) { |a, b| puts "#{a} - #{b}" }

Presumably the block knows what sorts of things it will be given so the block is well positioned to unpack the arguments. Note that the g function has to know that its argument is splatable (i.e. an array) but f doesn't. f nicely puts the "what sort of thing is x" logic together in the call to f, g buries half of the logic inside itself. One place where the difference becomes apparent is when you use Enumerable methods on a Hash:

{ :where => :is, :pancakes => :house? }.map { |k, v| ... }

Enumerable#map doesn't need to know that a Hash works in key/value two element arrays, it just passes things around and leaves it up everyone else to worry about the details.

answered Mar 19, 2013 at 6:46

mu is too short

436k71 gold badges863 silver badges822 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

voltair Over a year ago

thank you so much for your answer. so is there a place where i can see the rules for how ruby automatically detects and deconstructs (or doesn't deconstruct) these objects (like arrays and hashes)? or is it something you just learn through trial and error, since it really only seems to be relevant to arrays and hashes? also, for the g method, does the splat in your yield function mean an error will arise if the argument passed to g is not an array? and are only arrays splatable? that seemed to be what you were inferring, but i wasn't sure.

mu is too short Over a year ago

@user1419674: Only arrays get auto-splatted/destructured in block arguments. If you want to see how something interacts with Enumerable (the source of map and friends) then you'll have to check the class's documentation.

Collectives™ on Stack Overflow

Ruby: Overloading Yield Function

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related