Proporcionaré una respuesta aquí, ya que las de aquí no hicieron clic para mí.
La función de bendición de Perl asocia cualquier referencia a todas las funciones dentro de un paquete.
¿Por qué necesitaríamos esto?
Comencemos expresando un ejemplo en JavaScript:
(() => {
'use strict';
class Animal {
constructor(args) {
this.name = args.name;
this.sound = args.sound;
}
}
/* [WRONG] (global scope corruption)
* var animal = Animal({
* 'name': 'Jeff',
* 'sound': 'bark'
* });
* console.log(animal.name + ', ' + animal.sound); // seems good
* console.log(window.name); // my window's name is Jeff?
*/
// new is important!
var animal = new Animal(
'name': 'Jeff',
'sound': 'bark'
);
console.log(animal.name + ', ' + animal.sound); // still fine.
console.log(window.name); // undefined
})();
Ahora, eliminemos el constructo de la clase y lo hagamos sin él:
(() => {
'use strict';
var Animal = function(args) {
this.name = args.name;
this.sound = args.sound;
return this; // implicit context hashmap
};
// the "new" causes the Animal to be unbound from global context, and
// rebinds it to an empty hash map before being constructed. The state is
// now bound to animal, not the global scope.
var animal = new Animal({
'name': 'Jeff',
'sound': 'bark'
});
console.log(animal.sound);
})();
La función toma una tabla hash de propiedades desordenadas (ya que no tiene sentido escribir propiedades en un orden específico en lenguajes dinámicos en 2016) y devuelve una tabla hash con esas propiedades, o si olvidó poner la nueva palabra clave, devolverá todo el contexto global (por ejemplo, ventana en el navegador o global en nodejs).
Perl no tiene "esto" ni "nuevo" ni "clase", pero aún puede tener una función que se comporte de manera similar. No tendremos un constructor ni un prototipo, pero podremos crear nuevos animales a voluntad y modificar sus propiedades individuales.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Ahora, tenemos un problema: ¿qué pasa si queremos que el animal realice los sonidos por sí mismo en lugar de que nosotros imprimamos cuál es su voz? Es decir, queremos una función de realizar el sonido que imprima el sonido del animal.
Una forma de hacerlo es enseñando a cada animal individual cómo hacer que suene. Esto significa que cada gato tiene su propia función duplicada para realizar el sonido.
# self contained scope
(sub {
my $Animal = (sub {
$name = $_[0]{'name'};
$sound = $_[0]{'sound'};
return {
'name' => $name,
'sound' => $sound,
'performSound' => sub {
print $sound . "\n";
}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
$animal->{'performSound'}();
})->();
Esto es malo porque performSound se coloca como un objeto de función completamente nuevo cada vez que se construye un animal. 10000 animales significa 10000 realizar sonidos. Queremos tener una sola función de realizar Sonido que sea utilizada por todos los animales que busquen su propio sonido y lo impriman.
(() => {
'use strict';
/* a function that creates an Animal constructor which can be used to create animals */
var Animal = (() => {
/* function is important, as fat arrow does not have "this" and will not be bound to Animal. */
var InnerAnimal = function(args) {
this.name = args.name;
this.sound = args.sound;
};
/* defined once and all animals use the same single function call */
InnerAnimal.prototype.performSound = function() {
console.log(this.name);
};
return InnerAnimal;
})();
/* we're gonna create an animal with arguments in different order
because we want to be edgy. */
var animal = new Animal({
'sound': 'bark',
'name': 'Jeff'
});
animal.performSound(); // Jeff
})();
Aquí es donde se detiene el paralelo a Perl.
El nuevo operador de JavaScript no es opcional, sin él, "esto" dentro de los métodos de objeto corrompe el alcance global:
(() => {
// 'use strict'; // uncommenting this prevents corruption and raises an error instead.
var Person = function() {
this.name = "Sam";
};
// var wrong = Person(); // oops! we have overwritten window.name or global.main.
// console.log(window.name); // my window's name is Sam?
var correct = new Person; // person's name is actually stored in the person now.
})();
Queremos tener una función para cada animal que busque el sonido de ese animal en lugar de codificarlo en la construcción.
La bendición nos permite usar un paquete como prototipo de objetos. De esta forma, el objeto conoce el "paquete" al que está "referenciado" y, a su vez, puede hacer que las funciones del paquete "lleguen" a las instancias específicas que se crearon a partir del constructor de ese "objeto de paquete":
package Animal;
sub new {
my $packageRef = $_[0];
my $name = $_[1]->{'name'};
my $sound = $_[1]->{'sound'};
my $this = {
'name' => $name,
'sound' => $sound
};
bless($this, $packageRef);
return $this;
}
# all animals use the same performSound to look up their sound.
sub performSound {
my $this = shift;
my $sound = $this->{'sound'};
print $sound . "\n";
}
package main;
my $animal = Animal->new({
'name' => 'Cat',
'sound' => 'meow'
});
$animal->performSound();
Resumen / TL; DR :
Perl no tiene "esto", "clase", ni "nuevo". bendecir un objeto a un paquete le da a ese objeto una referencia al paquete, y cuando llama a funciones en el paquete, sus argumentos se compensarán con 1 ranura, y el primer argumento ($ _ [0] o shift) será equivalente a "esto" de javascript. A su vez, puede simular de alguna manera el modelo prototipo de JavaScript.
Desafortunadamente, hace que sea imposible (a mi entender) crear "nuevas clases" en tiempo de ejecución, ya que necesita que cada "clase" tenga su propio paquete, mientras que en JavaScript, no necesita paquetes en absoluto, como palabra clave "nueva" crea un hashmap anónimo para que lo use como un paquete en tiempo de ejecución al que puede agregar nuevas funciones y eliminar funciones sobre la marcha.
Hay algunas bibliotecas de Perl que crean sus propias formas de reducir esta limitación en la expresividad, como Moose.
¿Por qué la confusión? :
Por los paquetes. Nuestra intuición nos dice que vinculemos el objeto a un hashmap que contenga su 'prototipo. Esto nos permite crear "paquetes" en tiempo de ejecución como puede hacerlo JavaScript. Perl no tiene tanta flexibilidad (al menos no está integrado, tiene que inventarlo u obtenerlo de otros módulos) y, a su vez, su expresividad en tiempo de ejecución se ve obstaculizada. Llamarlo "bendecir" tampoco le hace mucho favor.
Lo que queremos hacer :
Algo como esto, pero tiene un enlace recursivo al mapa prototipo y está implícitamente vinculado al prototipo en lugar de tener que hacerlo explícitamente.
Aquí hay un intento ingenuo: el problema es que "call" no sabe "qué lo llamó", por lo que bien podría ser una función perl universal "objectInvokeMethod (objeto, método)" que verifica si el objeto tiene el método , o su prototipo lo tiene, o su prototipo lo tiene, hasta que llega al final y lo encuentra o no (herencia prototípica). Perl tiene buena magia de evaluación para hacerlo, pero lo dejaré para algo que pueda intentar hacer más tarde.
De todos modos aquí está la idea:
(sub {
my $Animal = (sub {
my $AnimalPrototype = {
'performSound' => sub {
return $_[0]->{'sound'};
}
};
my $call = sub {
my $this = $_[0];
my $proc = $_[1];
if (exists $this->{$proc}) {
return $this->{$proc}->();
} else {
return $this->{prototype}->{$proc}->($this, $proc);
}
};
return sub {
my $name = $_[0]->{name};
my $sound = $_[0]->{sound};
my $this = {
'this' => $this,
'name' => $name,
'sound' => $sound,
'prototype' => $AnimalPrototype,
'call' => $call
};
};
})->();
my $animal = $Animal->({
'name' => 'Jeff',
'sound'=> 'bark'
});
print($animal->{call}($animal, 'performSound'));
})->();
De todos modos, espero que alguien encuentre útil esta publicación.