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!

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!