Может ли кто-нибудь объяснить call/cc простыми словами?

если у вас есть выражение (+ (* 2 3) (/ 10 2)) система схемы не будет оценивать все одновременно, но по частям. Порядок не указан в схеме, но давайте представим, что он слева направо (я думаю, что ракетка всегда делает слева направо):

ты (* 2 3), продолжением этого было бы вычислить (/ 10 2), потом (+ result1 result2). Способ, которым система схемы может это сделать, - преобразовать ваш код в продолжение прохождения стиле перед казнью. Выражение вверху получается что-то вроде этого:

 (lambda (k)
  (*& 2 
      3
      (lambda (result1)
        (/& 10
            2
            (lambda (result2)
              (+& result1 result2 k))))))

теперь, процедуры с & в конце концов такие же, как в схеме, за исключением того, что он принимает продолжение в качестве последнего аргумента. Пример одного из них: (define (+& a b k) (k (+ a b))). Все остальные делаются точно так же и считаются примитивными.

если вы примените это и передают display или values он будет отображаться или оценивать до 11. Однако, если вы использовали call/cc можно переопределить. Представьте себе это вариант:

(call/cc (lambda (k) (+ (* 2 3) (/ 10 (if (zero? a) (k +inf.0) a))

в схеме вы получаете ошибку при делении на ноль, и если это произойдет, вы хотите отменить остальные вычисления и сказать, что результат бесконечен. Код выше делает это, и если a равно нулю, это не будет суммировать результаты двух предыдущих вычислений.. Он фактически действует как Гото. Версия CPS этого кода будет выглядеть примерно так:

(lambda (k)
   (*& 2 
       3
       (lambda (result1)
         (zero?& a 
                 (lambda (azero?)
                   (if azero?
                       (k +inf.0) ; continuation used here
                       (/& 10
                           a
                           (lambda (result2)
                             (+& result1 result2 k))))))))) ; and here

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

теперь представьте себе этот блок кода:

(let* ((c 10)
       (r (call/cc (lambda (exit) exit))))
  (display "Hello\n")
  (cond ((zero? c) 'done)
        (else (set! c (- c 1))
              (r r))))

здесь вы видите, что я возвращаю продолжение как r. Продолжение-это остальные вычисления, начинающиеся с установки r, тогда как display ... Это фактически отображает "hello\n" 11 раз с момента вызова продолжение в низ он делает то же самое снова и снова.

как eval Я стараюсь держать это на абсолютном минимуме, и когда я это делаю, я обычно делаю это, чтобы получить аборт от текущих вычислений. Например.

(define (lstadd1 lst)
  (call/cc (lambda (exit)
    (let loop ((lst lst))
       (cond ((pair? lst) (cons (add1 (car lst)) (loop (cdr lst))))
             ((null? lst) '())
             (else (exit #f))))))) ; not proper 

(lstadd1 '(1 2 3))   ; ==> (2 3 4)
(lstadd1 '(1 2 . 3)) ; ==> #f

для более примеров я люблю Мэтт Mights страница С большим количеством примеров использования продолжений.