Qu'est-ce que le mot de passe et comment ça marche exactement?

Question

J'ai vérifié sur wikipedia et sur Google, mais je ne parviens toujours pas à comprendre comment fonctionne la pass-name pour ALGOL 60.

Answer 1

J'ai trouvé une bonne explication à Paramètre Pass-By-Name Passing . Essentiellement, le corps d'une fonction est interprété au moment de l'appel après la substitution textuelle des paramètres réels dans le corps de la fonction. En ce sens, la méthode d’évaluation est similaire à celle des macros du préprocesseur C.

En substituant les paramètres réels dans le corps de la fonction, celui-ci peut à la fois lire et écrire les paramètres donnés. En ce sens, la méthode d'évaluation est similaire à la méthode de référence. La différence réside dans le fait que puisque le paramètre passe-par-nom est évalué dans la fonction, un paramètre tel que a [i] dépend de la valeur actuelle de . i dans la fonction, plutôt que de faire référence à la valeur en a [i] avant l'appel de la fonction.

La page que j'ai liée ci-dessus contient d'autres exemples de cas où la méthode de passe-nom est à la fois utile et dangereuse. Les techniques rendues possibles par le passage par nom sont aujourd'hui largement remplacées par d'autres techniques plus sûres telles que le passage par référence et les fonctions lambda.

Answer 2

Je suppose que vous voulez dire appel par nom dans ALGOL 60.

Appel par nom est similaire à appel par référence en ce que vous pouvez modifier la valeur du paramètre transmis. Il diffère de l'appel par référence en ce que le paramètre n'est pas évalué avant l'appel de la procédure, mais est plutôt évalué paresseusement. C'est-à-dire qu'il est évalué quand et seulement quand le paramètre est réellement utilisé.

