Por que a inferência de tipo é útil?

Eu leio código com mais freqüência do que escrevo código e estou assumindo que a maioria dos programadores que trabalham em software industrial faz isso. A vantagem da inferência de tipo que assumo é menos verbosidade e menos código escrito. Mas, por outro lado, se você ler código com mais frequência, provavelmente desejará código legível.

O compilador infere o tipo; existem algoritmos antigos para isso. Mas a verdadeira questão é por que eu, o programador, gostaria de inferir o tipo de minhas variáveis ​​quando leio o código? Não é mais rápido alguém ler o tipo do que pensar que tipo existe?

Edit: Como conclusão, eu entendo por que é útil. Mas na categoria de recursos de linguagem, eu o vejo em um balde com sobrecarga de operador - útil em alguns casos, mas afetando a legibilidade se for abusada.

Vamos dar uma olhada no Java. Java não pode ter variáveis ​​com tipos inferidos. Isso significa que frequentemente tenho que especificar o tipo, mesmo que seja perfeitamente óbvio para um leitor humano qual é o tipo:

int x = 42;  // yes I see it's an int, because it's a bloody integer literal!

// Why the hell do I have to spell the name twice?
SomeObjectFactory<OtherObject> obj = new SomeObjectFactory<>();

E, às vezes, é simplesmente irritante soletrar todo o tipo.

// this code walks through all entries in an "(int, int) -> SomeObject" table
// represented as two nested maps
// Why are there more types than actual code?
for (Map.Entry<Integer, Map<Integer, SomeObject<SomeObject, T>>> row : table.entrySet()) {
    Integer rowKey = entry.getKey();
    Map<Integer, SomeObject<SomeObject, T>> rowValue = entry.getValue();
    for (Map.Entry<Integer, SomeObject<SomeObject, T>> col : rowValue.entrySet()) {
        Integer colKey = col.getKey();
        SomeObject<SomeObject, T> colValue = col.getValue();
        doSomethingWith<SomeObject<SomeObject, T>>(rowKey, colKey, colValue);
    }
}

Essa digitação estática detalhada fica no meu caminho, o programador. A maioria das anotações de tipo são repetições repetitivas e sem conteúdo do que já sabemos. No entanto, eu gosto da digitação estática, pois ela pode realmente ajudar na descoberta de bugs, portanto, a digitação dinâmica nem sempre é uma boa resposta. A inferência de tipo é o melhor dos dois mundos: posso omitir os tipos irrelevantes, mas ainda assim, certifique-se de que meu programa (tipo-) faça check-out.

Embora a inferência de tipo seja realmente útil para variáveis ​​locais, ela não deve ser usada para APIs públicas que precisam ser documentadas sem ambiguidade. E, às vezes, os tipos são realmente críticos para entender o que está acontecendo no código. Nesses casos, seria tolice confiar apenas na inferência de tipo.

Existem muitos idiomas que suportam inferência de tipo. Por exemplo:

• C ++. A autopalavra-chave aciona a inferência de tipo. Sem ele, escrever os tipos de lambdas ou entradas em contêineres seria um inferno.

• C #. Você pode declarar variáveis ​​com var, o que aciona uma forma limitada de inferência de tipo. Ele ainda gerencia a maioria dos casos em que você deseja inferência de tipo. Em certos lugares, você pode deixar de fora o tipo completamente (por exemplo, em lambdas).

• Haskell e qualquer idioma da família ML. Embora o sabor específico da inferência de tipo usado aqui seja bastante poderoso, você ainda vê anotações de tipo para funções e por dois motivos: O primeiro é a documentação e o segundo é uma verificação de que a inferência de tipo realmente encontrou os tipos que você esperava. Se houver uma discrepância, provavelmente haverá algum tipo de bug.

É verdade que o código é lido com muito mais frequência do que está escrito. No entanto, a leitura também leva tempo, e duas telas de código são mais difíceis de navegar e ler do que uma tela de código; portanto, precisamos priorizar para compactar a melhor proporção de informações úteis / esforço de leitura. Este é um princípio geral de UX: Muita informação sobrecarrega e degrada a eficácia da interface.

