Meaning of the word yield

Question

Currently, I'm reading "The Well-Grounded Rubyist" by David A. Black, and I'm stuck at chapter 10.9 (Enumerators and the next dimension of enumerability). My question is about the yield method. What is the meaning of the word yield in the Ruby context? My native language is Russian, and Google Translate shows me a bunch of translation variants, that are confusing me. Some of them are: give, bring, surrender (give up), produce, agree, comply and many others.

UPD: please, pay attention to the fact, that I'm trying to understand the meaning of the Enumerator::Yielder#yield method, but not the yield keyword itself.

UPD_2: I've found an interesting article about Enumerators: "Lazy Enumerators in Ruby".

Answer 1

The word yield doesn't really have any special meaning in the context of Ruby. It means the same thing as it means in every other programming language, or in programming and computer science in general.

It is usually used when some kind of execution context surrenders control flow to a different execution context. For example, in Unix, there is a sched_yield function which a thread can use to give up the CPU to another thread (or process). With coroutines, the term yield is generally used to transfer control from one coroutine to another. In C#, there is a yield keyword, which is used by an iterator method to give up control to the iterating method.

And in fact, this last usage is exactly identical to the usage of the Enumerator::Yielder#yield method in Ruby, which you were asking about. Calling this method will suspend the enumerator and give up control to the enumerating method.

Example:

fibs = Enumerator.new do |y|
  a, b = 0, 1
  y.yield a
  loop do
    y.yield b
    a, b = b, a + b
  end
end

puts fibs.next #  0
puts fibs.next #  1
puts fibs.next #  1
puts fibs.next #  2
puts fibs.next #  3
puts fibs.next #  5
puts fibs.next #  8
puts fibs.next # 13
puts fibs.next # 21

As you see, there is an infinite loop. Obviously, if this loop just ran on its own, it wouldn't be of much use. But since every time it hits the yield method, it gives up control until it is called again, this will produce the Fibonacci numbers one by one, essentially representing an infinitely long list of all Fibonacci numbers.

There is another method, Fiber.yield, which serves a similar purpose. (In fact, I already described it above, because Fiber is just Ruby's name for coroutines.) Inside a Fiber, you call Fiber.yield to give up control back to the execution context that originally gave control to you.

Lastly, there is the yield keyword, which is used inside a method body to give up control to the block that was passed into the method.

Note that, at least in the Enumerator case (i.e. the first example), you can additionally interpret yield as to produce, since the Enumerator produces a new value, every time it calls yield.