Haskell: Tipos Compostos com Tuplas

E aí galera, tudo tranquilo?
Depois de um dia de praia e muito calor, decidi escrever rs.

De acordo com o meu último post a respeito de Haskell, falei sobre Tuplas. Será importante saber a respeito para dar continuidade.

Hoje tirei a noite pra falar a respeito dos Tipos Compostos e darei alguns exemplos usando Tuplas.

type
No Haskell quando usamos a função type criamos novos Tipos. Semelhante ao typedef do C.

É algo bem básico de entender. Imagine que você precisa definir um "novo" tipo, ou seja, quer definir um novo nome para um determinado tipo de dado:
type Numero = Float
raiz :: Numero -> Numero
raiz a = sqrt(a)

Na primeira linha, nós definimos o tipo e o nomeamos. Já na segunda linha definimos os parâmetros de entrada e saída da função raiz. No fim, tiramos a raiz. Nessa função, o type Numero equivale ao Float do Haskell.

Pô, e onde isso é útil?
Bom, durante meu processo de aprendizado em Haskell, pude ver que o type unido a Tupla fica muito mais interessante. Vamos ver?

Criemos a situação onde preciso de uma "objeto"(type) com seu "atributos". Como podemos definir um cachorro?
Nome
Raça
Idade
Peso

Acredito serem atributos válidos. Vamos usar o Haskell:
-- Define os nomes dos atributos do cachorro
-- String = [Char], ou seja um array de Char
type Nome = String
type Raca = String
type Idade = Int
type Peso = Float

-- Define Cachorro com seus respectivos atributos
type Cachorro = (Nome, Raca, Idade, Peso)

-- Criando um cachorro, um não dois
c_duda, c_pingo :: Cachorro
c_duda = ("Duda", "Teckel", 12, 2.5)
c_pingo = ("Pingo", "Poodle", 1, 4.1)

Com isso nós podemos trabalhar com "objetos" no Haskell.
Vamos ao exemplo prático. Crie um arquivo, types.hs, para começar digite em seu interior o conteúdo lido acima (Types até a criação do Cachorro), depois adicione o conteúdo abaixo:
-- Funções para retorno dos atributos
-- A função get_nome, recebe um Cachorro e devolve o seu nome
get_nome :: Cachorro -> Nome
get_raca :: Cachorro -> Raca
get_idade :: Cachorro -> Idade
get_peso :: Cachorro -> Peso

-- n = nome, r = raça, i = idade, p = peso
get_nome (n, r, i, p) = n
get_raca (n, r, i, p) = r
get_idade (n, r, i, p) = i
get_peso (n, r, i, p) = p

Bom, agora é só testar! Salve seu arquivo e vamos ao terminal e ao diretório do seu arquivo:
hugs types.hs

Main> c_duda
c_duda = ("Duda", "Teckel", 12, 2.5)

Main> get_nome c_duda
"Duda"

Main> get_idade c_pingo
1

E teste o que mais você quiser! Muito louco né?

E da pra fazer uma coisa mais legal ainda:
Main> get_nome ("Teka", "Basset", 3, 3.1)
"Teka"

Mas como assim? Nós criamos* um Cachorro e retornamos seu Nome.
*Entenda que no Haskell só trabalhamos com funções.
Não se esqueça do o Cachorro recebe uma tupla-4. Caso se esqueça desse pequeno detalhe, verá algo assim:

Bom galera, por hoje é só! O arquivo do exercício acima esta no meu GitHub. Só reforçando uma dica anterior , que tal aprender a usar um editor top?
Vim
Emacs

Qualquer dúvida, comente abaixo ou email-me: abner.terribili@gmail.com.

Valeu!

Node.js : Apresentando Node.js

Boa noite pessoal.

Hoje estou meio inspirado e acho que esse post vai ficar grande! 

O assunto é bem legal, muitos já ouviram falar e talvez poucos se atrevem a testar, mas hoje é o dia.

O que é Node.js?

É um interpretador JavaScript, escrito em C++, do lado do servidor e sim é Open Source. 

