Por que os protótipos de funções do Perl 5 são ruins?

Em outra pergunta do Stack Overflow, Leon Timmermans afirmou:

Aconselho você a não usar protótipos. Eles têm seus usos, mas não na maioria dos casos e definitivamente não neste.

Por que isso pode ser verdade (ou não)? Quase sempre forneço protótipos para minhas funções Perl, e nunca antes vi alguém dizer algo ruim sobre usá-los.

Protótipos não são ruins se usados ​​corretamente. A dificuldade é que os protótipos do Perl não funcionam da maneira que as pessoas costumam esperar. Pessoas com experiência em outras linguagens de programação tendem a esperar que os protótipos forneçam um mecanismo para verificar se as chamadas de função estão corretas: isto é, se têm o número e o tipo certo de argumentos. Os protótipos do Perl não são adequados para esta tarefa. É o mau uso que é ruim. Os protótipos do Perl têm um propósito único e muito diferente:

Os protótipos permitem definir funções que se comportam como funções integradas.

• Os parênteses são opcionais.
• O contexto é imposto aos argumentos.

Por exemplo, você pode definir uma função como esta:

sub mypush(\@@) { ... }

e chamá-lo de

mypush @array, 1, 2, 3;

sem precisar escrever o \para fazer uma referência ao array.

Em suma, os protótipos permitem que você crie seu próprio açúcar sintático. Por exemplo, a estrutura do Moose os usa para emular uma sintaxe OO mais típica.

Isso é muito útil, mas os protótipos são muito limitados:

• Eles precisam estar visíveis em tempo de compilação.
• Eles podem ser contornados.
• Propagar contexto para argumentos pode causar comportamento inesperado.
• Eles podem dificultar a chamada de funções usando algo diferente da forma estritamente prescrita.

Veja Protótipos em perlsub para todos os detalhes sangrentos.

O problema é que os protótipos de função do Perl não fazem o que as pessoas pensam que fazem. Seu propósito é permitir que você escreva funções que serão analisadas como as funções integradas do Perl.

Em primeiro lugar, as chamadas de método ignoram completamente os protótipos. Se você estiver fazendo programação OO, não importa o protótipo de seus métodos. (Portanto, eles não devem ter nenhum protótipo.)

Em segundo lugar, os protótipos não são estritamente impostos. Se você chamar uma sub-rotina com &function(...), o protótipo será ignorado. Portanto, eles não fornecem nenhum tipo de segurança.

Terceiro, eles são uma ação assustadora à distância. (Especialmente o $protótipo, que faz com que o parâmetro correspondente seja avaliado no contexto escalar, em vez do contexto de lista padrão.)

Em particular, eles dificultam a passagem de parâmetros de arrays. Por exemplo:

my @array = qw(a b c);

foo(@array);
foo(@array[0..1]);
foo($array[0], $array[1], $array[2]);

sub foo ($;$$) { print "@_\n" }

foo(@array);
foo(@array[0..1]);
foo($array[0], $array[1], $array[2]);

estampas:

a b c
a b
a b c
3
b
a b c

junto com 3 avisos sobre main::foo() called too early to check prototype(se os avisos estiverem habilitados). O problema é que uma matriz (ou fatia de matriz) avaliada no contexto escalar retorna o comprimento da matriz.

Se você precisar escrever uma função que atue como embutida, use um protótipo. Caso contrário, não use protótipos.

Nota: Perl 6 terá protótipos completamente renovados e muito úteis. Essa resposta se aplica apenas ao Perl 5.

Eu concordo com os dois cartazes acima. Em geral, o uso $deve ser evitado. Os protótipos são úteis apenas quando utilizando os argumentos de bloco ( &), (bolhas *) ou protótipos de referência ( \@, \$, \%, \*)

Algumas pessoas, olhando para um protótipo de sub-rotina Perl, pensam que significa algo que não significa:

sub some_sub ($$) { ... }

Para Perl, isso significa que o analisador espera dois argumentos. É a maneira do Perl permitir que você crie sub-rotinas que se comportam como integradas, todas as quais sabem o que esperar do código subsequente. Você pode ler sobre protótipos em perlsub

Sem ler a documentação, as pessoas adivinham que os protótipos se referem à verificação de argumento em tempo de execução ou algo semelhante que eles viram em outras linguagens. Como acontece com a maioria das coisas que as pessoas imaginam sobre o Perl, elas se revelam erradas.

No entanto, a partir do Perl v5.20, o Perl tem um recurso, experimental no momento em que escrevo isso, que oferece algo mais parecido com o que os usuários esperam e o quê. As assinaturas de sub-rotina do Perl executam contagem de argumento de tempo, atribuição de variável e configuração padrão:

use v5.20;
use feature qw(signatures);
no warnings qw(experimental::signatures);

animals( 'Buster', 'Nikki', 'Godzilla' );

sub animals ($cat, $dog, $lizard = 'Default reptile') { 
    say "The cat is $cat";
    say "The dog is $dog";
    say "The lizard is $lizard";
    }

Este é o recurso que você provavelmente deseja se estiver considerando protótipos.