# How do I get a recursive method to take a, non argument, block and run it on each recurrent call?

I’m trying to write a recursive binary tree depth first, pre-order, traversal method and have it also work when it’s passed a block. But I’m struggling to work out how to get it to use the passed block from the initial call on each internal recurrent call to itself. The code I’ve currently written is:

``````  def pre_order(node = @root, values = [])
return values if node.nil?
block_given? ? values << yield(node.value) : values << node.value
pre_order(node.left, values) if node.left
pre_order(node.right, values) if node.right
values
end
``````

Calling `#pre_order` on my test tree object without passing a block returns this correct output; `[7, 1, 4, 65, 13, 97]`. However when I call `#pre_order` and pass it a block, e.g.; `#pre_order { |value| value * 2 }` the result I get, vs the result I’m aiming for is;

Result from above code; `[14, 1, 4, 65, 13, 97]`
Result I’m aiming for; `[14, 2, 8, 130, 26, 194]`

I suppose the best way might be to save the initially passed block in a variable somehow so that it can be used it again on the recursive method calls on lines 4 & 5, without it being lost or needing to be reset on each method call. How might this be done? (I have a feeling I’m in Proc territory here, and am researching this further, but would appreciate some guidance on the ‘Ruby way‘ of this.)

### >Solution :

You have to define the block argument explicitly and pass it along:

``````def pre_order(node = @root, values = [], &block)
# ...
pre_order(node.left, values, &block) if node.left
pre_order(node.right, values, &block) if node.right
# ...
end
``````

With an explicit block argument, you could also replace `yield(node.value)` with a more explicit `block.call(node.value)` or the shorthand `block.(node.value)` syntax. (note the `.` before the parentheses)