JavaScript no servidor? Algo inimaginável há um tempo atrás. O Node veio com uma proposta interessante. Ele possibilita que criemos aplicativos altamente escaláveis e que mantém milhares de conexões simultâneas. Ou seja, ao contrário do Java e algumas outras linguagens, que reservam um determinado espaço de memória(aprox. 2bm) e processamento para manter as conexões simultâneas, o Node.js cria novas instancias da aplicação, para lidar com a demanda, assim o servidor não tem que monitorar e nem requisitar mais recursos. 

Se houver grande interesse de conhecimento, pode ler algo no developerWorks da IBM:

http://www.ibm.com/developerworks/br/library/os-nodejs/#toggle

E a trilha Node.js do Giovanni Bassi:

http://blog.lambda3.com.br/2013/08/node-node-node/

Tenha certeza que se você ler os links acima, não estará perdendo tempo :).

Vamos a parte prática?

A instalação do Node.js é bem simples, entrar no site e baixar:

http://www.nodejs.org/#download

Para os amantes do Terminal, nos nomes existem links com tutoriais mais profundos:

Mac, com o HomeBrew: 

brew install node

Linux:

(Tem que instalar Python também)

sudo apt-get update

sudo apt-get install -y python-software-properties python g++ make

sudo add-apt-repository ppa:chris-lea/node.js

sudo apt-get update

sudo apt-get install nodejs

Windows:

http://dailyjs.com/2012/05/03/windows-and-node-1/

Feito isso, só testar com o famoso version:

node --version

v0.10.25

E tudo certo. 

Vamos fazer o clássico Hello World?

Faremos toda tarefa usando JavaScript e um pouquinho, quase nada, de HTML.

Em seu diretório favorito, crie um arquivo chamado helloworld.js e em seu interior digite e entenda:

// Carrega a biblioteca HTTP do Node.js

var http = require('http');

// Cria um serviço web para tratar a requisição de resposta da mensagem Hello World.

var server = http.createServer(function (request, response) {

  // Define os parâmetros de cabeçalho de resposta.

  response.writeHead(200, {'Content-Type': 'text/html'});

  // Escreve uma mensagem de resposta do servidor.

  response.write('<html><body><h1>Hello World!</h1></body></html>');

  // Envia uma resposta para o cliente

  response.end();

});

// Define a porta e IP que será executado a aplicação.

server.listen(3000);

// Imprime mensagem no terminal do servidor.

console.log('Servidor Node.js em execucao');

Para testar é fácil, vá até seu terminal, caminhe até o diretório do arquivo helloworld.js e digite:

node helloworld.js

Servidor Node.js em execucao

Agora é só abrir seu navegador favorito e inserir a url:

localhost:3000

Vai ver o resultado escrito em HTML!

Quem estiver com pique, continue. Vamos tentar algo um pouco mais legal.

Imagine que você precisa requisitar ao seu servidor a soma de dois números. Se você não viu, faça esse exercício em Haskell também.

Mas vamos lá, JavaScript e tal...

Em seu diretório favorito, crie um novo arquivo chamado soma.js e em seu interior digite:

var http = require("http");

var url = require("url");

http.createServer(function(request, response) {

  response.writeHead(200, {"Content-Type": "text/plain"});

  // Pegando os parâmetros passados via URL

  var params = url.parse(request.url, true).query;

  var x = params.numberX;

  var y = params.numberY;

  var inputX = new Number(x);

  var inputY = new Number(y);

  soma = new Number(inputX + inputY);

  response.write(soma.toString());

  response.end();

}).listen(3000);

console.log("Somando dois números");

E como executar?

node soma.js

Mas ao abrir seu navegador, não estará vendo resultado algum(NaN)... Por que?

Porque não passamos nenhum parâmetro via url.
Tente de novo assim:

localhost:3000/?numberX=3&numberY=4

Entenda...

?	Indica passagem de parâmetros
numberX	Primeiro parâmetro
&	Indica passagem de mais de um parâmetro
numberY	Segundo parâmetro

Verá algo muito mais legal:

7

O servidor Node.js, se emcumbiu de fazer a soma e printar na tela o resultado. "Fácil" não? 

Para fixar, vou deixar um exercício básico:

Faça uma aplicação Node.js que gera um número aleatório, no intervalo de 0 - o número passado via parâmetro.

Dica: (Math.random() * seu_numero).toFixed(0);

