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!