Wertbindungen in SML?

Question

Könnte jemand bitte helfen. Ich bekomme hier nicht die Reihenfolge der Auswertung und wie wir Werte von "ans" bekommen haben. z.B. Im ersten Beispiel gibt es keinen Wert von y und ich bin mir nicht sicher, ob dies ein Paar zurückgibt oder x aufruft! (Fny => yx). Es wäre sehr hilfreich, wenn Sie jeden Ausdruck verfolgen können.

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

Es gibt ein paar Dinge, die Probleme wie diese viel klarer machen helfen, wenn ein Ausländer Funktion Lexical scoping Arbeiten versuchen, verstehen.

1. in Typen den Parameter hinzufügen und Werte zurückgeben, ohne das Programm zu modifizieren, der Compiler wird Ihnen sagen, wenn Sie es falsch ...
2. mit dem Namen diejenigen anonyme Funktionen ersetzen.
3. benennen Sie Variablenbindungen um, die denselben Namen haben, sich aber auf unterschiedliche lexikalische Bereiche beziehen.
4. entfernen Sie variable Bindungen, die nur einmal verwendet werden.

Wert auf einen Namen verfügen jedoch nicht bindend tatsächlich jede Berechnung, so nur zum Nutzen des Lesers ist, wenn es nicht diesen Job tun, ist es nur, dann mit allen Mitteln zu verschleiern dient es entfernen .

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

so g als Parameter f gegeben ist, f g ruft sie den Parameter x zu geben, um den Wert 1 Herstellung y2 = 1, die 7 g subtrahiert - 1 6. der Rückgabewert von g zurückkehr ein int, also f ist ein Typ, wenn g auf ihn angewendet wird, ist ein int.

für die zweite man es ein wenig aufzuräumen, zog ich die anonymen FN in eigene und benannten Werte und Call-f (foo, bar), um es besser lesbar ...

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

Schließlich wir können loszuwerden, die let-Werte erhalten, die einmal nur verwendet werden, und ersetzen Sie die (z, w) = p mit nur (z, w) als Parameter an die Funktion, die viel einfacher sein sollte

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 

folgen