Assim você gera um número pseudo-randômico em JS.

A resposta está no meu GitHub. Qualquer dúvida, email-me: abner.terribili@gmail.com ou comente abaixo.

Valeu galera!

Haskell: Apresentando Tuplas

E aí galera, hoje o assunto é bem interessante. Vou mostrar um pouco a respeito das Tuplas.

("Abner Terribili", 22, 72.4, "Verde")
Algo como Nome, Idade, Peso e Cor favorita. Imagine essa tupla como um objeto e seus respectivos atributos, do Java.

Esse exemplo acima é conhecido como Tupla. (Definição boa do Wikipédia, não deixe de ler)

Em Haskell podemos criar funções que manipulam um conjunto de dados. Esse conjunto, heterogênio de dados, tem como objetivo representar uma relação entre seus dados, de forma que a captura do mesmo seja atravês da posição, tal como um Array.

O número de objetos dentro da tupla, define o tamanho da tupla. Ou seja, caso avaliemos a tupla acima, teremos uma tupla-4, veja: 

("Abner Terribili", 22, 72.4, "Verde")

Caso nossa tupla possua somente:

("Abner Terribili", 22);

Teremos uma tupla-2. Podendo chegar até a tupla-n, dependendo somente da quantidade de elementos em seu interior.

Como no Haskell não somos "obrigados" a definir os tipos dos dados, o interpretador reconhece de forma automática, ele reconhecerá os respectivos elementos da seguinte maneira:

Abner Terribili	String
22	Int
72.4	Float
Verde	String

Lembrando que uma String é uma lista. (Sequência de caracteres)

A principal aplicação das tuplas é definir uma função que receba ou retorne mais de um valor e, geralmente, do tipo heterogênio. Apesar das suas vantagens, a tupla tem uma estrutura estática, ou seja, uma vez criada, não pode ser modificada. (Definição Livro: Haskell Uma abordagem prática)

Por padrão as tuplas-2, no Haskell, têm algumas duas pré-definidas, sendo elas:

fst; 
snd;

fst (first) = tem como função retornar o primeiro elemento da tupla-2.

snd (second) = tem como função retornar o segundo elemento da tupla-2.

Vamos testar? Vá até o seu terminal e entre no interpretador Hugs, digitando apenas:

$ hugs

Logo verá o Terminal Hugs, você pode testar vendo o retorno da função:

Main> fst (1, 2)

1

A função fst retornou o primeiro elemento da tupla-2 (1, 2). Agora teste o snd também. Gostou?

Imagine que você tem que calcular a multiplicação e soma de dois números (x, y).  Normalmente faríamos duas funções:

multiplicacao Int -> Int -> Int
multiplicacao x y = x * y

soma Int -> Int -> Int
soma x y = x + y

Pô, acho que uma tupla resolve e economiza na escrita, olha lá:

-- Na definição dos parâmetros, escrevemos que a função vai receber uma tupla-2 e devolverá outra tupla-2

multiplicacao_soma :: (Int, Int) -> (Int, Int)

multiplicacao_soma (x, y) = (x * y, x + y)

E aí, foi mais simples? Na minha opinião, sim!
Com apenas uma função resolvemos um problema "composto".

Teste o exercício acima, vai gostar do resultado, mas não se esqueça da passagem de uma tupla como parâmetro. Exemplos: (1, 2), (99, 27).

Se estiver com tempo, reescreva as funções "fst" e "snd". A resposta está no GitHub.

A dica para esse exercício é usar o "_" (Underscore), como variável anônima, imagine-o como um coringa, você não precisa definir o tipo da variável que não terá utilidade para você. Ou seja, o argumento "_" tem seu conteúdo desconsiderado pelo interpretador.

Esse post ficará por aqui, mas já estou preparando o próximo pra falar um pouco de "Tipos compostos com Tuplas".

E minha dica de hoje é um app, ou uma Android Activity, escrita em Haskell (!!!) , legal não? 

https://github.com/neurocyte/android-haskell-activity

Qualquer coisa, email-me: abner.terribili@gmail.com ou comente abaixo.

Cheers!

Ruby: Hello World!

