(define (break) (shift k k))

(define (forrest)
  (reset
   (begin
     (display "before breakpoint 1")
     (newline)

     (display (format "value returned from breakpoint 1: ~a" (break)))
     (newline)

     (display "before breakpoints 2 & 3")
     (newline)

     (display (format "result of complex expression with breaks inside: ~a"
                      (+ 10 (* (break) 2) (break))))
     (newline)
     "final value")))

(define (run-forrest-run)
  (let* ((snapshot1 (forrest))
         (snapshot2 (snapshot1 "eat this"))
         (alternative-snapshot2 (snapshot1 "now eat that"))
         (snapshot3 (snapshot2 10))
         (alternative-snapshot3 (alternative-snapshot2 20))         
         (final-value (snapshot3 20))
         (alternative-final-value (alternative-snapshot3 40)))
    (begin
      (display (format "final value is: ~a" final-value))
      (newline)
      (display (format "alternative final value is also: ~a" final-value))
      (newline))))

before breakpoint 1
value returned from breakpoint 1: eat this
before breakpoints 2 & 3
value returned from breakpoint 1: now eat that
before breakpoints 2 & 3
result of complex expression with breaks inside: 50
result of complex expression with breaks inside: 90
final value is: final value
alternative final value is also: final value

def foo(f):
    items = getSomeItems()
    for item in items:
        f(item)
...
foo(yield)

L>data CalcS a = StateT Env (ErrorT String IO) a

L>if param < 0
L>    then throwError "Negative" -- тут мы зовём метод MonadError
L>    else modify (param:)       -- тут мы зовём метод MonadState

if param < 0
    then liftM $ throwError "Negative"
    else modify (param:)

К>>if param < 0
К>>    then liftM $ throwError "Negative"
К>>    else modify (param:)
К>>

instance (MonadError e m) => MonadError e (StateT s m) where
    throwError       = lift . throwError
    m `catchError` h = StateT $ \s -> runStateT m s
        `catchError` \e -> runStateT (h e) s

PM>def foo(f):
PM>    items = getSomeItems()
PM>    for item in items:
PM>        f(item)
PM>...
PM>foo(yield)
PM>

class shift(object):
  def __init__(self, func):
    def wrapper(*args, **kw):
      gen = func(*args, **kw)
      gen.next()
      return gen
    self.cons = wrapper()

  def __call__(self, item):
    self.cons.send(item)

def for_each(it, func):
  "Итеративная функция"
  for item in it:
    func(item)

def test():
  "Наши вычисления над итемами"
  while True:
    item = (yield)
    print item

#Запускаем "продолжения"
for_each(xrange(10), shift(test))

T>def test():
T>  "Наши вычисления над итемами"
T>  while True:
T>    item = (yield)
T>    print item
T>

T>Оно конечно не настоящие "продолжения" но вроде где-то рядом.

...
  while True:
    item = (yield)
...
[py]
в итератор.
Тогда бы test мог выглядеть совершенно невинно:
[py]
def test(it):
  for item in it:
    print item

@@metacont = lambda { |x|
    raise RuntimeError, "You forgot the top-level reset..."
}

def reset(&block)
    mc = @@metacont
    callcc { |k|
        @@metacont = lambda { |v|
            @@metacont = mc
            k.call v
        }
        x = block.call
        @@metacont.call x
    }
end

def shift(&block)
    callcc { |k|
        @@metacont.call block.call(lambda { |*v| reset { k.call *v } })
    }
end

def each_to_stream(collection)
  reset {
    collection.each { |v|
      shift { |k|
        lambda { |&block|
          block.call v
          k.call
        }
      }
    }
    nil
  }
end

def each_to_stream(collection)
        callcc { |k1|
                k3({
                        collection.each(lambda { |v|
                                callcc { |k2|
                                        {k3|k1}(lambda { |b|
                                                b(v)
                                                callcc { |k3|
                                                        k3(k2([]))
                                                }
                                        })
                                }
                        })
                        nil
                })
        }
end

#
# Вот этот код "вывернется" наружу, обернув примитивы State в bind.
#
def reflect(&m)
    shift { | k | bindM(m, k) }
end

#
# Следующие две функции - это реализация монады State.
#
def returnM(x)
    lambda { |s| [x,s] }
end

def bindM(m, f)
    lambda do |s|
        as1 = m.call s
        a  = as1[0]
        s1 = as1[1]
        f.call(a).call(s1)
    end
end

#
# Следующие две функции - простые примитивы для работы с монадой State.
#
def put(s)
    reflect { |_| [[], s] }
end

def get
    reflect { |s| [s,s] }
end

#
# Вот так мы разворачиваем состояние.
#
def run_state(s0, &m)
    (reset { returnM(m.call) }).call(s0)
end

#
# Пример использования
#
def testMe
    state = run_state(10) do
        x = get
        put(x + 5)
        put(get + get)
        0
    end

    print state[1]
end

testMe