Polimorfismo ad hoc

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar

Em linguagens de programação , o polimorfismo ad hoc [1] é um tipo de polimorfismo no qual funções polimórficas podem ser aplicadas a argumentos de diferentes tipos, pois uma função polimórfica pode denotar uma série de implementações distintas e potencialmente heterogêneas dependendo do tipo de argumento(s). ) a que se aplica. Quando aplicado a conceitos orientados a objetos ou procedimentais, também é conhecido como sobrecarga de função ou sobrecarga de operador . O termo ad hoc neste contexto não pretende ser pejorativo; refere-se simplesmente ao fato de que esse tipo de polimorfismo não é uma característica fundamental do sistema de tipos. Isso contrasta com o polimorfismo paramétrico , no qual funções polimórficas são escritas sem menção a nenhum tipo específico e, portanto, podem aplicar uma única implementação abstrata a qualquer número de tipos de maneira transparente. Esta classificação foi introduzida por Christopher Strachey em 1967.

Vinculação antecipada

O polimorfismo ad hoc é um mecanismo de despacho : o controle que se move através de uma função nomeada é despachado para várias outras funções sem ter que especificar a função exata que está sendo chamada. A sobrecarga permite que múltiplas funções de diferentes tipos sejam definidas com o mesmo nome; o compilador ou interpretador garante automaticamente que a função correta seja chamada. Dessa forma, funções anexando listas de inteiros , listas de strings , listas de números reais e assim por diante poderiam ser escritas, e todas seriam chamadas de append — e o anexo direitoA função seria chamada com base no tipo de lista que está sendo anexada. Isso difere do polimorfismo paramétrico, em que a função precisaria ser escrita genericamente , para trabalhar com qualquer tipo de lista. Usando sobrecarga, é possível que uma função execute duas coisas completamente diferentes com base no tipo de entrada passada para ela; isso não é possível com polimorfismo paramétrico. Outra maneira de ver a sobrecarga é que uma rotina é identificada exclusivamente não por seu nome, mas pela combinação de seu nome e o número, ordem e tipos de seus parâmetros.

Esse tipo de polimorfismo é comum em linguagens de programação orientadas a objetos , muitas das quais permitem que os operadores sejam sobrecarregados de maneira semelhante às funções (consulte sobrecarga de operadores ). Algumas linguagens que não são tipadas dinamicamente e não possuem polimorfismo ad hoc (incluindo classes de tipo) têm nomes de funções mais longos, como print_int, print_string, etc. Isso pode ser visto como uma vantagem (mais descritiva) ou uma desvantagem (excessivamente detalhado) dependendo do ponto de vista .

Uma vantagem que às vezes é obtida com a sobrecarga é a aparência de especialização, por exemplo, uma função com o mesmo nome pode ser implementada de várias maneiras diferentes, cada uma otimizada para os tipos de dados específicos em que opera. Isso pode fornecer uma interface conveniente para código que precisa ser especializado em várias situações por motivos de desempenho. A desvantagem é que o sistema de tipos não pode garantir a consistência das diferentes implementações.

Como a sobrecarga é feita em tempo de compilação, ela não é um substituto para a ligação tardia, conforme encontrado no polimorfismo de subtipagem .

Encadernação tardia

Apesar da seção anterior, existem outras maneiras pelas quais o polimorfismo ad hoc pode funcionar. Considere, por exemplo, a linguagem Smalltalk. Em Smalltalk , a sobrecarga é feita em tempo de execução, pois os métodos ("implementação da função") para cada mensagem sobrecarregada ("função sobrecarregada") são resolvidos quando estão prestes a serem executados. Isso acontece em tempo de execução, depois que o programa é compilado. Portanto, o polimorfismo é dado por polimorfismo de subtipagem como em outras linguagens, e também é estendido em funcionalidade por polimorfismo ad hoc em tempo de execução.

Um olhar mais atento também revelará que Smalltalk fornece uma variedade ligeiramente diferente de polimorfismo ad hoc . Uma vez que Smalltalk tem um modelo de execução de ligação tardia, e uma vez que fornece aos objetos a capacidade de manipular mensagens que não são compreendidas, é possível implementar a funcionalidade usando polimorfismo sem sobrecarregar explicitamente uma mensagem específica. Isso pode não ser uma prática geralmente recomendada para programação diária, mas pode ser bastante útil ao implementar proxies.

Além disso, embora em termos gerais o método de classe comum e a sobrecarga de construtor não sejam considerados polimorfismo, existem linguagens mais uniformes nas quais as classes são objetos regulares. Em Smalltalk, por exemplo, classes são objetos regulares. Por sua vez, isso significa que as mensagens enviadas às classes podem ser sobrecarregadas, e também é possível criar objetos que se comportam como classes sem que suas classes herdem da hierarquia de classes. Estas são técnicas eficazes que podem ser usadas para tirar vantagem dos poderosos recursos de reflexão do Smalltalk . Arranjos semelhantes também são possíveis em idiomas como Self e Newspeak .

Exemplo

Imagine um operador +que pode ser usado das seguintes maneiras:

  1. 1 + 2 = 3
  2. 3.14 + 0.0015 = 3.1415
  3. 1 + 3.7 = 4.7
  4. [1, 2, 3] + [4, 5, 6] = [1, 2, 3, 4, 5, 6]
  5. [true, false] + [false, true] = [true, false, false, true]
  6. "bab" + "oon" = "baboon"

Para lidar com essas seis chamadas de função, quatro partes diferentes de código são necessárias (ou três, se as strings forem consideradas listas de caracteres):

Assim, o nome +na verdade se refere a três ou quatro funções completamente diferentes. Este é um exemplo de sobrecarga ou, mais especificamente, sobrecarga de operador .

Observe a ambiguidade nos tipos de string usados ​​no último caso. Considere "123" + "456"em que o programador pode naturalmente assumir adição em vez de concatenação. Eles podem esperar "579"em vez de "123456". A sobrecarga pode, portanto, fornecer diferentes significados, ou semânticas, para uma operação, bem como diferentes implementações.

Veja também

Referências

  1. ^ C. Strachey, conceitos fundamentais em linguagens de programação . Notas de aula para a Escola Internacional de Verão em Programação de Computadores, Copenhague, agosto de 1967