Qu'est-ce que "Call By Name"?

Je suis en train de travailler sur un devoir à la maison où nous sommes invités à mettre en œuvre une stratégie d'évaluation de l'appel "par nom" dans une certaine langue que nous avons développé (à l'aide de Schéma).

On nous a donné une exemple en Scalamais je ne comprends pas comment "appel par nom" fonctionne et comment il est différent de "l'appel par nécessité"?

source d'informationauteur forellana

  1. 24

    Appel par nécessité est un memoized version de l'appel par le nom (voir wikipedia).

    En appel par le nom, l'argument est évalué à chaque fois qu'il est utiliséalors qu'en appel par nécessité, elle est évaluée la première fois qu'il est utilisé, et la valeur enregistrée de sorte que par la suite il n'a pas besoin d'être ré-évalué.

  2. 10

    Appeler par son nom est un paramètre passant régime où le paramètre est évalué lorsqu'il est utilisé, pas quand la fonction est appelée. Voici un exemple 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.
}

    L'argument expression est paresseusement évalués lors de l'accès en utilisant les valeurs actuelles de l'argument de l'expression.

  3. 2

    Ajoutez à cela les réponses ci-dessus:

    De travail par le biais de la SICP section sur les cours d'eau. Il donne une bonne explication à la fois en appel par nom et appel par nécessité. Il montre également comment mettre en œuvre ces dans le Schéma. BTW, si vous êtes à la recherche pour une solution rapide, voici un appel de base-par-besoin en œuvre dans le Schéma:

     ;; 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))

    Un exemple d'exécution:

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