Estou dando uma olhada no F#, e uma das primeiras coisas que você percebe é a inferência de tipos. Que é muito legal. Vejam esse código:

let quadrado x = x * x

let somaDosQuadrados nums =
    let mutable total = 0
    for x in nums do
        total <- total + quadrado x
    total

Esse código apresenta uma função que faz o quadrado de um número, na primeira linha. Na terceira linha em diante há uma função que soma quadrados a partir de uma sequência de números.

Atenção: Em nenhum lugar há o tipo do número a ser somado ou elevado ao quadrado, ou que a lista de números, descrito. São inteiros? São doubles? São floats?

Respondendo então: São inteiros. Aqui a prova:

Recebe uma sequência de inteiros (seq<int>) e retorna um inteiro (-> int).

Eu executo isso na console interativa do F#, e ele me dá o resultado:

Inteiros mais uma vez.

Atenção: O F# não é uma linguagem dinâmica. Ele é fortemente tipado com static dispatch. Tudo isso é inferência de tipo.

Como ele sabe? Ele faz a inferência do tipo lendo a função ao contrário. Ele percebe que minha variável “total” é um inteiro, e portanto o retorno da função (dado na última linha, que só tem escrito “total”) só pode ser um inteiro. E para somar na variável total com o resultado da função quadrado, essa função deve retornar também um inteiro. E se ela retorna um inteiro, ela recebe um inteiro também (vejam que a função quadrado recebe x, e retorna x vezes x). E se x, dentro do meu “for”, é um inteiro, a variável nums só pode ser uma sequência de inteiros. Portanto, a função recebe uma sequência de inteiros e retorna um inteiro.

Uau!!!

Se eu mudar isso para:

let quadrado x = x * x

let somaDosQuadrados nums =
    let mutable total = 0.0
    for x in nums do
        total <- total + quadrado x
    total

(Só mudei a variável “total” de “0” para “0.0”.)

Tudo muda, e “x” passa a ser um double (chamado de float no F#), e nums uma lista de doubles (pulei algumas linhas para mostrar que mudei a variável total):

A função quadrado também passa a trabalhar com doubles:

Uma mudança na função somaDosQuadrados afetou a função quadrado. Uau de novo!

Está clara a influência desse tipo de construção sobre o C#, principalmente na construção de lambdas e do LINQ, não está? Bem legal que algo que tenha iniciado nas universidades, em algum momento foi parar no Microsoft Research, e foi incorporado ao C# mesmo antes do lançamento do F#, previsto só para o Visual Studio 2010 no fim deste ano, começo do ano que vem. Aliás, lambdas são consideradas o “lado funcional” do C#, e são um dos motivos que o C# é chamado de uma linguagem de múltiplos paradigmas.

Antes de terminar, eu só queria dizer que essa não é a maneira correta de fazer uma função com F#. Programar F# assim é como usar C# para fazer programação estruturada, sem OO, algo que devia dar cadeia. Esse programa, altamente imperativo, vai contra tudo o que o F# propõe, que é uma programação funcional, não imperativa. Mas isso fica para outro post.