Ir para o conteúdo

Tipos Básicos e seus Operadores

Como toda linguagem de programação, Haskell tem vários tipos pré-definidos para representar números, valores booleanos, e (sequências de) caracteres. Algo a se notar é que os nomes dos tipos são iniciados com letras maiúsculas, diferentemente dos nomes de funções e variáveis.

Números

Os tipos básicos para a representação de números em Haskell são apresentados na seguinte tabela. Observe que o tipo Integer ter precisão arbitrária, ou seja, pode ser usado para representar números com "qualquer" quantidade de dígitos, diferentemente de Int, que só consegue representar números em uma faixa específica (64 bits).

Tipos numéricos
Tipo Descrição Valores
Int Inteiro de precisão finita 4, -14, 2147483647
Integer Inteiro de precisão arbitrária 30414093201713378043612608166064768844377641568960512000000000000
Float Ponto flutuante de precisão simples 25.132742
Double Ponto flutuante de precisão dupla 25.132741228718345
Operadores

Diversos operadores são definidos para os tipos numéricos básicos, como mostra a tabela a seguir.

Operador Operação Exemplo
+ Adição 1 + 1 ⭆ 2
- Subtração 1 - 1 ⭆ 0
* Multiplicação 1 * 1 ⭆ 1
/ Divisão 1 / 1 ⭆ 1
^ Exponenciação 2^4 ⭆ 16
- Inversão de sinal2 - (-10) ⭆ 10
negate Inversão de sinal2 negate (-10) ⭆ 10
quot Divisão inteira, truncado para o 0, i.e., quot a b é igual a \(\lfloor\frac{a}{b}\rfloor\) se \(a>0\) e \(\lceil\frac{a}{b}\rceil\) se \(a<0\) quot 8 3 ⭆ 2 e quot (-8) 3 ⭆ -2
rem Resto da divisão inteira, tal que (quot x y)*y + (rem x y) ⭆ x rem 8 3 ⭆ 2 e rem (-8) 3 ⭆ -2
div Divisão inteira, truncado para baixo, i.e., div a b é igual a \(\lfloor\frac{a}{b}\rfloor\) div 8 3 ⭆ 2 e div (-8) 3 ⭆ -3
mod Módulo do inteiro, tal que (div x y)*y + (mod x y) ⭆ x mod (-8) 3 ⭆ 1 e mod (8) 3 ⭆ 2
Infixo X Prefixo

Observe que alguns destes operadores são naturalmente infixos, e.g., +, e outros, prefixos, e.g., rem.1 Contudo, ambos podem ser usados da outra forma, como mostrado nos seguintes exemplos, em que os operadores infixos são envelopados em por parênteses e os pré-fixos em aspas invertidas simples.

10 + 20
(+) 10 20
quot 10 3
10 `quot` 3
Tipos para números

Caso você queira ou precise, pode especificar um tipo para um número, por exemplo, 20 :: Int ou 20 :: Double.

Exercícios

  • Usar todos os operadores
  • Evidenciar diferenças entrem quot/rem e div/mod.

Booleanos

Para representação de valores lógicos, Haskell define o tipo Bool.

Tipo Descrição Valores
Bool Booleano True ou False

Para este tipo, temos os seguintes operadores.

Operador Operação
&& E lógico
|| OU lógico
not Negação
== Igualdade
/= Diferença

Caracteres

Finalmente, para a representação de caracteres individuais, Haskell usa o tipo Char, e para sequências de caracteres, usa o tipo String. Exemplos dos dois tipos são apresentados na tabela a seguir.

Tipo Descrição Valores
Char Caractere '1'; 'a'; 'B'
String Sequência de caracteres "Eu"; "Hello"; "Zabumba"

O tipo String é, na verdade, apenas um "apelido" para o tipo lista de caracteres e, assim sendo, voltaremos a falar de String quando estudarmos listas, mais adiante.

Haskell trabalha com caracteres Unicode, que incluem símbolos e letras em diferentes línguas, números, sinais de pontuação, separadores e outros caracteres especiais, como emojis e caracteres de controle. A seguir, algumas funções de manipulação de caracteres.3

Função Descrição Exemplo
isSpace Testa se é um espaço em branco ' ') ou um dos seguintes caractere de controle \t, \n, \r, \f ou \v isSpace '\t' ⭆ True e isSpace ' ' ⭆ True
isControl Testa se é um caracter de controle isControl '\t' ⭆ True
isLetter Testa se é uma letra isLetter 'A' ⭆ True e isLetter '\t' ⭆ False
isDigit Testa se é um dígito isDigit 'A' ⭆ False e isDigit '3' ⭆ True
isLower Testa se é uma letra minúscula isLower 'a' ⭆ True e isLower '\t' ⭆ False
isUpper Testa se é uma letra maiúscula isUpper 'A' ⭆ True e isUpper '\t' ⭆ False
toLower Transforma uma letra em minúscula toLower 'a' ⭆ 'a' e toLower 'A' ⭆ 'a'
toUpper Transforma uma letra em maiúscula toUpper 'A' ⭆ 'A' e toUpper 'a' ⭆ 'A'

  1. Operadores são funções cujos nomes só contem caracteres especiais. Eles são naturalmente infixos. ↩

  2. Observe que o o -10 está entre parênteses não porque o operador demanda, mas para deixar claro que o - faz parte do número. ↩↩

  3. Diversas outras funções estão disponíveis no pacote Data.Char. ↩