cant understand the triagle number enumerator yielder yield

Question

unable to understand this code how it works.

triangular_numbers = Enumerator.new do |yielder|
 number = 0
 count = 1
 loop do
    number += count
    count += 1
    yielder.yield number  
  end
 end
5.times { print triangular_numbers.next, " " }

cant understand how yielder works for this block. how its yield work for number variable. how do loop runs 5 times. and how triangular_number.next works for the first time.

Answer 1

An enumerator is basically something that you can call next on and get something back. The yielder is the mechanism where it gives something back when next is called. Execution stops at the yield until the next call to next.

Farfetched analogy

You can think of an enumerator as a ticket machine like when you're waiting in line at a government office. When you press a button (next) it gives you a ticket. Inside the machine there's a chute where the ticket comes out. But the ticket machine is not constantly printing tickets. It waits for the button to be pressed before it prints the next ticket and puts it through the chute.

In this case the analogous code would be:

ticket_machine = Enumerator.new do |chute|
 ticket = 0
 loop do
    #print_ticket
    chute.yield ticket #waits here until you hit the button
    ticket += 1
  end
 end
5.times { print ticket_machine.next, " " } # gets 5 tickets

Your code sample is basically the same thing, but instead of issuing tickets, it's issuing triangular numbers. The chute is the yielder where the numbers get passed through.

This is not the only way to use an enumerator, check the docs for more.

Answer 2

Enumerator::new accepts a block. This block, when run, receives an Enumerator::Yielder, which has a method #yield.

When the Enumerator#next is called, the block is executed, up to the first Enumerator::Yielder#yield. The execution is paused there; the value given to yield is the value that next returns. When you call next again on the same Enumerator, the execution is resumed, and proceeds until it encounters yield again.

---

So in your case, 5.times executes its block, intending to repeat it five times. triangular_numbers.next is called; this starts the execution of the block above. number and count are set to their values, and an infinite loop is started. number is set to 1, count is set to 2, and then we find yielder.yield. This pauses the execution of the block, and returns the control back to where next was called inside 5.times loop. next returns 1, because yielder.yield received number (1).

Second time through the 5.times loop, we want to print the next number. This stops the main execution line, and resumes the enumerator block from just after yielder.yield. The infinite loop continues; number is 3, count is 3, yielder.yield pauses the enumerator and resumes the main code. next gets 3, which gets printed.

Third, fourth and fifth time through the 5.times loop are exactly the same.

After five iterations, 5.times loop ends, and the execution proceeds past it. The enumerator is paused, ready to give the next number in sequence, if you ever call next on it again (since it has an infinite loop), but you never do, and the program exits.