E aí galera, hoje vou escrever sobre outra linguagem, que segundo alguns especialistas também tem algo funcional, não sei se é verdade, mas logo logo descubro e deixo aqui pra vocês :).

RUBY!

O Ruby foi lançado em 1995 por Yukihiro Matsumoto (também conhecido como Matz).
O objetivo de Matz ao fundamentar as bases do Ruby, foi pensar em algo expressivo, para assim ser simples de ler e ser compreendida. Com esses pensamentos, Matz criou uma linguagem orientada a objetos, com tipagem forte e dinâmica.

E fala sério, olha essa expressividade:

Vou deixar um material legal para vocês poderem ler a respeito :). A apostila aberta da Caelum vem ajudando muito no meu treinamento, se quiser dê uma olhadinha aqui. No site deles, Ruby, também existem alguns tutoriais bacanas.

Deixarei dois exemplos mais básicos, para você que ainda não configurou seu ambiente, vamos lá.

O site do Ruby, explica detalhadamente como configurar o seu ambiente. Então não vou estender muito essa parte, porque é "desnecessário".

Mas basicamente é isso:

Linux:

apt-get install ruby irb rdoc

Mac, com gerenciador Homebrew:

brew install ruby

Windows:
https://www.ruby-lang.org/pt/downloads/

Depois de instalado, podemos testar se ocorreu tudo certo assim, abra seu terminal e digite:

ruby --version

Verá algo como:

ruby 2.0.0p247 (2013-06-27 revision 41674) [universal.x86_64-darwin13]

E pronto! Podemos brincar.

Vamos ao Hello World descolado. Crie um arquivo em seu diretório favorito, com o nome de hello_world.rb. A extensão .rb significa Ruby, e é a extensão usada para o interpretador Ruby reconhecer como arquivo Ruby.

Abra seu arquivo com editor seu editor e digite em seu interior:

# Assim fazemos comentário de uma linha no Ruby

puts "Digite seu nome: "

nome = gets

puts "Hello #{nome.capitalize}!"

O que aconteceu aí em cima, é o seguinte:

puts = imprime conteúdo e pula uma linha.

nome = variável que recebe a string digitada pelo usuário, através de:

gets = um método que permite atribuir um valor do tipo string a uma variável.

#{sua_variavel} = Faz a interpolação da sua String com a variável inserida.

.capitalize = Deixa a primeira letra da sua cadeira de caracteres maiúscula.

Como você pode ver, não precisamos declarar o tipo da variável, e isso não quer dizer que Ruby é fracamente tipada, muito pelo contrário, seu interpretador reconhece e faz o trabalho por você. Mas lembre-se que ruby também é dinamicamente tipada, ou seja, pode ser trocado o valor da variável em tempo de execução. Mais para frente, dou alguns exemplos e melhores explicações.

Vamos exercitar na segunda função:
Podemos fazer esse hello_world ser mais moderno, como?

puts "Digite seu nome: "

nome = gets

def hello_world(nome)

 return "Hello , #{nome.capitalize)

end



puts hello_world(nome)

Agora só testar no seu terminal, digitando:

ruby hello_world.rb

E anime-se com o resultado! rs

Esse foi o primeiro post sobre Ruby e quero escrever muito mais. Qualquer dúvida comente abaixo, ou mande email: abner.terribili@gmail.com. Eu curto muito feedback. O exemplo está no GitHub.

Cheers!

Haskell: Recursividade

Fala aí galera, hoje peguei firme no estudo e estou escrevendo esse post com o Vim! :D

Vou falar mais um pouco de Haskell e o assunto hoje é Recursividade.

A recursividade é a definição de uma subrotina (função ou método) que pode invocar a si mesma (Definição Recursividade). A Matéria sobre Recursividade da Wikipédia está impecável, não deixe de ler.

Onde isso é útil?
Imagine, você precisa calcular a soma dos n primeiros números. Ou seja, precisa escrever uma função que receberá como parâmetro um número n, você terá que somar esse número n a todos os seus antecessores, para que não seja feito através da iteração, podemos usar a recursão.

