Dustin Barker
6/10/2008 9:39:00 PM
On Jun 10, 2008, at 4:58 PM, Justin To wrote:
> Output:
> each:a
> each: node:a yields:b
> each: node:a yields: node:b yields:c
> each: node:a yields:d
>
> Ok, from this example, I don't know how the #{e} in "child_node.each {
> |e| yield
> "node:#{value} yields:#{e}" }" turns into "node:b yields:c" because
> the
> #{e} isn't calling yield is it?
That's right, the e doesn't call yield - the 'each' in child_node.each
does. Remember that you're calling Tree#each here, so the value of 'e'
is whatever is yielded by the 'each' method. You'll have as many e's
as you have yields.
> Sorry for the trouble, I just can't seem to understand...when I walk
> through the algorithm with my logic it seems that it should just say
> "each: node b yields c"...which is obviously not the correct output.
So if remove the debug statements:
class Tree
def each
yield value
@children.each do |child_node|
child_node.each { |e| yield e }
end
end
end
t.each { |x| puts x }
I get:
a
b
c
d
Is that the iteration you're looking for? If so - let's walk through it:
t.each
-- yield value # node a is
yielding 'a' to t.each
puts x #
t.each outputs 'a'
-- @children.each do |child_node| # iterating children of node a
---- child_node.each # calling
Tree#each for first child of a, which is node b
------ yield value # node b is
yielding 'b'
---- yield e # node a
got e='b', so yielding 'b' to t.each
puts x #
t.each outputs 'b'
------ @children.each do |child_node| # iterating children of node b
-------- child_node.each # calling Tree#each
for first child of b, which is node c
---------- yield value # node c is
yielding 'c'
------ yield e # node b
got e='c', so yielding 'c' to node a
---- yield e # node
a got e='c', so yielding 'c' to t.each
puts x #
outputs 'c'
>
>
> I'll continue reviewing your example, though, but if you can explain
> in
> any other way, that'd be great. Thanks again!
>
No problem - it's a tough topic, hopefully the illustration of the
calls above helps!
-Dustin