call-with-current - continuation-концепция сохранения состояния

С продолжением прохождения стиля (без call/cc)

возможно, будет легче понять этот пример, если вы реализуете версию, которая использует явный стиль передачи продолжения, а не call/cc первый. В этом случае начнем с продолжения прохождения версии map:

(define (kmap fn list k)
  (if (null? list)
      (k list)
      (fn (car list)
          (lambda (head)
            (kmap fn
                  (cdr list)
                  (lambda (tail)
                    (k (cons head tail))))))))

(define (identity x) x)

(kmap (lambda (x k) (k (+ 1 x))) '(1 2 3 4) identity)
;=> (2 3 4 5)

если вы не знакомы со стилем прохождения продолжения, это может быть немного, чтобы обернуть голову, но это не слишком сложно. Запомните это kmap и fn каждый принимает дополнительный параметр в конце, который должен быть вызван с "результатом". Поэтому, когда мы призываем fn С (car list), мы также передаем ему процедуру (lambda (head) ...) это отвечает за заботу об остальной части отображения для нас. Остальная часть отображения определяется в терминах kmap снова. Каждый вызов kmap принимает окончательное продолжение, которое ожидает получить список, полученный в результате сопоставления fn список.

теперь, так как мы можем видеть, как отображение может быть реализовано со стилем передачи продолжения, с его помощью можно написать процедуру генерации итератора. Процедура iterator берет список и возвращает процедуру, которую мы можем вызвать, чтобы получить каждый элемент list.

(define (iterator list)
  (define (next k)
    (kmap (lambda (item more-next)
            (set! next more-next)
            (k item))
          list
          (lambda (results)
            (k 'done))))
  (lambda ()
    (next identity)))

> (define get (iterator '(1 2)))
> (get)
1
> (get)
2
> (get)
done
> (get)
done

> (define get (iterator '(a b c)))
> (get)
a
> (get)
b
> (get)
c
> (get)
done
> (get)
done

хитрость здесь в том, что мы определяем локальную процедуру next. Он зовет kmap С процедурой, которая redfines next когда каждый элемент list обрабатывается как процедура, которая будет обработать оставшуюся часть list. После переопределения next, он называет k с элементом. Окончательное продолжение перешло к kmap фактически игнорирует результаты, переданные ему, и просто вызывает k символ done. Что мы возвращение с iterator не является значением next, но процедура, которая называет next с продолжением identity. Косвенность здесь означает, что мы всегда называем последний стоимостью next С identity. Проходя identity поскольку продолжение означает, что мы просто получаем элемент списка обратно.

С call/cc

теперь, когда мы видим, как мы можем это сделать без call/cc, мы лучше оснащены, чтобы видеть, как мы можем использовать call/cc сделать это. Вспомните определение из вопроса:

(define (itr lst)
  (define (state k)
    (for-each (lambda (item)
                (call/cc (lambda (h)
                           (set! state h)
                           (k item))))
              lst)
    (k 'done))

  (define (generator)                   
    (call/cc (lambda (k) (state k))))   

  generator)                            

возвращение генератора

во-первых, обратите внимание, что

  (define (generator)
    (call/cc (lambda (k) (state k))))

  generator

можно упростить до

(lambda () (call/cc (lambda (k) (state k))))

и это как раз то, что мы сделали в нашей реализации. Когда вы вызываете это из REPL, все это k хочет сделать, это получить значение и вернуть его (и распечатать его). В нашей версии мы приближаемся к этому, просто возвращая его без изменений. То есть, мы используем identity, и мы использовали имя next вместо state. Так что

(lambda () (call/cc (lambda (k) (state k))))

как

(lambda () (next identity))

The state (или next) процедура

остальное

  (define (state k)
    (for-each (lambda (item)
                (call/cc (lambda (h)
                           (set! state h)
                           (k item))))
              lst)
    (k 'done))

очень похоже на то, что мы сделали, слишком. Вместо использования kmap и fn это принимает два аргумента (элемент и продолжение), мы используем for-each который принимает процедуру одного аргумента (элемента), и внутри этой процедуры мы используем call/cc чтобы захватить продолжение. Так что

(for-each
  (lambda (item)
    (call/cc (lambda (h)
               ...

как

(kmap (lambda (item h)
        ...

for-each не нужен окончательный аргумент продолжения, поэтому мы не удается передать результат-игнорирование (lambda () (k 'done)). Вместо этого, мы просто называем (k 'done) после the for-each звонок. То есть,

(for-each fn list)
(k 'done)

как

(kmap fn
      list
      (lambda (result)
        (k 'done)))

сохранение состояния программы

в обеих этих реализациях вы в некотором смысле "сохраняете состояние программы". Важное состояние, которое вы сохраняете, - это то, которое будет продолжать итерацию по списку.