¿Qué es "Llamar por nombre"?

Question

Estoy trabajando en una tarea de tarea en la que se nos pide que implementemos una estrategia de evaluación llamada "llamar por nombre" en un determinado idioma que desarrollamos (usando Scheme).

Nos dieron un example in Scala, pero no entiendo cómo funciona "llamar por nombre" y cómo es diferente a "llamar por necesidad"?

Answer 1

Llamada por necesidad es una versión memorada de llamada por nombre (ver wikipedia).

En llamada por nombre, el argumento se evalúa cada vez que se utiliza, mientras que en la llamada por necesidad, se evalúa la primera vez que se utiliza, y el valor registrado de manera que posteriormente lo necesitan no ser reevaluado

Answer 2

Llamar por nombre es un esquema de paso de parámetros donde se evalúa el parámetro cuando se usa, no cuando se llama a la función. Aquí hay un ejemplo en pseudo-C:

int i; 
char array[3] = { 0, 1, 2 }; 

i = 0; 
f(a[i]); 

int f(int j) 
{ 
    int k = j; // k = 0 
    i = 2;  // modify global i 
    k = j;  // The argument expression (a[i]) is re-evaluated, giving 2. 
} 

La expresión argumento se evalúa perezosamente cuando se accede utilizando los valores actuales de la expresión argumento.

Answer 3

añadir esto a las respuestas anteriores:

trabajo a través de la SICP section on Streams. Ofrece una buena explicación tanto de la llamada por nombre como de la llamada por necesidad. También muestra cómo implementarlos en Scheme. Por cierto, si usted está buscando una solución rápida que aquí hay una llamada por necesidad implementado en el esquema básico:

;; Returns a promise to execute a computation. (implements call-by-name) 
;; Caches the result (memoization) of the computation on its first evaluation 
;; and returns that value on subsequent calls. (implements call-by-need) 
(define-syntax delay 
    (syntax-rules() 
     ((_ (expr ...)) 
     (let ((proc (lambda() (expr ...))) 
      (already-evaluated #f) 
      (result null)) 
     (lambda() 
      (if (not already-evaluated) 
       (begin 
       (display "computing ...") (newline) 
       (set! result (proc)) 
       (set! already-evaluated #t))) 
      result))))) 

;; Forces the evaluation of a delayed computation created by 'delay'. 
(define (my-force proc) (proc)) 

una muestra de ejecución:

> (define lazy (delay (+ 3 4))) 
> (force lazy) 
computing ... ;; Computes 3 + 4 and memoizes the result. 
7 
> (my-force lazy) 
7 ;; Returns the memoized value.