class Fruits
    {
      function this()
      {
        this._data = ["apple","orange","lime","lemon","pear","banan","kiwi","pineapple"];
      } 
      function forward()
      {
        var items = this._data;
        var idx = -1;
        return function() // return function that supply "next" value 
        {
          if( ++idx < items.length )
            return items[idx];
        }
      }
      function backward()
      {
        var items = this._data;
        var idx = items.length;
        return function()
        {
          if( --idx >= 0 )
            return items[idx];
        }
      }
    }

var src = new Fruits();

for(var item in src.forward())
  stdout << item << "\n";

for(var item in src.backward())
  stdout << item << "\n";

function range( from, to )
{
  var idx = from - 1;
  return function() { if( ++idx <= to ) return idx; } 
}

for( var item in range(12,24) )
  stdout << item << "\n";

class Fruits(object):
  def __init__(self):
    self.__data=["apple","orange","lime","lemon","pear","banan","kiwi","pineapple"]
  def forward(self):
    idx=0
    while idx < len(self.__data):
      yield self.__data[idx]
      idx=idx+1
  def backward(self):
    idx=len(self.__data)-1
    while idx >= 0:
      yield self.__data[idx]
      idx=idx-1

fruits=Fruits()
for f in fruits.forward():
  print f

for f in fruits.backward():
  print f

def range2(start,end):
  i=start
  while i < end:
    yield i
    i=i+1

for i in range2(12,24):
  print i

class ByteValue(object):

    def __init__(self, data):
        self.data = data
        self.current_item = 0

    def __iter__(self):
        return self

    def next(self):
        if (self.current_item == len(self.data)):
            raise StopIteration
        else:
            byte_value = ord(self.data[self.current_item])
            self.current_item += 1
            return byte_value

str="hello"
a=ByteValue(str) # current_item для a и b разные
b=ByteValue(str) #

class ByteValue(object):
...
  def restart(self):
    self.current_item=0
...

iter=ByteValue("hello")
for f in iter:
  print f
iter.restart()
for f in iter:
  print f

        case YIELD_VALUE:
            retval = POP();
            f->f_stacktop = stack_pointer;
            why = WHY_YIELD;
            goto fast_yield;
fast_yield:
...
    if (tstate->frame->f_exc_type != NULL)
        reset_exc_info(tstate);
    }
...
    exit_eval_frame:
    Py_LeaveRecursiveCall();
    tstate->frame = f->f_back;

    return retval;

function Foo(p1) 
{
  if( p1 != 0 ) yield p1;
  return 0;
}

К>str="hello"
К>a=ByteValue(str) # current_item для a и b разные
К>b=ByteValue(str) # 
К>

К>        case YIELD_VALUE:
К>            retval = POP();
            f->>f_stacktop = stack_pointer;
К>            why = WHY_YIELD;
К>            goto fast_yield;
К>fast_yield:
К>...
К>    if (tstate->frame->f_exc_type != NULL)
К>        reset_exc_info(tstate);
К>    }
К>...
К>    exit_eval_frame:
К>    Py_LeaveRecursiveCall();
К>    tstate->frame = f->f_back;

К>    return retval;
К>

CS>>function Foo(p1) 
CS>>{
CS>>  if( p1 != 0 ) yield p1;
CS>>  return 0;
CS>>}
CS>>

К>+ ещё немного сказок Iterators and Generators (Alex Martelli)

A special value has the problem that if a sequence ever
contains that special value, a loop over that sequence will
end prematurely without any warning. If the experience with
null-terminated C strings hasn't taught us the problems this
can cause, imagine the trouble a Python introspection tool
would have iterating over a list of all built-in names,
assuming that the special End value was a built-in name!

def f(): return
print type(f())

<type 'NoneType'>

    function f()
    {
    }

    var a = [f(), f(), f()]; // [nothing,nothing,nothing]

def f():
    return

a = [f(), f(), f()]
print a # [None, None, None]

Кё>    function f()
Кё>    {
Кё>    }

Кё>    var a = [f(), f(), f()]; // [nothing,nothing,nothing]
Кё>

BC_ESET (offset,value) - сохранение в локальную переменную/параметр функции.
BC_VSET (index,value) - сохранение в элемент массива.
BC_PSET (key,value) - сохранение в property объекта.
BC_GSET (key,value) - сохранение в global/namespace объекте.

inline value value_to_set(value t) { return t == VM::nothingValue? VM::undefinedValue : t; }

a[0] = f()
assert(a[0] == f()) // should fail?

[1,2,3].each do |x|
  puts x
end
power = lambda {|x| puts x*x }
mul_2 = lambda {|x| puts x+x }
[1,2,3].each(&power)
[1,2,3].each(&mul_2)

for x in [1,2,3]:
    print(x)
power = lambda x: print(x*x)
mul_2 = lambda x: print(x+x)
list(map(power, [1,2,3])) # если нужно значение
all(map(power, [1,2,3])) # просто вычислить все
for x in map(mul_2, [1,2,3]): pass # более читабельно