Par exemple, supposons que nous ayons une procédure f (x, y) et que nous la passions i et i / 2 où i est initialement égal à 10 . Si f définit x sur 42 , puis évalue y , la valeur 21 (alors qu'appel par référence ou par valeur, il verrait toujours 5 ). En effet, l'expression i / 2 n'est pas évaluée tant que y n'est pas évalué.

À bien des égards, cela semble se comporter comme une substitution textuelle littérale des paramètres (avec renommer pour éviter les conflits de noms). En pratique, cependant, cela est mis en œuvre en utilisant "thunks". (essentiellement des fermetures) pour les expressions passées.

L'article de Wikipedia sur le Le dispositif de Jensen montre quelques exemples intéressants d'utilisation de l'appel par son nom. . En voici un:

real procedure Sum(k, l, u, ak)
     value l, u;
     integer k, l, u;
     real ak;
     comment k and ak are passed by name;
 begin
     real s;
     s := 0;
     for k := l step 1 until u do
         s := s + ak;
     Sum := s
 end;

     

Dans la procédure, la variable d'indexation k et le terme de sommation ak sont   passé par nom. Appel par nom permet à la procédure de modifier la valeur   de la variable d'index lors de l'exécution de la boucle for. Appeler par nom   provoque également la réévaluation de l'argument ak à chaque itération de   la boucle. En règle générale, ak dépendra du changement (effet secondaire)    k .

     

Par exemple, utilisez un code pour calculer la somme des 100 premiers termes d'un réel   tableau V [] serait:

Sum(i, 1, 100, V[i]).

Answer 3

Pour les futurs:

Concepts dans les langages de programmation par John C. Mitchell a également été utile.

  

Pass-by-Name . Peut-être le plus étrange   rétrospectivement, la fonction d’Algol 60 est   l'utilisation du mot de passe. Dans   passe-par-nom, résultat d'un   appel de procédure est le même que si le   paramètre formel ont été substitués dans   le corps de la procédure. Cette règle   pour définir le résultat d'une procédure   appeler en copiant la procédure et   substituer aux paramètres formels   s'appelle la règle de copie Algol 60.   Bien que la règle de copie fonctionne bien pour   programmes fonctionnels purs, comme   illustré par ß réduction de lambda   calcul, l'interaction avec le côté   les effets sur le paramètre formel sont un   un peu étrange. Voici un exemple   programme montrant une technique référée   comme dispositif de Jensen: passer un   expression et une variable qu'il contient   à une procédure afin que la procédure   peut utiliser un paramètre pour changer le   emplacement mentionné par l'autre:

     

 begin integer i;
        integer procedure sum(i, j);
            integer i, j;
                comment parameters passed by name;
            begin integer sm; sm := 0;
                for i := 1 step 1 until 100 do sm := sm + j;
                sum := sm
            end;
        print(sum(i, i*10 ))
 end

  

Dans ce programme, la procédure   somme (i, j) additionne les valeurs de j comme i   va de 1 à 100. Si vous regardez le   code, vous vous rendrez compte que le   procédure n'a de sens que si   les changements que je provoque un changement dans la   valeur de j; sinon, la procédure   calcule simplement 100 * j. Dans l'appel   somme (i, i * 10) montrée ici, la boucle for   dans le corps de la procédure somme somme   la valeur de i * 10 lorsque je passe de 1 à   100.

Answer 4

En fait, appel par nom, n’est pas seulement une curiosité historique. Vous pouvez effectuer un appel par nom dans les fichiers de commandes Windows (et dans une myriade d'autres langages de script). Savoir comment cela fonctionne et comment l'utiliser efficacement dans la programmation peut apporter des solutions judicieuses aux problèmes. Je sais qu’il ne fait que passer des chaînes pour une expansion ultérieure, mais il peut être manipulé pour produire des effets similaires à ceux d’appel par nom.

call :assign x 1
exit /b
:assign
setlocal enabledelayedexpansion
(endlocal
:: Argument 1 is the name of the variable
set %1=%2
)
exit /b

Answer 5

Flatlander a un exemple éloquent de son fonctionnement en Scala ici . Supposons que vous souhaitiez implémenter tandis que :

def mywhile(condition: => Boolean)(body: => Unit): Unit =
  if (condition) {
    body
    mywhile(condition)(body)
  }

     

Nous pouvons appeler cela comme suit:

var i = 0
mywhile (i < 10) {
  println(i)
  i += 1
}

Scala n’est pas Algol 60, mais c’est peut-être un peu éclairant.

Answer 6

Vous pouvez passer le mot "name". sous la forme symbolique d'une variable qui lui permet d'être à la fois mis à jour et accessible simultanément. Par exemple, disons que vous voulez tripler une variable x de type int:

start double(x);
real x;
begin
x : = x * 3
end;

Answer 7

ALGOL a été conçu pour les algorithmes mathématiques. J'aime la fonction de sommation comme exemple d'appel par nom.

Désolé, mon ALGOL est un peu rouillé, la syntaxe n’est probablement pas correcte.

.FUNCTION SUM(var,from,to,function)
.BEGIN
  .REAL sum =0;
  .FOR var = from .TO to .DO sum = function;
  return sum;
.END

Vous pouvez utiliser une somme comme

  Y = sum(x,1,4,sum(y,3,8,x+y));

Dans ce qui précède, la somme interne (y, 3,8, x + y) générerait une fonction non nommée à transmettre à l’appel de la somme externe. Les variables x et y ne sont pas passées par valeur mais par nom. Dans le cas de variables, appeler par nom équivaut à appeler par référence d'adresse en C. Cela devient un peu déroutant lorsque la récursivité est impliquée.

Borrows a fabriqué des machines ALGOL. Ils avaient une mémoire de mots de 48 bits avec 3 bits de drapeau. Les bits de drapeau implémentaient le cal par nom d’ALGOL. C'était une machine à pile, donc quand la fonction était chargée sur la pile, l'appel par son nom fag la faisait appeler. Le compilateur générerait des fonctions non nommées lorsque des expressions étaient utilisées comme arguments. Une variable serait une simple référence indirecte. Une erreur surviendrait lors de l'écriture dans une fonction.

Answer 8

Je sais que je suis arrivé tard au club et ce n’est pas nécessairement une réponse, mais je voulais ajouter une chose qui pourrait aider à clarifier un peu. J'ai toujours pensé que le mot de passe Algol était un processus similaire à celui utilisé lorsque les directives du préprocesseur C ++ (les macros, en particulier) remplacent le nom d'une fonction / variable par le code réel au moment de la compilation. Le nom d'utilisateur passe essentiellement par le nom du paramètre formel par le paramètre actuel et s'exécute. Je n’ai jamais écrit en algol, mais j’entends dire que passe par nom aura le même résultat que le passage par référence de C ++.