`amb` operador como macro o procedimiento?

Question

En this página hay un comentario después de que el mensaje que le da un muy corto implementación de amb como procedimiento:

(define (amb-backtrack) 
    (error "no solution found")) 

(define (amb . args) 
    (call/cc (lambda (return) 
      (let ((backtrack amb-backtrack)) 
       (map (lambda (x) 
         (call/cc (lambda (k) 
           (set! amb-backtrack k) 
           (return x)))) 
        args) 
       (backtrack 'fail))))) 

Pero yo suelo ver amb implementado como una macro - en el FAQ schemers.org, y también en Dorai Sitaram's book:

(define amb-fail '*) 

(define initialize-amb-fail 
    (lambda() 
    (set! amb-fail 
     (lambda() 
     (error "amb tree exhausted"))))) 

(initialize-amb-fail) 

(define-macro amb 
    (lambda alts... 
    `(let ((+prev-amb-fail amb-fail)) 
     (call/cc 
     (lambda (+sk) 

      ,@(map (lambda (alt) 
        `(call/cc 
        (lambda (+fk) 
         (set! amb-fail 
         (lambda() 
          (set! amb-fail +prev-amb-fail) 
          (+fk 'fail))) 
         (+sk ,alt)))) 
       alts...) 

      (+prev-amb-fail)))))) 

por lo tanto - la versión macro es más largo, y un poco más difícil de entender. No pude ver ninguna ventaja sobre la versión del procedimiento, y por supuesto prefiero usar un procedimiento que una macro. ¿Hay algo que extrañé?

Answer 1

La diferencia es que una llamada de procedimiento siempre evalúa todos los argumentos.

(amb 1 (very-expensive-computation)) 

será, con la versión de procedimiento de amb, realice el very-expensive-computation, a continuación, producir 1. Si rendir 1 es suficiente para todos los cálculos posteriores, habrá perdido mucho tiempo en un cálculo cuyo valor de resultado nunca se utiliza. Incluso cosas peores ocurren, como menciona @Eli Barzilay en un comentario, cuando amb se usa para modelar un no determinismo infinito, como generar todos los números naturales.

La versión de macro lo evita y, por lo tanto, su comportamiento es similar al de los lenguajes de programación no deterministas, como Prolog.