Herança não funciona

kumpera — Wed, 14 Nov 2007 02:18:39 +0000

Por um bom tempo achei que eu não tinha entendido sobre o assunto, mas já posso afirmar categoricamente: Herança não funciona. Existe hoje substância e argumentos suficientes para sustentar essa afirmação. Antes de discutir o mérito do assunto já adianto óbvio, programação orientada-a-objetos é sim um paradigma que funciona – apenas que um de seus elementos não funciona como se esperava. No fundo quem já programou em Java, C#, Ruby ou Smalltalk já sentiu que existe algo de estranho nessas linguagens, algo que não parece certo, e herança é o denominador comum desse sentimento.

O problema que vou tentar aqui descrever já foi estudado pelo Luca Cardelli, que é a questão da co-variância e contra-variância dos tipos – um problema que só existe na presença de herança. Originalmente foi descoberto quando ele tentou formular um cálculo para linguagens OO, algo análogo ao cálculo lambda para linguagens funcionais, e somente conseguiu progredir quando tentava reduzir para calculo lambda sem tipagem. Abandono aqui qualquer tentativa de equacionar a questão e explico a seguir através de exemplos. Vou comentar sobre a consistencia de sistemas de tipos, parametricidade de tipos e transparência de refêrencia.

A principal característica da herança é poder substituir um tipo mais abstrato por um mais especializado, poder trocar object por string, e não estar assim violando o sistema de tipos. Dada uma variável do tipo A, definimos operações de leitura e escrita. Para a leitura podemos dizer que o tipo retornado é A ou um super tipo de A; e para a escrita podemos dizer que o tipo aceito é A ou um sub tipo de A*. Exemplificando, se temos C

* Normalmente consideramos que A é super tipo e sub tipo de si próprio, logo leitura retorna um super tipo e escrita aceita um sub tipo.

Linguagens tipadas são assim e funcionam, então onde está o problema? O problema existe quando queremos ter referências para estas variáveis, C++ e C# são linguagens que suportam esse recurso. Vamos supor que referências a variaveis também funcionem com herança, isto é, uma referência à A pode ser substituída por uma à B. Vamos então examinar o pseudo-código abaixo:

C D

void foo (A &a) { a = new D(); }


A a;

B b;
A &ra = &a; //ra é uma referencia à variável 'a'

B &rb = &b; //ra é uma referencia à variável 'b'

foo (ra); // #1 foo (rb); // #2

Em #1, tudo ocorre corretamente pois a C é um sub tipo de A, condição exigida pela operação de escrita. Porém em #2, isso não ocorre, já que C não é sub tipo de B. Nesta situação temos uma clara falha no sistema de tipos e o comportamento durante a execução é imprevisível. Poderíamos inverter a direção da herança de referências, isto é, A& é um sub tipo de B& e desta forma resolveríamos o problema do exemplo anterior. Porém não sem introduzir semelhante situação quando tivermos leitura. Este é o exemplo mais simples para demonstrar o problema da co-variância da leitura e da contra-variância da escrita.

Tendo visto esta questão, entender o problema com tipo paramétricos e simples. A grosso modo, tipos paramétricos é o termo que a comunidade de linguagens funcionais usa para generics. Um tipo paramétrico não consegue carregar para si o relacionamento de herança que existe entre seus parâmetros pois, como vimos antes, não é possível estabelecer uma relação de herança para as variáveis parametrizadas do tipo - por isso que List não tem como ser um sub-tipo de List.

Uma solução parcial para é utilizar os wildcards do Java, que permite definir qual variância será utilizada. Solução similar é possível utilizando métodos genéricos em C# ou Java. Em ambos os caso, porém, não é possível definir código que ao mesmo tempo tem papel de escrita e leitura - além de criar assinaturas de métodos completamente assustadoras como as encontradas em java.util.Collections.

Por fim venho com a questão da consistencia do sistema de tipos, que deveria garantir que todas operações sobre tipos não deveriam falhar ou gerar estado inconsistente, salvo aquelas que testam explicitamente por um tipo como casts, is/as (C#) e instanceof (Java). Infelizmente não existe consistencia no sistema de tipos em linguagens como Java ou C#, que admitem herança entre arrays. Um atribuição a uma posição de um array pode falhar com ArrayStoreException/ArrayTypeMismatchException. Isso ocorre pois um array não é nada além que um vetor de referências e já sabemos que referências e herança não casam.

O mais curioso deste assunto é que não falo de um assunto que já não sabíamos, sinais claros existem vários: recomenda-se utilizar composição no lugar de estensão, frameworks baseados em herança são notoriamente mais difíceis de usar, a maioria dos sistemas hoje são modelados utilizando interfaces explicitas ou meta interfaces*. Quanto a solução, se ela se resume a apenas eliminarmos herança, não clamo por sabê-la. Digo, entretanto, que existem várias técnicas que compensam sua ausência e pretendo explorá-las em artigos futuros.

*Chamo aqui de meta interfaces aquelas que são frutos de conversão (JavaBeans) ou anotação (EJB3).

Update: apenas pequenas correções no texto.

Rodrigo Kumpera Weblog » funcional

Herança não funciona