Динамически -shallow связывание и глубокое связывание

Question

Я работаю над этой проблемой, и я получил ответы:

Статически: 13

Динамически -deep Переплет: 2 < - я не уверен, что этот

Динамически -shallow связывания: 2 < - я не уверен, что это один

правильно?

Рассмотрите программу ниже (на языке Pascal). Каков результат использования языка ? Каков выход языка с динамической областью и использует глубокую привязку? Каков результат работы языка с динамическим охватом и использует неглубокую привязку?

Program main; 
    x: integer := 2; 
    y: integer := 1; 
procedure f3(z: integer) 
    begin 
     x = z + x + y; 
    end 
procedure f2(p: procedure, z: integer) 
    int x := 5; 
    begin 
       p(z) 
    end 
procedure f1(z: integer) 
     int y := z 
    begin 
    f2(f3,y); 
    end 

begin /* main program */ 
f1(4); 
     print(x) 
end 

Answer 1

Для статического охвата и случаев с динамическим охватом с неглубокими связями, почему бы не попробовать их? Использование Perl со статической сферы:

my $x = 2; 
my $y = 1; 
sub f3($) { 
    my $z = shift; 
    $x = $z + $x + $y; 
} 
sub f2($$) { 
    my ($p, $z) = @_; 
    my $x = 5; 
    $p->($z); 
} 
sub f1($) { 
    my $z = shift; 
    my $y = $z; 
    f2(\&f3, $y); 
} 
f1(4); 
print "$x\n"; 

7 я (который 4 + 2 + 1). Изменение my s на local s для получения динамического объема с мелким привязкой, я получаю 2, как вы и предполагали.

Тестирование динамической области с глубокой привязкой сложнее, потому что так мало языков поддерживают ее. В this answer a while back я опубликовал Perl-код, который реализовал глубокое связывание «вручную», передав хэш ссылок на скаляры; используя тот же подход:

#!/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->{x} = new_scalar 2; 
$V->{y} = new_scalar 1; 

sub f3(\%$) { 
    my $V = shift; 
    my $z = $V->{z};     # save existing z 
    $V->{z} = new_scalar shift;  # create & initialize new z 
    ${$V->{x}} = ${$V->{z}} + ${$V->{x}} + ${$V->{y}}; 
    $V->{z} = $z;     # restore old z 
} 
sub f2(\%$$) { 
    my $V = shift; 
    my $p = shift; 
    my $z = $V->{z};     # save existing z 
    $V->{z} = new_scalar shift;  # create & initialize new z 
    my $x = $V->{x};     # save existing x 
    $V->{x} = new_scalar 5;   # create & initialize new x 
    $p->(${$V->{z}}); 
    $V->{x} = $x;     # restore old x 
    $V->{z} = $z;     # restore old z 
} 
sub f1(\%$) { 
    my $V = shift; 
    my $z = $V->{z};     # save existing z 
    $V->{z} = new_scalar shift;  # create & initialize new z 
    my $y = $V->{y};     # save existing y 
    $V->{y} = new_scalar ${$V->{z}}; # create & initialize new y 
    f2(%$V, bind_proc(%$V, \&f3), ${$V->{y}}); 
    $V->{y} = $y;     # restore old y 
    $V->{z} = $z;     # restore old z 
} 
f1(%$V, 4); 
print "${$V->{x}}\n"; 

__END__ 

я 10 (который 4 + 2 + 4).