Perl variable cuestión de alcance

Question

Así que tengo una clase de Perl. Tiene un método sort(), y yo quiero que sea más o menos idéntica a la incorporada en el sort() función:

$object->sort(sub ($$) { $_[0] <=> $_[1] }); 

Pero no puedo hacer:

$object->sort(sub { $a <=> $b }); 

Debido alcance. Pero el módulo List :: Util hace esto con reduce(). Miré el módulo List :: Util, y hacen algunas cosas bastante desagradables con no strict 'vars' para que esto suceda. Intenté eso, pero fue en vano.

Tengo entendido que reduce() funciona de la forma en que lo hace porque se exporta al espacio de nombres apropiado, y por lo tanto mi clase no puede hacerlo ya que la función está firmemente en otro espacio de nombres. ¿Es correcto o hay alguna forma (indudablemente más espantosa y desaconsejable) de hacerlo en mi situación?

Answer 1

Bueno, las otras dos respuestas son a la vez la mitad derecha. He aquí una solución de trabajo que realmente géneros:

package Foo; 

use strict; 
use warnings; 

sub sort { 
    my ($self, $sub) = @_; 

    my ($pkg) = caller; 
    my @x = qw(1 6 39 2 5); 
    print "@x\n"; 
    { 
     no strict 'refs'; 
     @x = sort { 
      local (${$pkg.'::a'}, ${$pkg.'::b'}) = ($a, $b); 
      $sub->(); 
     } @x; 
    } 
    print "@x\n"; 

    return; 
} 


package main; 

use strict; 
use warnings; 

my $foo = {}; 
bless $foo, 'Foo'; 

$foo->sort(sub { $a <=> $b }); 
# 1 6 39 2 5 
# 1 2 5 6 39 

Es de suponer que habría ordenar algunos datos que en realidad es parte del objeto.

Necesita la magia caller para localizar $a y $b en el paquete de la persona que llama, que es donde Perl los va a buscar. Está creando variables globales que solo existen mientras se está llamando a ese sub.

Tenga en cuenta que obtendrá un 'nombre usado una sola vez' con warnings; Estoy seguro de que hay algunos aros que puedes saltar para evitar esto, de alguna manera.

Answer 2

Puede utilizar the local operator para establecer los valores de $a y $b durante la duración de la llamada del subprograma:

sub sample 
{ 
    my $callback = shift; 
    for (my $i = 0; $i < @_; $i += 2) { 
     local ($a, $b) = @_[$i, $i + 1]; 
     $callback->(); 
    } 
}  

sample sub { print "$a $b\n" }, qw(a b c d e f g h i j); 

Si usted tiene una subrutina de ordinario, en lugar de un método, entonces usted puede hacer que sea aún más como sort, por lo que no necesita usar sub antes de su función de devolución de llamada. Utilizar un prototipo de la función:

sub sample (&@) 

Entonces llaman a llamarlo así:

sample { print "$a $b\n" } qw(a b c d e f g h i j); 

métodos, sin embargo, no están influenciados por prototipos.

Answer 3

Puede usar Sub::Identify para encontrar el paquete (al que llama stash_name) asociado con el valor del código. Luego configure $ a y $ b en ese paquete según sea necesario. Es posible que necesite usar no strict 'refs' en su método para que funcione.

Aquí es la respuesta de Evee modificado para que funcione en el caso general:

use strict; 
use warnings; 

package Foo; 

use Sub::Identify 'stash_name'; 

sub sort { 
    my ($self, $sub) = @_; 

    my $pkg = stash_name($sub); 
    my @x = qw(1 6 39 2 5); 
    print "@x\n"; 
    { 
     no strict 'refs'; 
     @x = sort { 
      local (${$pkg.'::a'}, ${$pkg.'::b'}) = ($a, $b); 
      $sub->(); 
     } @x; 
    } 
    print "@x\n"; 

    return; 
} 


package Sorter; 

sub compare { $a <=> $b } 

package main; 

use strict; 
use warnings; 

my $foo = {}; 
bless $foo, 'Foo'; 

$foo->sort(\&Sorter::compare); 

$foo->sort(sub { $b <=> $a });