Pt/Introdução

Haskell é uma linguagem de programação para computadores. Em particular, ela é uma linguagem polimórfica tipada, preguiçosa e puramente funcional, completamente difrente da maioria das outras linguagens. A linguagem foi batizada por Haskell Brooks Curry, que trabalha em expressões lógicas matemáticas em uma fundação para linguagens funcionais. Haskell é baseada em cálculo lambda, por isso o lambda é usado como logo.

Por quê usar Haskell?

Escrever grandes softwares é um trabalho difícil e dispendioso. Dar manutenção nesses sistemas é mais difícil e dispendioso ainda. Linguagens de programação funcional, como Haskell, podem torná-lo mais fácil e mais barato. Por exemplo, um novo usuário que escreve um pequeno banco de dados relacional em Haskell dirá:

Uau! Eu basicamente escrevi o programa sem testar nada em termos de transformação entre tipos. Eu escrevi o teste/código do exemplo e não teve quase nenhum erro da execução no código! O compilador/sistema é realmente realmente bons em impedi-lo de fazer erros de codificação! Nunca em minha vida tive um bloco do código tão grande executar corretamente na primeira tentativa. Estou realmente impressionado.

Mesmo se você não estiver em uma posição para usar Haskell em seus projetos de programação, aprender Haskell pode tornar-lhe um programador melhor em qualquer linguagem.

Eu aprendi Haskell há alguns anos atrás, programando anteriormente em Python e (muitos) outras linguagens. Recentemente, eu tenho usado o Python para um projeto (a escolha que está sendo determinada por critérios técnico e por não técnicos), e encontro em meu estilo de programação Python agora pesada influência (para o melhor, eu espero; -) por minha experiência em programação Haskell.

Graham Klyne

Haskell oferece a você:

• aumento substancial da produtividade do programador (Ericsson mediu um fator da melhoria entre 9 e 25% utilizando Erlang, uma língua de programação funcional similar a Haskell, em um conjunto de experimentos em software de telefonia).
• código menor, mais limpo e mais fácil de dar manutenção.
• menos erros e maior confiabilidade.
• menor "gap semântico" entre o programador e a linguagem.
• menor tempo de codificação.

Haskell é uma linguagem do largo-spectrum, apropriada para uma variedade das aplicações. É particularmente apropriado para os programas que necessitam ser altamente modificáveis e de fácil manutenção.

Muito do ciclo de vida do software é gasto em especificação , design , , manutenção , do projeto e não na programação . As linguagens funcionais são superb para as especificações da escrita que podem realmente ser executadas (e daqui testado e eliminado erros). Tal da especificação então é o primeiro protótipo do final programa.

Linguagens funcionais são soberbas para as especificações da escrita que podem realmente ser executadas (e assim testado e eliminado erros). Tal especificação então é o primeiro protótipo do programa final.

Programas funcionais são também relativamente fáceis de manter, porque o código é menor, mais claro, e o controle rigoroso de efeitos laterais elimina uma classe enorme de interações desnecessárias.

O que é programação funcional?

C, Java, Pascal, Ada, e assim por diante, são linguagens imperativas. São "imperativas" no sentido em que consistem em uma seqüencia de comandos, que são executados estritamente um após o outro. Haskell é uma linguagem funcional. Uma linguagem funcional é uma única expressão, que é executada avaliando essa expressão. Qualquer um que já usou uma planilha eletrônica, tem experiência em programação funcional. Em uma planilha, especificamos o valor de cada célula, em função dos valores de outras células. O foco está em "o quê" deve ser computado, e não "como" deve ser computado. Por exemplo:

• nós não especificamos a ordem em que as planilhas devem ser computadas, ao invés disso, nós temos garantia que a planilha será calculada em uma ordem que respeite suas dependências.
• nós não dizemos à planilha como alocar sua memória - melhor, esperamos apresentar-nos com um plano aparentemente infinito de células, e alocar na memória somente as células que estão realmente em uso.
• na maioria das vezes, avaliamos o valor das células por uma "expressão" (cujas partes podem ser avaliadas em qualquer ordem), melhor que por uma "seqüência de comandos" que compute seu valor.