E é minha experiência que , muitas vezes , o tipo exato não é (isso) importante. Certamente você às vezes expressões ninho: x + y * z, monkey.eat(bananas.get(i)), factory.makeCar().drive(). Cada uma delas contém subexpressões avaliadas para um valor cujo tipo não está gravado. No entanto, eles são perfeitamente claros. Estamos bem em deixar o tipo não declarado, porque é fácil descobrir o contexto e escrevê-lo faria mais mal do que bem (confundir a compreensão do fluxo de dados, ocupar tela valiosa e espaço de memória de curto prazo).

Uma razão para não aninhar expressões como se não houvesse amanhã é que as linhas ficam longas e o fluxo de valores se torna incerto. A introdução de uma variável temporária ajuda nisso, impõe uma ordem e atribui um nome a um resultado parcial. No entanto, nem tudo o que se beneficia com esses aspectos também se beneficia de ter seu tipo explicitado:

user = db.get_poster(request.post['answer'])
name = db.get_display_name(user)

Importa se useré um objeto de entidade, um número inteiro, uma string ou outra coisa? Para a maioria dos propósitos, não basta, basta saber que representa um usuário, vem da solicitação HTTP e é usado para buscar o nome a ser exibido no canto inferior direito da resposta.

E quando se faz a matéria, o autor é livre para escrever o tipo. Essa é uma liberdade que deve ser usada com responsabilidade, mas o mesmo vale para tudo o que pode melhorar a legibilidade (nomes de variáveis ​​e funções, formatação, design da API, espaço em branco). E, de fato, a convenção em Haskell e ML (onde tudo pode ser inferido sem esforço extra) é escrever os tipos de funções de funções não locais e também de variáveis ​​e funções locais sempre que apropriado. Somente iniciantes permitem inferir todo tipo.

Eu acho que a inferência de tipo é muito importante e deve ser suportada em qualquer linguagem moderna. Todos nós desenvolvemos IDEs e eles podem ajudar muito, caso você queira saber o tipo inferido, apenas alguns de nós invadimos vi. Pense em verbosidade e código de cerimônia em Java, por exemplo.

  Map<String,HashMap<String,String>> map = getMap();

Mas você pode dizer que está tudo bem, meu IDE vai me ajudar, pode ser um ponto válido. No entanto, alguns recursos não estariam lá sem a ajuda da inferência de tipo, tipos anônimos C #, por exemplo.

 var person = new {Name="John Smith", Age = 105};

O Linq não seria tão bom como é agora sem a ajuda da inferência de tipo, Selectpor exemplo

  var result = list.Select(c=> new {Name = c.Name.ToUpper(), Age = c.DOB - CurrentDate});

Esse tipo anônimo será inferido ordenadamente na variável.

Não gosto de inferência de tipo em tipos de retorno, Scalaporque acho que seu ponto se aplica aqui; deve ficar claro para nós o que uma função retorna para que possamos usar a API com mais fluência

Eu acho que a resposta para isso é realmente simples: economiza a leitura e a gravação de informações redundantes. Especialmente nas linguagens orientadas a objetos, nas quais você tem um tipo nos dois lados do sinal de igual.

O que também informa quando você deve ou não usá-lo - quando as informações não são redundantes.

Suponha que alguém veja o código:

someBigLongGenericType variableName = someBigLongGenericType.someFactoryMethod();

Se someBigLongGenericTypeé atribuível a partir do tipo de retorno someFactoryMethod, qual a probabilidade de alguém ler o código perceber se os tipos não correspondem exatamente e com que facilidade alguém que notou a discrepância pode reconhecer se foi intencional ou não?

Ao permitir a inferência, um idioma pode sugerir a alguém que está lendo o código que, quando o tipo de uma variável é declarado explicitamente, a pessoa deve tentar encontrar um motivo para isso. Isso, por sua vez, permite que as pessoas que estão lendo o código concentrem melhor seus esforços. Se, por outro lado, na grande maioria das vezes em que um tipo é especificado, ele é exatamente o mesmo que seria inferido, alguém que está lendo um código pode ser menos propenso a perceber os momentos em que é sutilmente diferente .

Vejo que já existem várias respostas excelentes. Algumas das quais repetirei, mas às vezes você só quer colocar as coisas com suas próprias palavras. Vou comentar com alguns exemplos do C ++, porque essa é a linguagem com a qual tenho mais familiaridade.