E a idéia é simples, vamos as definições:
soma (n) = { 1                         : n = 1
                  { soma (n - 1) + 1 : n > 1

soma 10 = 1+2+3+4+5+6+7+8+9+10 = 55

Poxa, mas como minha função sabe onde deve parar?
Devemos definir um aterramento, ou seja, um ponto onde a função deva parar.(Uma Guarda!)

De acordo com a definição matemática de indução, registrada acima, para n = 1, temos como resultado o número 1, para n > 1, nós invocamos novamente a função soma.

Vamos codar, para isso crie um novo arquivo em seu diretório favorito, de o nome de soma_recursividade.hs e digite em seu interior:

soma Int -> Int
soma 1 = 1
soma n = soma (n-1) + n

Ou seja, caso nosso n = 1, a função soma 1, entra em ação e retorna 1. Caso n > 1, a função soma(n), entra em ação, fazendo uso de si mesma para executar a tarefa de soma, isso se chama recursividade.

Podemos compreender o que o Hugs faz, interpretando essa função como escadaria da recursividade, quer ver?

soma 5
= (soma 4) + 5
= ((soma 3) + 4) + 5
= (((soma 2) + 3) + 4 ) + 5
= ((((soma 1) + 2) + 3) + 4) + 5

Agora,o seu interpretador resolverá a função de acordo com as prioridades:

= ((((1) + 2) + 3) + 4) + 5
= (((3) + 3) + 4) + 5
= ((6) + 4) + 5
= (10) + 5
= 15

Teste você mesmo, caminhe até o local do arquivo e:
hugs soma_recursividade.hs

Main> soma 10
15

Pronto! Simples? Talvez meio complicado para compreender de início, mas quando entra na cabeça, parece até simples. rs

Vou até deixar um exercício, ou melhor, dois!

Exercício 3:
O que acha de aprender a usar o Vi ? ou o Vim (Vi improved)?
É simples, poderoso e um software livre!

Eu treinei com esse aí:
Tutorial Básico Vim

Logo, quando eu estiver mais confortável, escrevo um post a respeito do Vim.

Exercício 4:
Crie uma função, em Haskell, que receba um inteiro como parametro e calcule o seu fatorial.

Vamos as definições matemáticas:
O Fatorial, para quem não lembra, é o número corrente multiplicado pelo fatorial de seu antecessor.
fatorial (n) = { 1 : n = 0
                    { fatorial (n - 1) * n  : n > = 1

Bom, se rolar alguma dúvida, não se esqueçam de comentar abaixo ou email-me: abner.terribili@gmail.com. A resposta para o exercicio 4 está no meu GitHub, nome exercicio_4.hs.

Até mais galera!

Haskell: Operadores Relacionais e Estruturas Condicionais

Fala aí galera, acho que to gostando de falar/aprender sobre Haskell :)

No post passado falei a respeito Tipo de Dados e Introdução a Funções, se não o leu, favor ler, complementará o material de hoje.

Hoje, vou falar a respeito Operadores Relacionais e Estruturas Condicionais.
Para começar, vamos entender o que fazem os Operadores Relacionais. Eles têm a responsabilidade de realizar comparações, trabalhando com valores lógicos:
São eles:

Operador	Descrição
>	maior do que
>=	maior ou igual a
<	menor do que
<=	menor ou igual a
/=	diferente de

Vou deixar alguns exemplos, somente para fins didáticos. Vamos fazer a soma de dois números e verificar as operações básicas relacionais entre eles:

soma x y | x + y > 0 = 1
         | x + y >= 0 = 2
         | x + y < 0 = 3
         | x + y <= 0 = 4

         | x + y /= 0 = 5 



-- Se a soma de x y for maior do que 0, retorna 1.

-- Se a soma de x y for maior ou igual a 0, retorna 2.

-- Se a soma de x y for menor do que 0, retorna 3.

-- Se a soma de x y for menor ou igual a 0, retorna 4

-- Se a soma de x y for diferente de 0, retorna 5

Estruturas Condicionais nada mais são do que condições que controlam se um determinado trecho de código será executado ou não. Exemplo, vamos supor que sua equação só trabalhe com números positivos. Normalmente faríamos algo parecido com:

sua_funcao seu_numero se seu_numero > 0 = √seu_numero
        caso contrário = 0

Aqui no Haskell, não é muito diferente, na verdade, é idêntico!
O Haskell também possui tipos de dados Booleanos (True / False). Podemos trabalhar com eles, para melhorar nossas estruturas condicionais.

Vamos aos exemplos, crie um arquivo chamado raiz_quadrada.hs e insira o código abaixo:

-- Você não precisa definir os tipos dos parâmetros de entrada e saída toda vez, mas para fixar o conceito, pratique!
raiz_quadrada :: Float -> Float
raiz_quadrada x | x > 0 =  sqrt(x)

Vamos entender, aquele pipe '|' é o nosso 'se', mais conhecido como 'if'. Tem a função de verificar o parâmetro de entrada. O 'x', é o nosso parâmetro de entrada. Caso o número seja positivo, a função 'sqrt()' pré-definida na Biblioteca do Haskell, Prelude, vai fazer o 'favor' de calcular a raiz quadrada do 'x'.

Bom, vamos fazer um something more nessa função.

Caso o número seja negativo ou igual a 0, vamos retornar 0.

raiz_quadrada x | x > 0 = sqrt(x)
                | otherwise = 0

Bom, o que é 'otherwise'?
Nada mais é do que 'caso contrário', significa que se nenhuma das condições acima for satisfeita, execute a condição 'otherwise'.

E se minha função tiver que trabalhar com uma condição 'composta' ?
Seria limitar ainda mais sua entrada, nós podemos usar os operadores abaixo:

Operador	Descrição
&&	e / and, tem o objetivo de verificar se ambas condições são verdadeiras.
||	ou / or, tem o objetivo de verificar apenas uma das condições é verdadeira.
not	não / not, tem o objetivo de negar o booleano, converte true/false e vice versa.

Abra seu arquivo raiz_quadrada.hs novamente, vamos fazer mais algumas alterações:

raiz_quadrada :: Float -> Float
raiz_quadrada x | x > 0 || x == 0 = sqrt(x)
                | otherwise = 0

-- Poderíamos otimizar para x >= 0, só não fiz isso para seguirmos no exemplo.

Execute sua função no Terminal, digitando:

hugs raiz_quadrada.hs

Você verá a telinha de apresentação do Hugs, informe o número de entrada da sua função:

Main> raiz_quadrada 2
1.41414

Agora com um número negativo:

Main> raiz_quadrada (-1)
0

Lembre-se de inserir o '()', para que o sinal de '-' faça parte do número real.

Se tiver alguma dúvida sobre como executar o arquivo, ou mesmo instalar o Interpretador Hugs, olhe aqui! Nos próximos posts evitarei ficar falando disso :)

Acredito ter dado uma pequena, mas boa introdução a 'Operadores Relacionais e Estruturas Condicionais', espero que tenham gostado.

Deixarei 2 exercícios abaixo, que não são de minha autoria (Claudio C. de Sá e Márcio F. da Silva), apenas as resoluções são de minha autoria, se tiverem alguma dúvida ou sugestão, pode comentar ou mesmo me enviar um email: abner.terribili@gmail.com. As respostas estão no meu GitHub.

Exercício 1:
Fornecidos três valores, a, b e c, escreva uma função que retorne quantos dos três são iguais. 3 para os 3 iguais. 2 para dois iguais e 0 para nenhum igual.

Exercício 2:
Fornecidos três valores, a, b e c, elaborar uma função que retorne quantos desses três números são maiores que o valor médio entre eles. 3 para os 3 maiores. 2 para dois maiores e 0 para nenhum maior.

Boa sorte!

Já que nosso primeiro HelloWorld foi Matemático, que tal fazermos um HelloWorld de verdade?

Crie um arquivo chamado hello_world.hs e digite em seu interior:

hello_world :: IO()
hello_world = putStrLn "Hello World!"
-- Mais para frente entro em detalhes desse Tipo de Dado IO()

Agora vá em seu Terminal, caminhe até o local do arquivo e digite:

hugs hello_world.hs

Teremos essa bela saída, criada por B. W. Kernighan

Main> hello_world
Hello World!

Agora, se você curtiu esse 'Hello World!', que tal implementa-lo em 'todas' as linguagens?
Deve ser um exercício muito construtivo e interessante!

A dica de hoje é exatamente essa: Programa Olá Mundo

Bom, agora acabou mesmo, até a próxima galera!

Haskell: Tipo de dados e Introdução a Funções

E aí galera, olha eu aqui de novo.

Hoje vou falar mais um pouco de Haskell. Caso você não saiba do que estou falando, dê uma olhadinha no meu primeiro post .

As funções que desenvolvemos no Haskell têm um tipo de dado de retorno e de entrada, podendo ser:

Tipo	Descrição	Exemplo
Bool	Booleano	True/False
Int	Inteiro com Domínio Limitado	1900
Integer	Inteiro com Domínio Ilimitado	01123581321345589144233
Float	Real	3.14159265359
Char	Caractere	'h'
String	Cadeira de Caracteres	'Haskell'
Void	Vazio	'_' (underscore. Mais pra frente, entrarei em detalhes)

O Haskell, como padrão, em seu compilador ou interpretador, tem um sistema de dedução automática de tipos em todas as funções que não tiveram seus tipos definidos. Ou seja, você não é 'obrigado' a definir os tipos de dados que serão utilizadas em suas funções. E sim, o Haskell possui uma disciplina rigorosa de tipos de dados, diz-se fortemente tipada. Com isso, sabemos que todas as variáveis, funções e constantes têm somente um tipo de dado e sempre podemos determinar o seu tipo. Certo?

Bom, caso você queira determinar os tipos de dados que serão aceitos por sua função, é bem simples, vamos ao exemplo teórico:

Definição do tipo de dados que serão aceitos pela função nome_funcao:

nome_funcao :: Tipo_Arg_1 -> Tipo_Arg_2 -> Tipo_Saida

Então, 'nome_funcao' é o nome da função, '::' operador de instância de tipos, 'Tipo_Arg_X' (Tipo_Arg_1, Tipo_Arg_2) é tipo de dado de entrada e por fim 'Tipo_Saida' é tipo de dado que será retornado por sua função.

No exemplo prático, talvez fique mais simples:

soma :: Int -> Int -> Int

soma x y = x + y

Ou seja, nossa função 'soma' receberá dois argumentos do tipo Int, 'x' e 'y', e terá como retorno um tipo 'Int'.

Nota: Lembre-se um pouco da Matemática, onde ƒ(x, y) = x + y.

Crie um novo arquivo com o nome de 'soma.hs' e digite o código acima dentro desse arquivo, não se esqueça de usar um editor de texto que tenha como padrão ASCII.

Teste no seu terminal:

hugs soma.hs

Deve aparecer a famosa apresentação do Hugs, digite:

Main> soma 3 4

7

Se sentir alguma dificuldade, baixe o arquivo do meu repositório GitHub: github.com/aterribili/Haskell/blob/master/soma.hs

Mais fácil impossível rs, talvez minha didática ainda não esteja tão boa quanto desejo, mas vou melhorando :)

E, para finalizar, as dicas de hoje são:

Interpretador Haskell Online TryHaskell (Gratuito)
http://tryhaskell.org/

Existe no GitHub, um repositório chamado /free-programming-books, onde nada menos que 16.000 pessoas estão colocando seus tutoriais de programação para compartilhar seus conhecimentos.

https://github.com/vhf/free-programming-books

E lá, tem algo muito bacana sobre Haskell:
https://github.com/taylorrf/learnhaskell
http://haskell.tailorfontela.com.br/

A galera ainda está traduzindo, mas já tem um bom material para começar. Vou dar um fork e tentar a ajudar a traduzir. Até mais galera! Qualquer dúvida, por favor, pergunte abaixo ou me enviem um email: abner.terribili@gmail.com. Vou criar um repositório GitHub e compartilhando os exercícios lá.

Atualizando: Repositório criado, para acompanhar os exercícios: github.com/aterribili/Haskell

Haskell: O HelloWorld Matemático

E aí galera, vou me apresentando aos poucos. 
Me chamo Abner Terribili, atualmente tenho 22 anos, estou planejando iniciar este blog há algum tempo (+/- 2 anos) . Sou programador há aproximadamente 3 anos, já trabalhei com Delphi, Java, HTML5, JS, Obj-C, C++, Android, e por aí vai. Tenho como maior objetivo salvar o mundo, ainda mais se for codando :). Meu objetivo aqui é deixar minhas experiências e ajudar aqueles que precisam de ajuda. Não possuo vasta experiência na área, e com esse blog, além de ajudar quem precisar, possivelmente aprenderei muito. Vou escrever a cada nova experiência que eu participar. E tentarei ao máximo que isso seja frequente.

