Liaisons de valeur dans SML?

Question

Quelqu'un pourrait-il m'aider s'il vous plaît. Je n'ai pas la séquence d'évaluation ici et comment nous avons obtenu des valeurs de "ans". par exemple. dans le premier exemple, il n'y a pas de valeur de y et je ne suis pas sûr que cela retourne une paire ou appelle x! (fn y => y x). Ce serait très utile si vous pouvez Tracer chaque expression.

val x = 1 
val f = (fn y => y x) 
val x = 7 
val g = (fn y => x - y) 
val ans = f g 

val ans = 6 : int 

===================================== 
fun f p = 
let 
val x = 3 
val y = 4 
val (z,w) = p 
in 
(z (w y)) + x 
end 
val x = 1 
val y = 2 
val ans = f((fn z => x + z), (fn x => x + x + 0)) 

val ans = 12 : int 

Answer 1

Il y a quelques choses qui aident à faire des problèmes comme celui-ci beaucoup plus claire lorsque vous essayez de comprendre une fonction étrangère Lexical scoping fonctionne.

1. ajouter dans les types des paramètres et renvoient des valeurs sans modifier le programme, le compilateur vous dira si vous vous trompez ...
2. fonctions anonymes avec remplacent celles nommées. Renommez les liaisons de variable qui ont le même nom mais qui se réfèrent à une portée lexicale différente.
4. Supprime les liaisons de variables qui ne sont utilisées qu'une seule fois.

liant une valeur à un nom ne est pas réellement exécutée tout calcul, donc est simplement au profit du lecteur, si elle ne fait pas ce travail il ne sert qu'à embrouiller, puis par tous les moyens l'enlever .

fun f (y1 : int -> 'a) = y1 1 : 'a; 
fun g (y2 : int) = 7 - y2 : int; 
val ans : int = f g; 

si g est donné en tant que paramètre à f, f appelle g donnant le paramètre x ayant la valeur 1 prise y2 = 1, g soustrait 7 - 1 reviennent 6. la valeur de retour de g est un int, donc f 'un type auquel g lui est appliqué est un int.

pour le 2ème nettoyer un peu, je tire les années anonymes de fn sortir dans leurs propres et valeurs nommées et appel f (foo, bar) pour le rendre plus lisible ...

fun f p = 
let val x = 3 
    val y = 4 
    val (z, w) = p 
    in (z (w y)) + x end 
fun foo z = z + 1; 
fun bar x = x * 2; 
val ans = f(foo, bar); 

Enfin , on peut se débarrasser des let valeurs qui ne sont utilisés qu'une fois et remise en place (z, w) = p avec juste (z, w) en tant que paramètre à la fonction qui devrait être beaucoup plus facile à suivre

fun f (z, w) = (z (w 4)) + 3 
fun foo z = z + 1; 
fun bar x = x * 2; 
val ans = f(foo, bar); 
val ans = ((4 * 2) + 1) + 3