Fornecerei uma resposta aqui, já que as que não foram encontradas aqui.
A função bless do Perl associa qualquer referência a todas as funções dentro de um pacote.
Por que precisamos disso?
Vamos começar expressando um exemplo em 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
})();
Agora vamos remover a construção da classe e passar sem ela:
(() => {
'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);
})();
A função pega uma tabela hash de propriedades não ordenadas (já que não faz sentido escrever propriedades em uma ordem específica em idiomas dinâmicos em 2016) e retorna uma tabela hash com essas propriedades, ou se você esqueceu de colocar a nova palavra-chave, ela retornará todo o contexto global (por exemplo, janela no navegador ou global no nodejs).
Perl não tem "isso" nem "novo" nem "classe", mas ainda pode ter uma função que se comporta de maneira semelhante. Não teremos construtor nem protótipo, mas poderemos criar novos animais à vontade e modificar suas propriedades individuais.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Agora, temos um problema: e se queremos que o animal faça os sons sozinhos, em vez de imprimirmos a voz deles. Ou seja, queremos uma função performSound que imprima o som do animal.
Uma maneira de fazer isso é ensinando cada animal individualmente como fazer o seu som. Isso significa que cada gato tem sua própria função duplicada para executar o som.
# 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'}();
})->();
Isso é ruim porque performSound é colocado como um objeto de função completamente novo toda vez que um animal é construído. 10000 animais significa 10000 performSounds. Queremos que uma única função performSound seja usada por todos os animais que procure seu próprio som e o imprima.
(() => {
'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
})();
Aqui é onde o paralelo ao Perl meio que para.
O novo operador do JavaScript não é opcional, sem ele, "this" dentro dos métodos de objeto corrompe o escopo 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 ter uma função para cada animal que procure o som do animal em vez de codificá-lo na construção.
Bênção nos permite usar um pacote como o protótipo de objetos. Dessa forma, o objeto está ciente do "pacote" ao qual é "referenciado" e, por sua vez, pode fazer com que as funções no pacote "alcancem" as instâncias específicas que foram criadas a partir do construtor desse "objeto de pacote":
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();
Resumo / TL; DR :
Perl não tem "isso", "classe", nem "novo". abençoar um objeto para um pacote fornece a ele uma referência ao pacote e, quando ele chama funções no pacote, seus argumentos serão deslocados em 1 slot, e o primeiro argumento ($ _ [0] ou shift) será equivalente a javascript é "isso". Por sua vez, você pode simular um pouco o modelo de protótipo do JavaScript.
Infelizmente, torna impossível (no meu entender) criar "novas classes" em tempo de execução, pois você precisa que cada "classe" tenha seu próprio pacote, enquanto que em javascript, você não precisa de pacotes, como palavra-chave "nova" cria um hashmap anônimo para você usar como um pacote em tempo de execução ao qual você pode adicionar novas funções e remover funções rapidamente.
Existem algumas bibliotecas Perl que criam suas próprias maneiras de superar essa limitação na expressividade, como o Moose.
Por que a confusão? :
Por causa dos pacotes. Nossa intuição nos diz para vincular o objeto a um hashmap contendo seu 'protótipo. Isso nos permite criar "pacotes" em tempo de execução, como o JavaScript pode. O Perl não tem essa flexibilidade (pelo menos não está embutido, é necessário inventá-lo ou obtê-lo de outros módulos) e, por sua vez, sua expressividade no tempo de execução é prejudicada. Chamar isso de "abençoar" também não ajuda muito.
O que queremos fazer :
Algo parecido com isto, mas tem ligação com o mapa do protótipo recursivo e está implicitamente vinculado ao protótipo, em vez de ter que fazê-lo explicitamente.
Aqui está uma tentativa ingênua: o problema é que "call" não sabe "o que chamou", portanto pode ser também uma função perl universal "objectInvokeMethod (objeto, método)" que verifica se o objeto possui o método , ou seu protótipo possui, ou seu protótipo, até que chegue ao fim e o encontre ou não (herança prototípica). Perl tem uma boa magia de avaliação para fazer isso, mas deixarei isso para algo que eu possa tentar fazer mais tarde.
Enfim, aqui está a idéia:
(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 qualquer forma, espero que alguém ache este post útil.