Playlists
Surgiu em 1990 com o objetivo de ser a primeira linguagem puramente funcional.
Por muito tempo considerada uma linguagem acadêmica.
Atualmente é utilizada em diversas empresas (totalmente ou em parte de projetos).
Haskell tem como características:
take 100 [x | x <- nat, primo x]
x = 1.0
x = 2.0
ERRO!
int x = 1;
for (int i = 1; i <= 10; i++) {
x = x * 2;
}
printf("%d\n", x);
f 0 = 1
f n = 2 * f (n-1) -- Note que f(x) é o mesmo que f x
print (f 10)
print (aplique dobro [1,2,3,4])
> [2,4,6,8]
fst
retorna o primeiro elemento de uma tupla, os tipos dos elementos
não importam.fst :: (a,b) -> a
fst (x,y) = x
listaInf = [1..] -- 1, 2, 3, ...
print (take 10 listaInf)
module Main where -- indica que é o módulo principal
main :: IO ()
main = do -- início da função principal
putStrLn "hello world" -- imprime hello world
f a b -- f(a,b)
f a b + c*d -- f(a,b) + c*d
A tabela abaixo contém alguns contrastes entre a notação matemática e Haskell:
Matemática | Haskell |
---|---|
\(f(x)\) | f x |
\(f(x,y)\) | f x y |
\(f(g(x))\) | f (g x) |
\(f(x, g(y))\) | f x (g y) |
\(f(x)g(y)\) | f x * g y |
funcao, ordenaLista, soma1, x'
case, class, data, default, deriving do, else,
foreign, if, import, in, infix, infixl, infixr,
instance, let module, newtype, of, then, type,
where
As listas são nomeadas acrescentando o caractere ’s’ ao nome do que ela representa.
Uma lista de números n
é nomeada ns
, uma lista de variáveis
x
se torna xs
. Uma lista de listas de caracteres tem o nome
css
.
f x = a*x + b
where
a = 1
b = 3
z = f 2 + 3
where
faz parte da definição de f
, da mesma
forma, as definições de a
e b
fazem parte da cláusula
where
. A definição de z
não faz parte de f
.Comentários em uma linha são demarcados pela sequência --
, comentários
em múltiplas linhas são demarcados por {-
e -}
:
-- função que dobra o valor de x
dobra x = x + x
{-
dobra recebe uma variável numérica
e retorna seu valor em dobro.
-}
Um tipo é uma coleção de valores relacionados entre si.
Exemplos:
Int
compreende os valores de números inteiros.Bool
contém apenas os valores True
e False
, representando
valores lógicos.Em Haskell, os tipos são definidos pela notação
v :: T
Significando que v
define um valor do tipo T
.
False :: Bool
True :: Bool
10 :: Int
Alguns destes tipos são:
Bool
: contém os valores True
e False
. Expressões booleanas
podem ser executadas com os operadores &&
(e), ||
(ou) e
not
.
Char
: contém todos os caracteres no sistema Unicode. Podemos
representar a letra 'a'
, o número '5'
, a seta tripla '⇶'
e
o homem de terno levitando1, 2 '🕴'
.
String
: sequências de caracteres delimitados por aspas duplas:
"Olá Mundo"
.
Int
: inteiros com precisão fixa em 64 bits. Representa os
valores numéricos de \(-2^{63}\) até \(2^{63}-1\).
Integer
: inteiros de precisão arbitrária. Representa valores
inteiros de qualquer precisão, a memória é o limite. Mais lento
do que operações com Int
.
Float
: valores em ponto-flutuante de precisão simples. Permite
representar números com um total de \(7\) dígitos, em média.
Double
: valores em ponto-flutuante de precisão dupla. Permite
representar números com quase \(16\) dígitos, em média.
Note que ao escrever:
x = 3
O tipo de x
pode ser Int, Integer, Float
ou Double
.
Pergunta: Qual tipo devemos atribuir a x
?
Listas são sequências de elementos do mesmo tipo agrupados por colchetes e separados por vírgula:
[1,2,3,4]
[12]
Uma lista de tipo T
tem tipo [T]
:
[1,2,3,4] :: [Int]
[False, True, True] :: [Bool]
['o', 'l', 'a'] :: [Char]
Também podemos ter listas de listas:
[ [1,2,3], [4,5] ] :: [[Int]]
[ [ 'o','l','a'], ['m','u','n','d','o'] ] :: [[Char]]
\(\cdot\) O tipo da lista não especifica seu tamanho
\(\cdot\) Não existem limitações quanto ao tipo da lista
\(\cdot\) Não existem limitações quanto ao tamanho da lista
Tuplas são sequências finitas de componentes, contendo zero ou mais tipos diferentes:
(True, False) :: (Bool, Bool)
(1.0, "Sim", False) :: (Double, String, Bool)
(T1, T2,...,Tn)
.\(\cdot\) O tipo da tupla especifica seu tamanho
\(\cdot\) Não existem limitações dos tipos associados a tupla (podemos ter
tuplas de tuplas)
\(\cdot\) Tuplas devem ter um tamanho finito
\(\cdot\) Tuplas de aridade 1 não são permitidas para manter compatibilidade do
uso de parênteses como ordem de avaliação
Funções são mapas de argumentos de um tipo para resultados em
outro tipo. O tipo de uma função é escrito como T1 -> T2
, ou
seja, o mapa do tipo T1
para o tipo T2
:
not :: Bool -> Bool
even :: Int -> Bool
Para escrever uma função com múltiplos argumentos, basta separar os
argumentos pela ->
, sendo o último o tipo de retorno:
soma :: Int -> Int -> Int
soma x y = x + y
mult :: Int -> Int -> Int -> Int
mult x y z = x * y * z
Estes slides foram preparados para os cursos de Paradigmas de Programação e Desenvolvimento Orientado a Tipos na UFABC.
Este material pode ser usado livremente desde que sejam mantidos, além deste aviso, os créditos aos autores e instituições.
Este é o nome oficial do caracter na tabela Unicode v.7.0! ↩︎
The Secret Ska History of That Weird Levitating Businessman Emoji ↩︎