div (x : int, y : int) : int
{
  call/cc (fun (return)
    {
      when (y = 0)
        return 0;
      x / y
    }
  )
}

fun (a) {
  ...
  div (x : int, y : int) : int
  {
    a
  }
  ...
}

reset (10 + (shift (foo => 1 + 2 + 3 + (foo 3))))

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

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

def shift(func):
    cons = func()
    cons.next()
    return cons.send()

VD>Тогда что понимать по повторить. Боюсь, что повтор на С, да и на С++ могут оказаться настолько "выразительным", что все кто это увидит будут долго и нецензурно выражаться .

get = reflect(get')
set = reflect(set')

reflect(m) = shift (f => m >>= f)

(B) (reset { return {
    x  = shift(f => (s => (s,s)) >>= f)
        shift(f => (_ => ((), x + 5)) >>= f)
        $1 = shift(f => (s => (s,s)) >>= f)
        $2 = shift(f => (s => (s,s)) >>= f)
        shift(f => (_ => ((), $1 + $2)) >>= f)
    }})

(C) (s => (s,s)) >>=
(x => (_ => ((), x + 5)) >>=
(_ => (s => (s,s)) >>=
($1 => (s => (s,s)) >>=
($2 => (_ => ((),$1 + $2))))))
[code]

Это ключевое место, обрати внимание как (B) преобразуется в (C).
Мы просто везде вместо f подставляем готовый контекст - как будто, мы выдернули первый shift, и вместо f подставили всё что осталось в reset-блоке, дальше в нём выдернули следующий shift и т.д. пока у нас не осталось ни одного shift-а.

Т.е

[code]
reset { q; shift(k => m(k)); shift(k => n(k)); p}

m(n({q;p}))

s0 => let (x, _) = get'(s0)      // (s0,s0)
          (_,s1) = put'(x+5)     // ((), s0+5)
                    ($1,_) = get'(s1)      // (s0+5,s0+5)
                    ($2,_) = get'(s1)      // (s0+5,s0+5)
             in ((), $1 + $2)          // ((), (s0+5)+(s0+5))

То есть 2+ получается после ужатия C#-ного кода до безоразия (объявления и выражения на одной строке, 150-символьные строки).