Bom, com o tempo eu melhoro essa apresentação, estou empolgado para começar a codar com vocês. 

Hoje comecei a estudar algo novo, mais voltado para a Matemática, do que para programação. Estava procurando algum livro bacana em uma loja e acabei encontrando esse: Haskell : Uma abordagem prática de Claudio C. de Sá e Márcio F. da Silva. Cara, que coisa legal essa história de paradigma funcional. Não entrarei em extensos detalhes, para não ficar complicado para mim e para vocês.

O que é paradigma funcional ?

- É um paradigma de programação que trata a computação como uma avaliação de funções matemáticas e que evita estados ou dados mutáveis. Ela enfatiza a aplicação de funções, em contraste da programação imperativa, que enfatiza mudanças no estado do programa. (Wikipédia: Paradigma Funcional)

Depois de dar uma passadinha aí por cima do texto do Wikipédia (que é pequeno), vamos a instalação do interpretador Hugs. Escolhi o Haskell, justamente por ouvir falar bem a respeito (Jean Baro). Clique no link caso tenha interesse em maiores informações a respeito.

www.haskell.org/hugs/

O interpretador Hugs é uma implementação de Haskell, foi escrito na linguagem C e não compila código algum, somente interpreta. Após a instalação, que é bem simples, só acessar a guia “Downloading” do site acima e seguir os passos descritos.

