¿Por qué una subclase no hereda las constantes de sus padres?

Question

Así que estaba haciendo mi negocio de Moosey y pensé que sería bueno usar una constante en estos lugares donde estoy usando números para aclarar lo que significan estos números o en caso de que cambien más tarde

So en la clase padre añadí el estándar 'uso constante'

package Parent; 
    use constant { 
     NO_LEVEL => 0, 
     MY_LEVEL => 1, 
     YOUR_LEVEL => 2, 
    }; 

package Child; 
extends 'Parent'; 

#just to demonstrate that child can or cannot access the constant 
sub printMyLevel{ 
print MY_LEVEL; 
} 

pero la clase niño no es consciente de las constantes seleccionadas en la matriz! doh!

Supongo que tengo que hacer algo de magia de Moose para que esto funcione bien, o algo completamente distinto. Mi búsqueda en este tema no obtuvo ningún resultado =/

Answer 1

Dado que las constantes son subrutinas y puede obtener la herencia llamándolas como métodos, el bit ya se ha cubierto hasta la muerte, aquí hay un giro diferente en las cosas.

Si sabe que está trabajando solamente en un solo archivo, puede utilizar las constantes léxicas a los paquetes de puente:

package Parent; 
    our ($NO_LEVEL, $MY_LEVEL, $YOUR_LEVEL); 
    *NO_LEVEL = \0; # this split declaration installs aliases to numbers 
    *MY_LEVEL = \1; # into the lexicals. since numbers are constants 
    *YOUR_LEVEL = \2; # to perl, the aliased names are also constants 

package Child; 

# just to demonstrate that anything below can access the constants 
sub printAll { 
    print "$NO_LEVEL $MY_LEVEL $YOUR_LEVEL\n"; 
} 

Child->printAll; # 0 1 2 

eval {$NO_LEVEL = 3} or print "error: $@\n"; 
# error: Modification of a read-only value attempted at ... 

Si usted no necesita Perl a morir cuando se asigna a la constante, la declaración our se hace un poco más simple (y podría ser una my):

our ($NO_LEVEL, $MY_LEVEL, $YOUR_LEVEL) = (0, 1, 2); 

puede traer de vuelta a la naturaleza constante sin dejar de utilizar la sintaxis concisa con un poco de magia:

my $constant = sub {Internals::SvREADONLY($_[$_], 1) for 0 .. $#_}; 

package Parent; 
    $constant->(our ($NO_LEVEL, $MY_LEVEL, $YOUR_LEVEL) = (0, 1, 2)); 

package Child; 

# just to demonstrate that anything below can access the constants 
sub printAll { 
    print "$NO_LEVEL $MY_LEVEL $YOUR_LEVEL\n"; # interpolates :) 
} 

Child->printAll; # 0 1 2 

eval {$NO_LEVEL = 3} or print "error: $@\n"; 
# error: Modification of a read-only value attempted at ... 

Por supuesto, puede omitir el coderef $constant en línea y de la magia:

package Parent; 
    Internals::SvREADONLY($_, 1) 
     for our ($NO_LEVEL, $MY_LEVEL, $YOUR_LEVEL) = (0, 1, 2); 

Answer 2

Las constantes son subrutinas.

{ 
    package Parent; 
    use Moose; 
    use namespace::autoclean; 

    use constant { 
     NO_LEVEL => 0, 
     MY_LEVEL => 1, 
     YOUR_LEVEL => 2, 
    }; 
    __PACKAGE__->meta->make_immutable; 
}; 

{ 
    package Child; 
    use Moose; 
    use namespace::autoclean; 

    extends 'Parent'; 

    sub printMyLevel { 
     my $self = shift; 
     my $class = ref $self; 

     print $class->MY_LEVEL; 
    } 
    __PACKAGE__->meta->make_immutable; 
} 

package main; 

my $child = Child->new; 
$child->printMyLevel; 

Tenga en cuenta que las constantes son subrutinas con un prototipo vacío. perl aprovecha esto para alinearlos durante la compilación. Sin embargo, el método llama a ignorar los prototipos y, por lo tanto, las constantes heredadas a las que se accede de esta forma no se incluirán en línea.

Answer 3

Llámalos como método.

sub printMyLevel{ 
    my ($self,) = $_; 
    print $self->MY_LEVEL; 
} 

Answer 4

Esto es en realidad mencionado en el documentation, aunque sólo sea de pasada:

"Constantes pertenecen al paquete que se definen en hacer referencia a una constante definida en otro paquete, especifique el pleno. nombre del paquete, como en Some::Package::CONSTANT. Las constantes pueden exportarse por módulos y también pueden llamarse como métodos de clase o instancia, es decir, como Some::Package->CONSTANT o como $obj->CONSTANT donde $obj es una instancia de Some::Package. Las subclases pueden definir sus propias constantes para sobrescribir aquellos en su clase base ".

Answer 5

La herencia afecta a las llamadas a los métodos ($x->m), punto.