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!