Testei em um ambiente Unix/Mac, foi bem simples, fiz a instalação via Terminal, utilizei o Homebrew, que é um gerenciador de pacotes (Homebrew).

Comando para instalação do Hugs no Mac, via Terminal:

brew install hugs

Ele acabou pedindo um complemento (GCC):

brew install apple-gcc42

Para instalar no Linux:
apt-get install hugs

Aqui tem uma discussão legal a respeito da Instalação do Hugs no Windows:
Interpretador Haskell Windows e Online

E tudo certo!

Para escrever programas em Haskell, basta qualquer editor compatível com ASCII. Atualmente utilizo o Sublime Text 2 (Sublime Text 2).

Finalizando com exemplo:

Imagine que você tem que calcular a área de uma circunferência, então para iniciarmos nosso exercício vamos definir: 

- Área da circunferência = π * r ², onde π = 3.14159 e r = distância do centro da circunferência até alguma extremidade (raio).

Para iniciar o exercício, crie um diretório em algum local de sua preferência, no Desktop fica mais fácil acessar.

Após criar o diretório, crie, também, um novo arquivo chamado area_circunferencia.hs. (Arquivos com extensão .hs são aplicativos Haskell) 

Abra o seu arquivo area_circunferencia.hs com o seu editor de texto favorito.

Insira as seguintes linhas:

p = 3.14159

area_circunferencia r = p * r * r

Ou utilize o valor do pi da própria biblioteca Prelude:
area_circunferencia r = pi * r * r

Caminhe, via Terminal/CMD, até o diretório do arquivo area_circunferencia.hs.

Execute o comando :

hugs area_circunferencia.hs

Verá algo como:

Pronto sua aplicação está pronta para receber entradas, teste a sua função: 

Main> area_circunferencia 2

Deverá ver algo como:

12.5663706143592

Se sentir alguma dificuldade, baixe o arquivo do meu repositório GitHub: github.com/aterribili/Haskell/blob/master/area_circunferencia.hs

Nota: Na prática descobri que a biblioteca do Hugs, Prelude, já armazena um valor para o π (pi). Basta colocar pi no código. (Hugs.Prelude.pi)

O Haskell passou seu valor para o raio e fez o cálculo para você. Essa é a principal diferença do paradigma funcional, ele executa funções, como na matemática, você não precisa “mandar” ele fazer algo, precisa apenas informar os valores. Bom, espero que isso ajude quem tem interesse em Haskell e quem ainda não tem também. :) Vou melhorando e estou aqui para maiores dúvidas.