Dynamische/Statische Rahmen mit Deep/Shallow binding (übungen)

Ihre Antwort für lexikalische (statische) Umfang korrekt ist. Ihre Antworten für dynamische Umfang falsch sind, aber wenn ich lese deine Erklärungen Recht, es ist, weil Sie verwirrt zwischen u und v, statt wegen jeder echte Missverständnis darüber, wie Tiefe und flache Bindung arbeiten. (Ich gehe davon aus, dass Ihre u/v Verwirrung war nur Zufall und nicht durch eine seltsame Verwirrung über Werte vs. Verweise im Aufruf foo.)

a) Verwendung von statischen Bereich? Antwort=180

Richtig.

b) mit dynamischen Umfang und Tiefe Bindung? Antwort=69 (Summe u = 126, aber es ist foo lokalen v, richtig?)

Ihre verklärende Erklärung ist richtig, aber deine Antwort ist falsch: u ist in der Tat zu 126, und foo tatsächlich lokalisiert v, aber da main Drucke u, nicht v, die Antwort ist 126.

c) die Verwendung dynamischer Bereich und flacher Bindung? Antwort=69 (Summe u = 101 aber es ist foo lokalen v, richtig?)

Die Summe für u ist eigentlich 97 (42+13+42), aber da bar lokalisiert u, die Antwort ist 42. (Ihre verklärende Erklärung ist falsch, für diese ein — Sie scheinen zu haben, verwendet die Globale variable w, die 17, in der Interpretation der Aussage int u := w in der definition von bar; aber diese Aussage bezieht sich eigentlich auf foo's lokale variable w, seine zweite parameter, der 13. Aber das hat nicht wirklich Einfluss auf die Antwort. Deine Antwort falsch ist, nur diesen einen, weil main Drucke u, nicht v.)

Zur lexikalischen Bereich, ist es ziemlich einfach, überprüfen Sie Ihre Antworten mit der übersetzung der pseudo-code in eine Sprache mit lexikalischen scope. Ebenfalls dynamischen Bereich mit einer geringen Bindung. (In der Tat, wenn Sie Perl verwenden, können Sie testen, beide Wege fast auf einmal, da es unterstützt; verwenden Sie my für den lexikalischen Bereich, dann eine suchen-und-ersetzen zu ändern, um local für dynamische Umfang. Aber selbst wenn Sie, sagen wir, JavaScript lexikalischen Umfang und Bash für dynamische Umfang, es sollte schnell zu testen.)

Dynamischen Bereich mit tiefer Bindung ist viel schwieriger, da einige weit verbreitete Sprachen unterstützen. Wenn Sie Perl verwenden, können Sie implementieren, es manuell, indem ein hash (assoziatives array), die Karten von Variablen-Namen zu Skalar-refs, und übergeben Sie diesen hash von Funktion zu Funktion. Überall, wo der pseudocode deklariert eine lokale variable, die Sie speichern Sie die vorhandenen Skalar-Referenz in Perl lexikalische variable ist, dann setzen Sie die neue Zuordnung in der hash -; und am Ende der Funktion, die Sie wiederherstellen der ursprünglichen skalaren-Referenz. Zur Unterstützung der Bindung, erstellen Sie eine wrapper-Funktion, die erstellt eine Kopie der hash und übergibt , dass seiner gewickelt Funktion. Hier ist eine dynamisch scoped -, tief-verbindliche Umsetzung des Programms in Perl, mit diesem Ansatz:

#!/usr/bin/perl -w

use warnings;
use strict;

# Create a new scalar, initialize it to the specified value,
# and return a reference to it:
sub new_scalar($)
  { return \(shift); }

# Bind the specified procedure to the specified environment:
sub bind_proc(\%$)
{
  my $V = { %{+shift} };
  my $f = shift;
  return sub { $f->($V, @_); };
}

my $V = {};

$V->{u} = new_scalar 42; # int u := 42
$V->{v} = new_scalar 69; # int v := 69
$V->{w} = new_scalar 17; # int w := 17

sub add(\%$)
{
  my $V = shift;
  my $z = $V->{z};                     # save existing z
  $V->{z} = new_scalar shift;          # create & initialize new z
  ${$V->{u}} = ${$V->{v}} + ${$V->{u}} + ${$V->{z}};
  $V->{z} = $z;                        # restore old z
}

sub bar(\%$)
{
  my $V = shift;
  my $fun = shift;
  my $u = $V->{u};                     # save existing u
  $V->{u} = new_scalar ${$V->{w}};     # create & initialize new u
  $fun->(${$V->{v}});
  $V->{u} = $u;                        # restore old u
}

sub foo(\%$$)
{
  my $V = shift;
  my $x = $V->{x};                     # save existing x
  $V->{x} = new_scalar shift;          # create & initialize new x
  my $w = $V->{w};                     # save existing w
  $V->{w} = new_scalar shift;          # create & initialize new w
  my $v = $V->{v};                     # save existing v
  $V->{v} = new_scalar ${$V->{x}};     # create & initialize new v
  bar %$V, bind_proc %$V, \&add;
  $V->{v} = $v;                        # restore old v
  $V->{w} = $w;                        # restore old w
  $V->{x} = $x;                        # restore old x
}

foo %$V, ${$V->{u}}, 13;
print "${$V->{u}}\n";

__END__

und zwar druckt er 126. Es ist offensichtlich chaotisch und fehleranfällig, aber es hilft auch wirklich Sie verstehen, was Los ist, so für pädagogische Zwecke, ich denke, es lohnt sich!

Statische Bindung, auch bekannt als lexikalischen Umfang, bezieht sich auf den scoping-Mechanismus gefunden in den meisten modernen Sprachen.

In der "lexical scope", der Letzte Wert für u ist weder 180 oder 119, die falschen Antworten.

Die richtige Antwort ist u=101.

Finden Sie standard-Perl-code unten, um zu verstehen, warum.

use strict;
use warnings;

my $u = 42;
my $v = 69;
my $w = 17;

sub add {
    my $z = shift;
    $u = $v + $u + $z;
}

sub bar {
    my $fun = shift;
    $u = $w;
    $fun->($v);
}

sub foo {
    my ($x, $w) = @_;
    $v = $x;
    bar( \&add );
}

foo($u,13);
print "u: $u\n";

Bezüglich flache Bindung versus Tiefe Bindung, beide Instrumente stammen aus der ehemaligen LISP-ära.

Beide Mechanismen sind bedeutete, zu erreichen, dynamische Bindung (versus lexikalischen Umfang Bindung) und daher Sie produzieren identische Ergebnisse !

Die Unterschiede zwischen flache Bindung und Tiefe Bindung, die Ihren Wohnsitz nicht in der Semantik, die identisch sind, aber in der Umsetzung dynamische Bindung.

Mit Tiefe Bindung, Variablen-Bindungen liegen in einem Stapel als "varname =" > "varvalue" Paare.

• Den Wert einer bestimmten variable abgerufen wird, von der Durchquerung der stack von oben nach unten, bis eine Bindung für die gegebene variable gefunden wird.
• Aktualisierung der Variablen, besteht darin, die Bindung in den Stapel und aktualisiert den zugehörigen Wert.
• Beim Eintritt in ein Unterprogramm, eine neue Bindung für die jeweils aktuellen parameter auf dem Stapel abgelegt, möglicherweise versteckt sich eine ältere Bindung, die somit nicht mehr zugänglich wrt das abrufen Mechanismus oben beschrieben (das hält bei der 1. abgerufen Bindung).
• Beim verlassen des Unterprogramms Bindungen für diese Parameter sind einfach aufgetaucht, die aus der Bindung stack, so re-aktivieren des Zugriffs auf die früheren Bindungen.

Finden Sie den code unten ein Perl-Implementierung von deep-binding dynamischen Umfang.

use strict;
use warnings;
use utf8;

##
# Dynamic-scope deep-binding implementation
my @stack = ();

sub bindv {
    my ($varname, $varval);

    unshift @stack, [ $varname => $varval ]
        while ($varname, $varval) = splice @_, 0, 2;

    return $varval;
}

sub unbindv {
    my $n = shift || 1;
    shift @stack while $n-- > 0;
}

sub getv {
    my $varname = shift;

    for (my $i=0; $i < @stack; $i++) {
        return $stack[$i][1]
            if $varname eq $stack[$i][0];
    }

    return undef;
}

sub setv {
    my ($varname, $varval) = @_;

    for (my $i=0; $i < @stack; $i++) {
        return $stack[$i][1] = $varval
            if $varname eq $stack[$i][0];
    }
    return bindv($varname, $varval);
}

##
# EXERCICE
bindv(  u => 42,
        v => 69,
        w => 17,
);

sub add {
    bindv(z => shift);

     setv(u => getv('v')
               + getv('u')
               + getv('z')
    );

    unbindv();
}

sub bar {
    bindv(fun => shift);

     setv(u   => getv('w'));
    getv('fun')->(getv('v'));

    unbindv();
}

sub foo {
    bindv(x => shift,
          w => shift,
    );

     setv(v => getv('x'));
    bar( \&add );

    unbindv(2);
}

foo( getv('u'), 13);
print "u: ", getv('u'), "\n";

Das Ergebnis ist u=97

Dennoch, diese ständige Durchlaufen der Bindung stack ist teuer : 0(n) Komplexität !

Flache Bindung bringt eine wunderbare O(1) verbesserte Leistung gegenüber dem bisherigen Umsetzung !

Flache Bindung ist die Verbesserung der ehemaligen Mechanismus durch die Zuordnung jeder variable eine eigene "Zelle", die Speicherung wird der Wert der Variablen innerhalb der Zelle.

• Den Wert einer bestimmten variable ist einfach werden aus der variable
  Zelle (unter Verwendung einer hash-Tabelle auf Variablennamen, erreichen wir eine
  0(1) Komplexität für den Zugriff auf Variablen!)
• Aktualisierung der variable Wert ist, einfach speichern Sie den Wert in die
  variable Zelle.
• Erstellen einer neuen Bindung (Eingabe subs) funktioniert durch drücken der alt-Wert
  der Variablen (eine Vorherige Bindung) auf den stack und die Speicherung der
  neue lokale Wert in der Zelle "Wert".
• Beseitigung einer Bindung (ohne subs) arbeitet mit dem knallen der alte Wert
  aus dem stack in die variable, die den Wert der Zelle.

Lesen Sie bitte den folgenden code für eine einfache Perl-Implementierung von shallow-binding dynamischen Umfang.

use strict;
use warnings;

our $u = 42;
our $v = 69;
our $w = 17;
our $z;
our $fun;
our $x;

sub add {
    local $z = shift;
    $u = $v + $u + $z;
}

sub bar {
    local $fun = shift;
    $u = $w;
    $fun->($v);
}

sub foo {
    local $x = shift;
    local $w = shift;
    $v = $x;
    bar( \&add );
}

foo($u,13);
print "u: $u\n";

Wie Sie sehen werden, das Ergebnis ist immer noch u=97

Als Fazit, erinnere mich an zwei Dinge :

• flache Bindung liefert die gleichen Ergebnisse wie Tiefe Bindung, läuft aber schneller, da es nie eine Notwendigkeit, um die Suche für eine Bindung.

• Das problem ist nicht flache Bindung versus Tiefe Bindung versus
  
  statische Bindung ABER lexikalischen Umfang versus dynamischen Umfang (realisiert entweder mit deep-oder shallow-binding).