Necesito un final de acción de alcance léxico que pueda morir normalmente

Question

Necesito la habilidad de agregar acciones al final de un bloque léxico donde la acción puede morir. Y necesito la excepción para ser arrojado normalmente y poder ser atrapado normalmente.

Lamentablemente, Perl excepciones de casos especiales durante DESTROY tanto agregando "(en la limpieza)" al mensaje y haciéndolo imposible de trazar. Por ejemplo:

{ 
    package Guard; 

    use strict; 
    use warnings; 

    sub new { 
     my $class = shift; 
     my $code = shift; 
     return bless $code, $class; 
    } 

    sub DESTROY { 
     my $self = shift; 
     $self->(); 
    } 
} 

use Test::More tests => 2; 

my $guard_triggered = 0; 

ok !eval { 
    my $guard = Guard->new(
#line 24 
     sub { 
      $guard_triggered++; 
      die "En guarde!" 
     } 
    ); 
    1; 
}, "the guard died"; 

is $@, "En guarde! at $@ line 24\n", "with the right error message"; 
is $guard_triggered, 1,     "the guard worked"; 

Quiero que pase. En la actualidad, la excepción es totalmente tragada por la evaluación.

Esto es para Test :: Builder2, por lo que no puedo usar nada más que Perl puro.

El problema subyacente es que tengo un código como éste:

{ 
    $self->setup; 

    $user_code->(); 

    $self->cleanup; 
} 

que la limpieza debe ocurrir incluso si el $ user_code muere, otro $ auto entra en un estado extraño. Así que hice esto:

{ 
    $self->setup; 

    my $guard = Guard->new(sub { $self->cleanup }); 

    $user_code->(); 
} 

La complejidad viene porque la limpieza se ejecuta código de usuario arbitrario y se trata de un caso de uso en donde el Código morirá. Espero que esa excepción sea atrapable e inalterada por el guardia.

Estoy evitando envolver todo en bloques eval debido a la forma en que altera la pila.

Answer 1

ACTUALIZACIÓN: ¡El enfoque a continuación no parece funcionar como está escrito como señaló Eric !.

Dejo esta respuesta en caso de que alguien pueda ponerla en funcionamiento.

El problema es:

que esperaba que al quitar los viejos valor mundial de nuevo en la variable atada mundial una vez que el local se sale del ámbito implicará una llamada a FETCH/almacén, pero de alguna manera esto sólo sucede en silencio sin tocar el mecanismo vinculado (el problema es irrelevante para el manejo de excepciones).

---

Schwern - No estoy 100% seguro de que puede utilizar la técnica del lazo (robado de Perlmonks post by Abigail) para su caso de uso - aquí está mi intento de hacer lo que creo que estaba tratando de hacer

use Test::More tests => 6; 

my $guard_triggered = 0; 
sub user_cleanup { $guard_triggered++; die "En guarde!" }; # Line 4; 
sub TIESCALAR {bless \(my $dummy) => shift} 
sub FETCH  { user_cleanup(); } 
sub STORE  {1;} 
our $guard; 
tie $guard => __PACKAGE__; # I don't think the actual value matters 

sub x { 
    my $x = 1; # Setup 
    local $guard = "in x"; 
    my $y = 2; #user_code; 
} 

sub x2 { 
    my $x = 1; # Setup 
    local $guard = "in x2"; 
    die "you bastard"; #user_code; 
} 

ok !eval { 
    x(); 
}, "the guard died"; 
is $@, "En guarde! at $0 line 4.\n", "with the right error message"; 
is $guard_triggered, 1,     "the guard worked"; 

ok !eval { 
    x2(); 
}, "the guard died"; 
is $@, "En guarde! at $0 line 4.\n", "with the right error message"; 
is $guard_triggered, 2,     "the guard worked"; 

SALIDA:

1..6 
ok 1 - the guard died 
ok 2 - with the right error message 
ok 3 - the guard worked 
ok 4 - the guard died 
ok 5 - with the right error message 
ok 6 - the guard worked 

Answer 2

¿Es esta semánticamente sonido? Por lo que entiendo, usted tiene esta (en pseudocódigo):

try { 
    user_code(); # might throw 
} 
finally { 
    clean_up(); # might throw 
} 

hay dos posibilidades:

• user_code() y clean_up() nunca va a lanzar en el mismo plazo, en cuyo caso sólo se puede escribirlo como código secuencial sin ningún tipo de negocio divertido de guardia y funcionará.
• user_code() y clean_up() pueden, en algún momento, lanzar ambos en la misma ejecución.

Si ambas funciones pueden arrojarse, entonces tiene dos excepciones activas. No sé cualquier lenguaje que pueda manejar múltiples excepciones activas actualmente lanzadas, y estoy seguro de que hay una buena razón para esto. Perl agrega (in cleanup) y hace la excepción imposible de trazar; C++ calls terminate(), Java drops the original exception silently, etc, etc

Si acaba de salir de una eval en el que tanto user_code() y cleanup() arrojó excepciones, ¿qué esperas de encontrar en $@?

Por lo general, esto indica que necesita para manejar la excepción de limpieza a nivel local, tal vez haciendo caso omiso de la excepción de limpieza:

try { 
    user_code(); 
} 
finally { 
    try { 
     clean_up(); 
    } 
    catch { 
     # handle exception locally, cannot propagate further 
    } 
} 

o tiene que elegir una excepción a ignorar cuando ambos tiro (que es lo que hace la solución de DVK; ignora la excepción user_code()):

try { 
    user_code(); 
} 
catch { 
    $user_except = $@; 
} 
try { 
    cleanup(); 
} 
catch { 
    $cleanup_except = $@; 
} 
die $cleanup_except if $cleanup_except; # if both threw, this takes precedence 
die $user_except if $user_except; 

o de alguna manera combinar las dos excepciones en una excepción objeto:

try { 
    user_code(); 
} 
catch { 
    try { 
     clean_up(); 
    } 
    catch { 
     throw CompositeException; # combines user_code() and clean_up() exceptions 
    } 
    throw; # rethrow user_code() exception 
} 
clean_up(); 

Creo que debería haber una manera de evitar repetir la línea clean_up() en el ejemplo anterior, pero no puedo pensar en ello.

En resumen, sin saber lo que usted piensa que debería suceder cuando se lanzan ambas partes, su problema no puede ser respondido.