Bool

I
I

Valores: True, False

Funcoes:
I
I
I
I

(ordem)
igualdade e comparacoes
retorna True sse ambos argumentos iguais a True
&& (e):
|| (ou): retorna True sse algum argumento igual a True

do argumento
not (nao):
retorna negacao

Integer, Int

Integer : inteiros com tamanho ilimitado

Int: inteiros com tamanho limitado (32 bits)

(sobrecarregadas):
Funcoes

I
I
I

(ordem)
resultado de igualdade e comparacoes

Aritmeticas:
+, -, *, div, mod, abs, negate,
fromInteger, toInteger
Conversao:

 com guardas
Definicoes
de funcao
pode usar guardas. Ex.:
Definicao
signum x
| x > 0
= 1
| x < 0
= -1
| otherwise = 0
Equivale a:
signum x = if x>0 then 1
else if x<0 then -1
else 0
Outros exemplos:
max x y | x >= y
| otherwise
max3 x y z
| x >= y && x>= z
| y >= z
| otherwise

= x
= y
= x
= y
= z

Char
I

Literais escritos entre aspas simples. Ex.: a, 3, *,

\n, \\, \, \65, \97

Haskell usa Unicode

Conversao

I
I

fromEnum:: Char Int

toEnum:: Int Char

Exemplos de funcoes:
offset:: Int
offset = fromEnum A - fromEnum a
toUpper:: Char -> Char
toUpper ch = toEnum (fromEnum ch + offset)
isDigit:: Char -> Bool
isDigit ch = (0 <= ch) && (ch <= 9)

String

Sequencias
de caracteres

Literais escritos entre aspas duplas. Ex.: "abc",

"*2!a\n"
funcoes
sobrecarregadas show, read
Conversao:

I
I
I
I

show
show
read
read

(2+3)
"5"
(not True)
"False"
"False"
False
5
5

Ponto Flutuante

limitados
Float, Double: tamanhos e precisao

Literais: -23.12, -2.312e1, -231.2e-1

(sobrecarregadas):
Funcoes

I
I

(ordem)
resultado de igualdade e comparacoes

Aritmeticas:
+, -, *, /, , **, abs, negate, cos, sin, tan,
acos, asin, atan, ceiling, floor, round, log, logBase, pi,
signum, sqr
fromIntegral, fromInteger, toIntegral, toInteger
Conversao:
I

ha conversao
automatica:

de tipos
Nao
verificacao
(considere os tipos!)
Exemplo: 2 + 5.0 correto porque 2 equivale a
fromInteger 2

Regra de leiaute

termina em texto que comeca na mesma coluna,

Definicao
ou coluna mais a` esquerda, da coluna de incio da

definicao

Exemplo:
f x = x *x
+x
-2
g y = ...

Leiaute e sugerido por editores dirigidos por sintaxe. Ex.:

emacs ou vi com Haskell-mode, Eclipse-FP

Operadores
I
I

I
I

smbolos que denotam funcoes,

Operadores sao

tipicamente binarias
usam os smbolos, quando
Chamadas de funcoes
binarias,

antes,
operacoes
entre os operandos (e nao

como no caso de funcoes)

usados em forma infixada, funcoes
em
Operadores sao
forma prefixada
Operador que recebe dois ou mais argumentos pode ser

usado de forma prefixada colocando-o entre parenteses.

Ex.: (+) 2 3
(ou construtor) que tenha
Analogamente, nome de funcao
mais de um argumento pode ser usada em forma infixada
entre crases. Ex.: 3 mod 2
colocando nome da funcao
Operadores podem ser definidos em programas:
(&&&):: Integer -> Integer -> Integer
x &&& y
| x > y
= x
| otherwise = y


Precedencia
e Associatividade de Operadores
I

precedencia

Operadores tem
entre 0 (a menor) e 9 (a

maior) usada para evitar parenteses

Exemplo: * tem precedencia

maior que +. Portanto:
1+2*3 e o mesmo que 1+(2*3)
de funcao
tem precedencia

Aplicacao
sobre uso de
operadores. Ex.: f x + 1 e o mesmo que (f x) + 1
Associatividade pode ser a` esquerda ou a` direita, e indica,
para um operador qualquer, digamos +, se: e1 + e2 +
e3 e equivalente a: (e1 + e2) + e3 ou a: (e1 + (e2
+ e3 No primeiro caso a associatividade e a` esquerda e
no segundo caso a` direita

Precedencia
e associatividade de operadores devem ser
usadas para aumentar a legibilidade de programas

(evitando parenteses)