O que é necessário nunca é imprudente. A inferência de tipo é necessária para tornar outros recursos de linguagem práticos. Em C ++, é possível ter tipos indizíveis.

struct {
    double x, y;
} p0 = { 0.0, 0.0 };
// there is no name for the type of p0
auto p1 = p0;

O C ++ 11 adicionou lambdas que também são indizíveis.

auto sq = [](int x) {
    return x * x;
};
// there is no name for the type of sq

A inferência de tipo também sustenta modelos.

template <class x_t>
auto sq(x_t const& x)
{
    return x * x;
}
// x_t is not known until it is inferred from an expression
sq(2); // x_t is int
sq(2.0); // x_t is double

Mas suas perguntas foram "por que eu, o programador, gostaria de inferir o tipo de minhas variáveis ​​quando leio o código? Não é mais rápido para alguém apenas ler o tipo do que pensar que tipo existe?"

A inferência de tipo remove a redundância. Quando se trata de ler código, às vezes pode ser mais rápido e fácil ter informações redundantes no código, mas a redundância pode ofuscar as informações úteis . Por exemplo:

std::vector<int> v;
std::vector<int>::iterator i = v.begin();

Não é preciso muita familiaridade com a biblioteca padrão para um programador de C ++ identificar que eu sou um iterador, i = v.begin()portanto a declaração de tipo explícita é de valor limitado. Por sua presença, oculta os detalhes mais importantes (como os que iapontam para o início do vetor). A boa resposta de @amon fornece um exemplo ainda melhor de verbosidade que oculta detalhes importantes. Em contraste, o uso de inferência de tipo dá maior destaque aos detalhes importantes.

std::vector<int> v;
auto i = v.begin();

Embora a leitura do código seja importante, não é suficiente, em algum momento você precisará parar de ler e começar a escrever um novo código. A redundância no código torna a modificação do código mais lenta e mais difícil. Por exemplo, digamos que tenho o seguinte fragmento de código:

std::vector<int> v;
std::vector<int>::iterator i = v.begin();

No caso em que eu preciso alterar o tipo de valor do vetor para alterar o código para:

std::vector<double> v;
std::vector<double>::iterator i = v.begin();

Nesse caso, tenho que modificar o código em dois lugares. Contraste com a inferência de tipo, onde o código original é:

std::vector<int> v;
auto i = v.begin();

E o código modificado:

std::vector<double> v;
auto i = v.begin();

Note que agora só preciso alterar uma linha de código. Extrapole isso para um programa grande e a inferência de tipo pode propagar as alterações para os tipos muito mais rapidamente do que com um editor.

A redundância no código cria a possibilidade de erros. Sempre que seu código depende de duas informações mantidas equivalentes, existe a possibilidade de erro. Por exemplo, há uma inconsistência entre os dois tipos nesta declaração que provavelmente não se destina:

int pi = 3.14159;

A redundância torna a intenção mais difícil de discernir. Em alguns casos, a inferência de tipo pode ser mais fácil de ler e entender, porque é mais simples que a especificação de tipo explícita. Considere o fragmento de código:

int y = sq(x);

No caso que sq(x)retorna um int, não é óbvio se yé um intporque é o tipo de retorno sq(x)ou porque é adequado às instruções que são usadas y. Se eu alterar outro código para que sq(x)não retorne mais int, é incerto a partir dessa linha apenas se o tipo de ydeve ser atualizado. Contraste com o mesmo código, mas usando inferência de tipo:

auto y = sq(x);

Neste, a intenção é clara, ydeve ser do mesmo tipo retornada por sq(x). Quando o código altera o tipo de retorno sq(x), o tipo de yalteração é correspondido automaticamente.

Em C ++, existe uma segunda razão pela qual o exemplo acima é mais simples com inferência de tipo, a inferência de tipo não pode introduzir conversão implícita de tipo. Se o tipo de retorno de sq(x)não for int, o compilador insere silenciosamente uma conversão implícita em int. Se o tipo de retorno de sq(x)é um tipo complexo de tipo que define operator int(), essa chamada de função oculta pode ser arbitrariamente complexa.