Uma conseqüência interessante de não especificar a ordem do recálculo, é que a noção de atribuição não é muito útil. Apesar de tudo, se você não souber exatamente quando uma atribuição acontece, você não pode fazer muito uso dela! Isto contrasta fortemente com programas nas línguagens convencionais como C, que consistem essencialmente de uma seqüência especificada cuidadosamente de atribuições, ou de Java, em que a requisição do método é crucial ao funcionamento de um programa.

Este foco em alto nível "o quê" é melhor que o baixo nível "como" é a característica que distingue as linguagens de programação funcionais.

Outra linguagem conhecida que é quase funcional é a standard database query language (SQL). Uma consulta SQL é uma expressão envolvendo projeções, seleções, junções e assim por diante. A consulta diz que a relação deve ser computada sem dizer como ela deve ser computada. Certamente a query pode ser avaliada em qualquer ordem conveniente. Com freqüência, implementações SQL executam extensivamente consultas de otimização que (entre outras coisas), busca a melhor ordem para avaliar a expressão.

Quais as vantagens da programação funcional?

Planilhas e SQL são ambos linguagens razoavelmente especializadas. Linguagens de programação funcional seguem as mesmas idéias das linguagens de propósito geral. Para se ter uma idéia de como é uma linguagem de programação funcional, vamos olhar os seguintes programas quicksort. Ambos ordenam uma sequência de números em ordem ascendente usando um método padrão chamado "quicksort". O primeiro programa é escrito em Haskell e o segundo em C.

Considerando que o programa C descreve os todos os passos de como a máquina deve fazer para realizar a ordenação - a maior parte código lida com os detalhes de baixo nível da manipulação de dados - o programa Haskell codifica o algoritmo de ordenação em um nível muito mais alto, melhorando a velocidade e clareza do resultado.

Quicksort em Haskell

qsort []     = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

Quicksort em C

void qsort(int a[], int lo, int hi) {
{
  int h, l, p, t;

  if (lo < hi) {
    l = lo;
    h = hi;
    p = a[hi];

    do {
      while ((l < h) && (a[l] <= p)) 
          l = l+1;
      while ((h > l) && (a[h] >= p))
          h = h-1;
      if (l < h) {
          t = a[l];
          a[l] = a[h];
          a[h] = t;
      }
    } while (l < h);

    t = a[l];
    a[l] = a[hi];
    a[hi] = t;

    qsort( a, lo, l-1 );
    qsort( a, l+1, hi );
  }
}

Uma tradução semi-direta de C pode ser acessada aqui.

Vamos examinar alguns dos benefícios de Haskell e programaçao funcional. Um caso mais detalhado para programação funcional pode ser encontrado em

Why Functional Programming Matters por John Hughes, The Computer Journal, Vol. 32, No. 2, 1989, pp. 98 - 107. Also in: David A. Turner (ed.): Research Topics in Functional Programming, Addison-Wesley, 1990, pp. 17 - 42.

A slightly less formal essay inspired by the paper above can be found in Um ensaio pouco menos formal inspirado pelo paper acima pode ser encontrado em

Why Haskell Matters originally by Sebastian Sylvan

Tamanho reduzido

Programas funcionais tendem a ser muito mais concisos do que os seus homólogos imperativos. Quicksort é um caso extremo sim, mas em geral programas funcionais são muito mais curtos (por um fator de dois pra dez).

Fácil compreensão

Functional programs are often easier to understand. You should be able to understand the program without any previous knowledge of either Haskell or quicksort. The same certainly cannot be said of the C program. It takes quite a while to understand, and even when you do understand it, it is extremely easy to make a small slip and end up with an incorrect program. Here is a detailed explanation of the Haskell quicksort:

Programas funcionais são muitas vezes mais fáceis de entender. Você deve ser capaz de entender o programa sem qualquer conhecimento prévio de Haskell ou quicksort. O mesmo, não se pode dizer do programa C. Demora um pouco para entender, e mesmo quando você faz compreendê-lo, é extremamente fácil de fazer um pequeno deslize e acabar com um programa incorreto. Aqui está uma explicação detalhada do Haskell quicksort:

qsort []     = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

A primeira linha lê-se:

"Quando você classifica uma lista vazia ( [] ), o resultado é uma outra lista vazia".

A segunda linha diz: "Para ordenar uma lista cujo primeiro elemento é chamado x e o resto do que é chamado xs , classificar os elementos de xs , que são menos de x , classificar os elementos de xs , que são iguais ou superiores a x , e concatenar ( + + ) os resultados, com x </ tt> colada no meio. "