Noções Básicas
Hello World
main é o ponto de entrada, putStrLn exibe com uma nova linha
-- GHCi interactive environment
-- launch: ghci (quit with :q)
-- simple arithmetic
> 2 + 3
5
-- function application (no parentheses needed)
> succ 5
6
-- define a function
> double x = x * 2
> double 10
20
-- lists
> [1,2,3,4]
[1,2,3,4]
-- strings are lists of chars
> "hello"
"hello"Comentários
{- -} para comentários de múltiplas linhas
-- single line comment
{- multi-line comment
spanning multiple lines -}
{- nested {- comments -} are allowed -}
-- comments are ignored by the compilerGHCi Interativo
:t mostra o tipo, :q sai
-- hello.hs
main :: IO ()
main = putStrLn "Hello, World!"
-- run interpreted
-- runhaskell hello.hs
-- or compile to an executable
-- ghc hello.hs && ./helloBinding let
let define variáveis locais em um bloco do
-- in GHCi, 'let' defines a binding (no 'in' needed)
> let x = 5
> let double n = n * 2
> x + double x
15
-- in a source file, top-level bindings need no 'let'
y = 10
-- 'let' inside an expression needs 'in'
z = let a = 2 in a * a -- 4Regras de Indentação
Haskell usa indentação em vez de chaves
-- :t shows the type of an expression
> :t 'a'
'a' :: Char
> :t True
True :: Bool
> :t "hi"
"hi" :: [Char]
> :t (+)
(+) :: Num a => a -> a -> a
-- :info shows typeclass info
> :info NumCarregando arquivos
:load carrega um módulo no GHCi; :reload o recarrega após edições. :browse lista tudo que um módulo exporta. :main roda o programa com argumentos de linha de comando. Isso deixa o fluxo do REPL fluido.
-- GHCi commands
> :load MyModule.hs -- or :l
> :reload -- or :r, reload after edits
> :type main -- check a type
> :browse Data.List -- list a module's exports
> :main arg1 arg2 -- run main with args
-- :set +t auto-prints types of resultsTipos
Tipos Básicos
:: anota tipos explicitamente
-- Int: bounded integer (platform-dependent)
x :: Int
x = 9
-- Integer: arbitrary-precision (unbounded)
big :: Integer
big = 2 ^ 100
-- Float / Double (prefer Double)
piVal :: Double
piVal = 3.14159
-- Bool
flag :: Bool
flag = True
-- Char (single Unicode character)
c :: Char
c = 'a'Tipos de Função
-> é associativo à direita, o último é o tipo de retorno
-- explicit type signature above a binding
age :: Int
age = 30
-- annotate an expression inline with ::
result = (5 :: Int) + 3
-- function signature
add :: Int -> Int -> Int
add x y = x + y
-- annotate a list
nums :: [Double]
nums = [1.0, 2.0, 3.0]Variáveis de Tipo
Letras minúsculas são variáveis de tipo
-- 'a' is a type variable (polymorphic)
id' :: a -> a
id' x = x
-- works for any type
> id' 5
5
> id' "hello"
"hello"
-- length works on any list
length :: [a] -> IntTipo Maybe
Maybe representa computações que podem falhar
-- '->' is right-associative
add :: Int -> Int -> Int
-- equivalent to: Int -> (Int -> Int)
-- takes a function as an argument
apply :: (a -> b) -> a -> b
apply f x = f x
-- returns a function
const' :: a -> b -> a
const' x y = xTipo Either
Either é usado para tratamento de erros
-- Maybe: optional values
data Maybe a = Nothing | Just a
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)
-- Either: a value or an error
data Either a b = Left a | Right b
-- convention: Left = error, Right = success
parse :: String -> Either String Int
parse s = Right (read s)Tuples e tipos de lista
Tuples (a, b) guardam um número fixo de valores de tipos possivelmente diferentes. Listas [a] guardam qualquer número de valores do mesmo tipo. O tipo de uma tuple codifica seu tamanho; o de uma lista, não.
-- tuple: (a, b)
pair :: (Int, String)
pair = (1, "one")
-- list: [a]
nums :: [Int]
nums = [1, 2, 3]
-- list of tuples
pairs :: [(Int, String)]
pairs = [(1, "a"), (2, "b")]
-- empty list keeps the polymorphic type
empty :: [a]
empty = []Type Classes
Type Class Eq
Eq define comparação de igualdade
-- name, parameters, '=', body
double :: Int -> Int
double x = x * 2
-- application: just a space, no parentheses
> double 5
10
-- multiple parameters (curried)
add :: Int -> Int -> Int
add x y = x + y
> add 3 4
7Show e Read
Type classes Show/Read
-- application is left-associative
> max 3 5
5
> max (max 3 5) 7
7
-- '$' has the lowest precedence, right-associative
> sum (map (*2) [1..5])
30
> sum $ map (*2) [1..5] -- same, fewer parens
-- chain reads left to right
> putStrLn $ show $ sum [1..10]
55Num e Ord
Num para operações numéricas, Ord para comparação de ordenação
-- wrap an operator in () to use as a function
> (+) 2 3
5
> (*) 4 5
20
-- sections: partial application of operators
> (+10) 5
15
> (3/) 12
0.25
> (/3) 12
4.0
-- backticks make a function infix
> 10 `div` 3
3
> 10 `mod` 3
1Type Class Functor
Functor é mapeável
-- (.) composes functions right to left
(.) :: (b -> c) -> (a -> b) -> a -> c
(f . g) x = f (g x)
> negate . sum $ [1,2,3]
-6
-- chaining
fn = ceiling . negate . tan
> fn (pi/4)
-1
-- point-free style
odd' = not . evenRestrições de Tipo
À esquerda de => está a restrição de tipo
-- functions are first-class values
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
> applyTwice (+3) 10
16
> applyTwice (\x -> x*x) 2
16
-- pass functions to higher-order functions
> map (*2) [1..5]
[2,4,6,8,10]
> filter even [1..6]
[2,4,6]Infix e prefix
Qualquer função binária pode ser escrita infixa entre backticks (3 `elem` xs), e qualquer operador pode ser escrito prefixo entre parênteses (mod 10 3). Escolha o que ler de forma mais natural no contexto.
-- infix operators can be written prefix with ()
> mod 10 3
1
> div 10 3
3
-- functions can be written infix with backticks
> 10 `mod` 3
1
> 10 `div` 3
3
-- elem: membership test, often infix
> 3 `elem` [1,2,3]
TrueFunções
Definição de Função
Chamadas de função não precisam de parênteses
-- lists are homogeneous linked lists
nums :: [Int]
nums = [1, 2, 3, 4, 5]
-- strings are [Char]
chars = ['h','e','l','l','o']
str = "hello" -- same as chars
-- empty list
empty = []
-- cons (prepend) is O(1)
> 0 : [1,2,3]
[0,1,2,3]Funções de Múltiplos Parâmetros
Todas as funções são de parâmetro único (curried)
-- ranges
> [1..5]
[1,2,3,4,5]
-- with a step (first two elements)
> [2,4..10]
[2,4,6,8,10]
-- decreasing needs the step
> [5,4..1]
[5,4,3,2,1]
-- infinite lists (lazy)
> take 5 [1..]
[1,2,3,4,5]
> take 3 (cycle [1,2])
[1,2,1]Operadores como Funções
() envolve um operador como função
-- basic access (partial: crash on empty)
> head [1,2,3]
1
> tail [1,2,3]
[2,3]
> last [1,2,3]
3
> init [1,2,3]
[1,2]
-- safe helpers
> length [1,2,3]
3
> null []
True
> reverse [1,2,3]
[3,2,1]Composição de Funções
. operador compõe funções
-- '++' concatenates two lists
> [1,2] ++ [3,4]
[1,2,3,4]
-- ':' prepends a single element (O(1))
> 1 : [2,3]
[1,2,3]
-- concat flattens one level
> concat [[1,2],[3,4],[5]]
[1,2,3,4,5]
-- intercalate joins with a separator
> intercalate ", " ["a","b","c"]
"a, b, c"Cláusula where
where define auxiliares no final de uma função
-- like mathematical set-builder notation
> [x*2 | x <- [1..5]]
[2,4,6,8,10]
-- with a predicate (filter)
> [x | x <- [1..10], even x]
[2,4,6,8,10]
-- multiple generators = Cartesian product
> [(x,y) | x <- [1,2], y <- ['a','b']]
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- with a let binding
> [x*y | x <- [1..3], let y = x+1]
[2,6,12]Funções de lista comuns
elem verifica pertencimento (geralmente infixo). sum e product reduzem listas de números. take/drop extraem ou removem um prefixo. splitAt divide num índice, num par. Todas retornam novas listas, já que listas são imutáveis.
-- membership (often written infix)
> elem 3 [1,2,3]
True
> 3 `elem` [1,2,3]
True
-- reductions
> sum [1..10]
55
> product [1..5]
120
-- take / drop a prefix
> take 3 [1..10]
[1,2,3]
> drop 3 [1..10]
[4,5,6,7,8,9,10]
-- split at an index
> splitAt 3 [1..6]
([1,2,3],[4,5,6])Pattern Matching
Pattern Matching Básico
Faz match em ordem, _ corresponde a qualquer coisa
-- tuples can hold different types
pair :: (Int, String)
pair = (1, "hello")
triple :: (Int, String, Double)
triple = (1, "x", 3.14)
-- the size is part of the type
-- (1,2) and (1,2,3) are different typesPattern Matching em Listas
: separa head e tail
-- fst/snd only work on pairs
> fst (1, "a")
1
> snd (1, "a")
"a"
-- swap exchanges the components
> swap (1, 2)
(2,1)
-- these do NOT work on triples
> fst (1, 2, 3) -- type error!Pattern Matching em Tuples
Faz match de cada posição de um tuple
-- destructure a tuple by position
describe :: (Int, String) -> String
describe (n, s) = show n ++ ": " ++ s
-- ignore components with _
firstOf :: (a, b, c) -> a
firstOf (x, _, _) = x
-- in a list comprehension
> [n | (n, _) <- [(1,'a'),(2,'b')]]
[1,2]Padrão as
@ mantém o valor inteiro correspondido
-- zip pairs elements from two lists
> zip [1,2,3] ['a','b','c']
[(1,'a'),(2,'b'),(3,'c')]
-- stops at the shorter list
> zip [1,2,3] [4,5]
[(1,4),(2,5)]
-- unzip splits a list of pairs
> unzip [(1,'a'),(2,'b')]
([1,2],"ab")Expressão case
case para pattern matching dentro do corpo de uma função
-- list: same type, variable length
ints :: [Int]
ints = [1, 2, 3]
-- tuple: mixed types, fixed length
mixed :: (Int, String, Bool)
mixed = (1, "x", True)
-- list of tuples (tabular data)
people :: [(String, Int)]
people = [("Alice",30),("Bob",25)]
-- cannot mix types in a list
> [1, "two"] -- type errorGuardas
Guardas Básicas
otherwise é um alias para True
-- match on literals, top to bottom
lucky :: Int -> String
lucky 7 = "LUCKY SEVEN!"
lucky _ = "Sorry, you're out of luck"
> lucky 7
"LUCKY SEVEN!"
> lucky 13
"Sorry, you're out of luck"Guardas de Múltiplos Parâmetros
Guardas verificam em ordem
-- empty list
isEmpty [] = True
isEmpty _ = False
-- head and tail (cons pattern)
head' :: [a] -> a
head' (x:_) = x
-- first two elements
firstTwo :: [a] -> [a]
firstTwo (x:y:_) = [x,y]
firstTwo xs = xswhere com Guardas
where pode ser compartilhado por todas as guardas
-- match by position
addPair :: (Int, Int) -> Int
addPair (x, y) = x + y
-- nested patterns
getAge :: (String, (Int, Int)) -> Int
getAge (_, (age, _)) = age
-- ignore with _
nameOf :: (String, Int) -> String
nameOf (name, _) = namePadrões as
As-patterns (name@pattern) vinculam um nome ao valor inteiro casado enquanto o desestruturam. Útil quando você precisa tanto do original quanto de suas partes, evitando reconstrução cara.
-- '@' keeps the whole value AND its parts
firstLetter :: String -> String
firstLetter "" = "Empty string!"
firstLetter all@(x:_) =
"The first letter of " ++ all ++ " is " ++ [x]
> firstLetter "Haskell"
"The first letter of Haskell is H"Expressões case
case faz pattern matching dentro de uma expressão. É útil quando o corpo de uma função precisa ramificar sobre um valor computado depois de alguma preparação. Os padrões são tentados em ordem; adicione um catch-all se necessário.
-- pattern match inside any expression
describe :: [a] -> String
describe xs =
case xs of
[] -> "empty"
[_] -> "singleton"
_ -> "longer"
-- case on any value, e.g. an Ordering
classify n = case compare n 0 of
LT -> "negative"
EQ -> "zero"
GT -> "positive"Padrões de construtor
Padrões podem casar construtores de dados como Red, Nothing e Just. É assim que tipos de dados algébricos são desconstruídos. O compilador avisa sobre padrões não exaustivos, então cubra os construtores.
-- match on data constructors
data Color = Red | Green | Blue
toString :: Color -> String
toString Red = "red"
toString Green = "green"
toString Blue = "blue"
-- match on Maybe
fromMaybe :: a -> Maybe a -> a
fromMaybe d Nothing = d
fromMaybe _ (Just x) = xWhere / Let
Cláusula where
where fica no final da definição da função
-- '|' tests boolean conditions in order
bmiTell :: Double -> String
bmiTell bmi
| bmi <= 18.5 = "underweight"
| bmi <= 25.0 = "normal"
| bmi <= 30.0 = "overweight"
| otherwise = "obese"
> bmiTell 22.0
"normal"Expressão let-in
let-in é uma expressão, pode ser usada em qualquer lugar
-- otherwise is just True
otherwise :: Bool
otherwise = True
-- a signum implementation
signum' :: Int -> Int
signum' n
| n < 0 = -1
| n == 0 = 0
| otherwise = 1let em Bloco do
let em um bloco do não precisa de in
-- multiple parameters
max' :: Int -> Int -> Int
max' a b
| a > b = a
| otherwise = b
-- shared helpers via where
bmiTell :: Double -> Double -> String
bmiTell w h
| bmi <= 18.5 = "underweight"
| bmi <= 25.0 = "normal"
| otherwise = "overweight"
where bmi = w / h^2let em List Comprehension
let pode ser usado em list comprehensions
-- pattern matching: fixed values/structure
factorial 0 = 1
factorial n = n * factorial (n-1)
-- guards: ranges and conditions
clamp :: Int -> Int -> Int -> Int
clamp lo hi x
| x < lo = lo
| x > hi = hi
| otherwise = xif-then-else
Em Haskell, 'if' é uma expressão que sempre retorna um valor — os dois ramos são obrigatórios. Para ramificações m últiplas, guards são mais limpos que if-then-else aninhado. if-then-else serve para escolhas simples de duas vias.
-- 'if' is an expression that returns a value
abs' :: Int -> Int
abs' n = if n < 0 then -n else n
-- nested ifs (prefer guards for readability)
grade :: Int -> Char
grade n =
if n >= 90 then 'A'
else if n >= 80 then 'B'
else if n >= 70 then 'C'
else 'F'Listas
Noções Básicas de Listas
Listas são listas encadeadas de elementos do mesmo tipo
-- where: definitions at the bottom, scoped to a function
area :: Double -> Double -> Double
area w h = w * h_adj
where
h_adj = h * 0.9 -- adjust height
scale = 0.9 -- a helper
-- definitions can refer to each other
f x = a + b
where a = x * 2
b = a + 1 -- refers to aListas de Intervalo
Suporta passo e listas infinitas
-- let <bindings> in <expr>
cylinder :: Double -> Double -> Double
cylinder r h =
let side = 2 * pi * r * h
top = pi * r^2
in side + 2 * top
-- scoped to the expression only
> let z = 5 in z * z
25
-- z is not in scope hereOperações com Listas
Funções básicas de operação com listas
-- in do, 'let' needs no 'in'
main = do
let x = 5
y = 10
putStrLn $ "sum = " ++ show (x + y)
-- in a list comprehension, no 'in'
> [x*y | x <- [1..3], let y = x+1]
[2, 6, 12]Concatenação de Listas
++ concatena, : adiciona à head
-- where bindings support pattern matching
describe :: [a] -> String
describe xs = "head is " ++ show first
where (first:_) = xs
-- multiple where bindings
analyze :: [Int] -> String
analyze xs =
"sum=" ++ show s ++ ", len=" ++ show l
where s = sum xs
l = length xsList Comprehension
Similar a comprehensions de conjuntos matemáticos
-- let: an expression, available wherever expressions go
-- (needs 'in', except in do/comprehension)
-- where: a declaration, attached to a function
-- (cannot be nested as an expression)
-- same result, two styles:
-- with let:
f x = let y = x+1 in y*y
-- with where:
f' x = y*y where y = x+1Tuples
Noções Básicas de Tuples
Tuples podem conter tipos diferentes
-- base case + recursive case
factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)
> factorial 5
120Funções de Tuple
fst/snd só funcionam em pares
-- match [] then (x:xs)
length' :: [a] -> Int
length' [] = 0
length' (_:xs) = 1 + length' xs
sum' :: Num a => [a] -> a
sum' [] = 0
sum' (x:xs) = x + sum' xsPattern Matching em Tuples
Pattern matching desestrutura tuples
-- carry the running result in an accumulator
factorial :: Int -> Int
factorial n = go n 1
where
go 0 acc = acc
go k acc = go (k-1) (k*acc)
-- sum with an accumulator
sumTo :: Int -> Int
sumTo n = go n 0
where go 0 acc = acc
go k acc = go (k-1) (k+acc)Quick Sort
Este exemplo famoso mostra a expressividade de Haskell: list comprehensions dividem em torno de um pivô, e então cada parte é ordenada recursivamente. Não é o quicksort mais eficiente, mas é uma demonstração bela de recursão e comprehensions.
-- elegant but not in-place quicksort
qsort :: Ord a => [a] -> [a]
qsort [] = []
qsort (p:xs) =
qsort smaller ++ [p] ++ qsort larger
where
smaller = [x | x <- xs, x < p]
larger = [x | x <- xs, x >= p]
> qsort [3,1,4,1,5,9,2,6]
[1,1,2,3,4,5,6,9]Recursão mútua
Recursão mútua é quando duas ou mais funções se chamam. Aqui even' e odd' reduzem em direção ao caso base 0. Ambas devem estar definidas (a ordem não importa num módulo).
-- functions calling each other
even' :: Int -> Bool
even' 0 = True
even' n = odd' (n - 1)
odd' :: Int -> Bool
odd' 0 = False
odd' n = even' (n - 1)
> even' 4
TrueFunções de Ordem Superior
map
map aplica uma função a cada elemento
-- map applies a function to every element
> map (*2) [1,2,3]
[2,4,6]
> map (+1) [1..5]
[2,3,4,5,6]
-- with a lambda
> map (\x -> x*x) [1..4]
[1,4,9,16]
-- strings are lists of chars
> map toUpper "hello"
"HELLO"filter
filter mantém elementos que satisfazem o predicado
-- keep elements satisfying a predicate
> filter even [1..10]
[2,4,6,8,10]
> filter (>3) [1,2,3,4,5]
[4,5]
-- with a lambda
> filter (\c -> c /= ' ') "hello world"
"helloworld"
-- count matches
> length (filter odd [1..100])
50foldl e foldr
foldl fold à esquerda, foldr fold à direita
-- foldl: left fold (function, seed, list)
> foldl (+) 0 [1..5]
15
-- foldr: right fold
> foldr (+) 0 [1..5]
15
-- associativity differs:
-- foldl: ((((0+1)+2)+3)+4)+5
-- foldr: 1+(2+(3+(4+(5+0))))
-- foldl1/foldr1 use the first element as seed
> foldl1 max [3,1,4,1,5]
5zipWith
zipWith combina duas listas com uma função
-- apply a function to paired elements
> zipWith (+) [1,2,3] [10,20,30]
[11,22,33]
> zipWith (*) [1,2,3,4] [2,2,2,2]
[2,4,6,8]
-- combine strings
> zipWith (\a b -> a ++ b) ["a","b"] ["1","2"]
["a1","b2"]
-- stops at the shorter list
> zipWith max [1,5,3] [2,4,6,8]
[2,5,6]Aplicação de Função $
Operador $ reduz parênteses
-- scanl returns all intermediate accumulators
> scanl (+) 0 [1,2,3]
[0,1,3,6]
-- scanr from the right
> scanr (+) 0 [1,2,3]
[6,5,3,0]
-- running maximum
> scanl max 0 [3,1,4,1,5]
[0,3,3,4,4,5]takeWhile e dropWhile
takeWhile para no primeiro elemento que falha no predicado; dropWhile descarta o prefixo que o satisfaz. span divide a lista no primeiro elemento que falha. Ótimos para processamento baseado em prefixo.
-- takeWhile: take while the predicate holds
> takeWhile (<5) [1,2,3,4,5,4,3]
[1,2,3,4]
-- dropWhile: drop while the predicate holds
> dropWhile (<5) [1,2,3,4,5,4,3]
[5,4,3]
-- span splits at the first failing element
> span (<3) [1,2,3,4,5]
([1,2],[3,4,5])
-- first word of a string
> takeWhile (/= ' ') "hello world"
"hello"Map / Filter / Fold
Operações Encadeadas
Combinar map/filter/fold
-- '\' defines a lambda (resembles the λ symbol)
> (\x -> x + 1) 5
6
-- used with map
> map (\x -> x * x) [1..4]
[1,4,9,16]
-- used with filter
> filter (\x -> x > 2) [1,2,3,4]
[3,4]scanl/scanr
scan mantém todos os resultados intermediários
-- parameters separated by spaces
> (\x y -> x + y) 3 4
7
-- in zipWith
> zipWith (\x y -> x * y + 1) [1,2,3] [10,20,30]
[11,21,31]takeWhile/dropWhile
Pegar/descartar elementos por condição
-- lambdas can pattern match their one argument
> map (\(a,b) -> a + b) [(1,2),(3,4)]
[3,7]
-- only ONE pattern, no fallthrough
-- this crashes if it doesn't match:
> (\(x:_) -> x) [] -- runtime errorLambdas em ordem superior
Lambdas brilham com fold, filter e map. Podem retornar outras funções (\x -> \y -> ...), demonstrando currying. Mantenha-os curtos — lambdas longos ficam mais claros como funções nomeadas.
-- combining with fold
> foldl (\acc x -> acc + x*2) 0 [1,2,3]
12
-- with filter (infix via backticks)
> length . filter (\x -> x `mod` 2 == 0) $ [1..10]
5
-- a lambda returning a function
> (\x -> \y -> x + y) 3 4
7Estilo point-free
O estilo point-free omite argumentos explícitos, expressando funções via composição e aplicação. É conciso, mas pode prejudicar a legibilidade se exagerado. Prefira-o para cadeias curtas em que o fluxo é óbvio.
-- explicit: name every argument
sumSquares xs = sum (map (^2) xs)
-- point-free: omit arguments via composition
sumSquares' = sum . map (^2)
-- more examples
count p = length . filter p
oddNums = filter odd
negateAll = map negateLambdas
Funções Anônimas
\ define um lambda, como λ
-- all functions are curried (one arg at a time)
add :: Int -> Int -> Int
add x y = x + y
-- apply fewer args to get a function
add5 :: Int -> Int
add5 = add 5
> add5 10
15
-- with map
> map (add 5) [1,2,3]
[6,7,8]Lambda de Múltiplos Parâmetros
Múltiplos parâmetros separados por espaços
-- left section (fix the left operand)
> map (+3) [1,2,3]
[4,5,6]
-- right section (fix the right operand)
> map (3/) [9, 12, 18]
[0.333..,0.25,0.166..]
-- (-3) is the NUMBER, not a section!
> map (subtract 3) [4,5,6]
[1,2,3]
-- comparison sections
> filter (>3) [1..6]
[4,5,6]Lambda com Pattern Matching
Pattern matching em lambdas
-- flip swaps the first two arguments
flip :: (a -> b -> c) -> b -> a -> c
flip f x y = f y x
-- fix the second argument instead of the first
> map (flip (-) 1) [3,4,5]
[2,3,4]
-- divide from the other side
> map (flip div 2) [4,6,9]
[2,3,4]Currying explicado
a -> b -> c significa a -> (b -> c): uma função que recebe 'a' e retorna uma função. A aplicação é associativa à esquerda: f x y = (f x) y. É por isso que a aplicação parcial funciona naturalmente.
-- this signature:
max :: Int -> Int -> Int
-- is actually: Int -> (Int -> Int)
-- max takes an Int and returns a function
-- step by step
> :t max 5
max 5 :: Int -> Int
> (max 5) 10
10
-- application is left-associative
> max 5 10 == ((max 5) 10)
TrueFunções que retornam funções
Funções podem retornar outras funções, surgindo naturalmente do currying. Isso habilita fábricas de funções: multiplyBy 2 cria uma função de dobrar. Aplicação parcial como greet "Hi" configura uma função para uso posterior.
-- return a function
multiplyBy :: Int -> (Int -> Int)
multiplyBy n = \x -> n * x
-- or equivalently (currying)
multiplyBy' n x = n * x
> let double = multiplyBy 2
> double 21
42
-- configure a function via partial application
greet :: String -> String -> String
greet greeting name = greeting ++ ", " ++ name
sayHi = greet "Hi" -- a configured greeterCurrying
Aplicação Parcial
Todas as funções são automaticamente curried
-- Eq: equality
> 5 == 5
True
> "a" /= "b"
True
-- Ord: ordering
> 3 < 5
True
> compare 3 5
LT
-- Show: convert to a string
> show 5
"5"
> show [1,2,3]
"[1,2,3]"
-- Read: parse from a string
> read "5" + 2
7Aplicação Parcial Infixa
Aplicação parcial de operadores
-- '=>' constrains the type variables
(==) :: Eq a => a -> a -> Bool
(<) :: Ord a => a -> a -> Bool
show :: Show a => a -> String
-- a function requiring Eq
elem :: Eq a => a -> [a] -> Bool
elem _ [] = False
elem x (y:ys) = x == y || elem x ys
-- multiple constraints
showMax :: (Ord a, Show a) => [a] -> String
showMax xs = show (maximum xs)Função flip
flip troca a ordem dos argumentos
-- declare a typeclass with method signatures
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
-- default implementations
x == y = not (x /= y)
x /= y = not (x == y)
-- minimal: define either (==) or (/=)Declarações de instância
instance Typeclass Type where implementa uma typeclass para um tipo. Cada função deve ser definido, a menos que exista um padrão. Depois disso, valores TrafficLight podem usar ==, /= e show.
data TrafficLight = Red | Yellow | Green
instance Eq TrafficLight where
Red == Red = True
Yellow == Yellow = True
Green == Green = True
_ == _ = False
instance Show TrafficLight where
show Red = "Red light"
show Yellow = "Yellow light"
show Green = "Green light"Typeclasses numéricas
A hierarquia numérica inclui Num (os números), Fractional (suporta /) e Integral (suporta div, mod). Int e Double são tipos diferentes — use fromIntegral para converter entre eles com segurança.
-- Num: basic numeric operations
(+) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
-- Fractional: supports division
(/) :: Fractional a => a -> a -> a
-- Integral: integer division
div, mod :: Integral a => a -> a -> a
-- convert between numeric types
> fromIntegral (length [1,2,3]) + 0.5
3.5Deriving
Muitas typeclasses podem ser derivadas automaticamente: Eq, Ord, Show, Read, Enum, Bounded. Isso evita escrever instâncias repetitivas. Enum e Bounded habilitam a sintaxe de faixa ([Red ..]) e minBound/maxBound.
-- automatically derive common typeclasses
data Color = Red | Green | Blue
deriving (Eq, Ord, Show, Read, Enum, Bounded)
> show Red
"Red"
> Red < Green
True
> minBound :: Color
Red
> [Red ..]
[Red,Green,Blue]Composição
Composição de Funções
. compõe da direita para a esquerda
-- sum type: alternatives separated by '|'
data Bool' = False' | True'
-- pattern match on constructors
not' :: Bool' -> Bool'
not' True' = False'
not' False' = True'
-- value constructors with no fields
data Weekday = Mon | Tue | Wed | Thu | FriComposição de Múltiplas Funções
Compor em cadeia múltiplas funções
-- product type: constructors carry fields
data Point = Point Double Double
data Shape
= Circle Double -- radius
| Rect Double Double -- width, height
-- construct values
p = Point 1.0 2.0
c = Circle 5.0
r = Rect 3.0 4.0Estilo Point-free
Omitir argumentos, mais conciso
-- a type parameter 'a' (like Maybe)
data Maybe' a = Nothing' | Just' a
-- a boxed value
data Box a = Box a
-- use it with any type
> Just' 5
Just' 5
> Box "hello"
Box "hello"
-- model failure with Maybe
divide :: Double -> Double -> Maybe' Double
divide _ 0 = Nothing'
divide x y = Just' (x/y)Tipos recursivos
Um tipo pode se referir a si mesmo, formando estruturas recursivas. IntList é uma lista encadeada de Ints. Tree a é uma árvore binária. O pattern matching recursa naturalmente sobre tais estruturas.
-- a custom linked list
data IntList = INil | ICons Int IntList
-- build the list 1,2,3
xs = ICons 1 (ICons 2 (ICons 3 INil))
-- a binary tree
data Tree a = Leaf | Node a (Tree a) (Tree a)
tree = Node 1 (Node 2 Leaf Leaf) (Node 3 Leaf Leaf)Uma BST com funções
Tipos de dados algébricos se combinam naturalmente com funções recursivas via pattern matching. Esta implementação de BST insere mantendo a ordem, e a travessia inorder achata numa lista ordenada. ADTs mais recursão substituem classes na POO.
data Tree a = Leaf | Node a (Tree a) (Tree a)
-- insert into a binary search tree
insert :: Ord a => a -> Tree a -> Tree a
insert x Leaf = Node x Leaf Leaf
insert x (Node y l r)
| x < y = Node y (insert x l) r
| otherwise = Node y l (insert x r)
-- inorder traversal yields a sorted list
inorder :: Tree a -> [a]
inorder Leaf = []
inorder (Node x l r) = inorder l ++ [x] ++ inorder rEnumerações
Um sum type de construtores sem campos funciona como um enum. Deriving Enum habilita succ/pred e a sintaxe de faixa ([North ..]); deriving Bounded dá minBound/maxBound. Esta é a enumeração idiomática de Haskell.
-- enum-like sum type
data Direction = North | East | South | West
deriving (Eq, Ord, Enum, Bounded, Show)
-- enumerate via Enum
> [North .. West]
[North,East,South,West]
-- Bounded: the limits
> minBound :: Direction
North
> maxBound :: Direction
West
-- cycle through directions
next :: Direction -> Direction
next West = North
next d = succ dMonads
Monad Maybe
Maybe trata automaticamente a propagação de falhas
-- without records (positional, error-prone)
data Person0 = Person0 String Int String
-- with records (named fields)
data Person = Person
{ name :: String
, age :: Int
, city :: String
}
-- construct with field names (any order)
p1 = Person { name = "Alice", age = 30, city = "NYC" }Monad List
Monad List representa computação não determinística
-- field names are accessor functions
> name p1
"Alice"
> age p1
30
-- their types
> :t name
name :: Person -> String
> :t age
age :: Person -> Int
-- record patterns also work
greet :: Person -> String
greet (Person { name = n }) = "Hi, " ++ nMonad IO
Monad IO isola efeitos colaterais
-- functional update: change only some fields
p2 = p1 { age = 31 }
-- the original is unchanged (immutable)
> age p1
30
> age p2
31
-- update multiple fields at once
p3 = p1 { age = 31, city = "LA" }Operador bind
>>= é a operação central do Monad
-- match and bind fields by name
birthday :: Person -> Person
birthday p@Person { age = a } = p { age = a + 1 }
-- ignore unneeded fields
getName :: Person -> String
getName Person { name = n } = n
-- as-pattern keeps the whole record
isAdult :: Person -> Bool
isAdult p@Person { age = a } = a >= 18return
return coloca um valor em um contexto de Monad
-- field names share a top-level namespace
data Person = Person { name :: String }
data Company = Company { name :: String }
-- ERROR: 'name' clashes in the same module
-- workaround 1: prefix the fields
data Person' = Person' { personName :: String }
data Company' = Company' { companyName :: String }
-- workaround 2: language extensions
{-# LANGUAGE DuplicateRecordFields #-}Functors
fmap
fmap aplica uma função a um valor dentro de um Functor
-- file Geometry.hs
module Geometry
( sphereVolume -- explicit export list
, cubeVolume
) where
sphereVolume :: Float -> Float
sphereVolume r = (4/3) * pi * r^3
cubeVolume :: Float -> Float
cubeVolume s = s^3
-- a helper not in the export list is private
privateHelper = ...Operador <$>
<$> é equivalente a fmap
-- import everything from Data.List
import Data.List
-- names are now in scope
> sort [3,1,2]
[1,2,3]
> nub [1,1,2,2,3]
[1,2,3]
-- import specific functions
import Data.Maybe (fromMaybe)
-- qualified: use the full module name
import qualified Data.Map as M
> M.emptyFunctor de Função
fmap em funções é .
-- import only specific names
import Data.List (sort, nub, group)
-- import everything except some
import Data.List hiding (head, tail)
-- import a type without its constructors
import Data.Tree (Tree, Node)
-- import constructors too
import Data.Tree (Tree(..))Imports qualificados
Imports qualificados forçam o prefixo do módulo, prevenindo colisões (por exemplo, filter do Prelude vs o de Data.Map). import qualified M as M é o idiomático. Use qualified para módulos com muitos nomes sobrepostos.
-- avoid name clashes with qualified
import qualified Data.Map as Map
import qualified Data.Set as Set
m = Map.empty
s = Set.fromList [1,2,3]
-- Prelude's filter vs Data.Map's
> filter even [1..6]
[2,4,6]
> Map.filter (>2) (Map.fromList [(1,'a'),(3,'b')])
fromList [(3,'b')]Prelude
Prelude é o import padrão, fornecendo funções e tipos comuns. Oculte entradas para evitar colisões ou para usar alternativas melhores (por exemplo, foldl' de Data.List). Muitos projetos usam preludes personalizados.
-- Prelude is imported by default
-- provides: map, filter, length, (+), etc.
-- hide entries to avoid clashes
import Prelude hiding (head, tail, foldl)
-- use better alternatives
import Data.List (foldl') -- strict fold
-- common standard modules
import Data.List
import Data.Maybe
import Data.Char
import Data.EitherHierarquia de módulos
Nomes de módulos são hierárquicos e espelham a estrutura de diretórios: A.B.C vive em A/B/C.hs. Um módulo pode reexportar outro com 'module M' na sua lista de exportação, útil para empacotar uma API pública.
-- hierarchical names mirror directories
-- module Data.Geometry.Sphere where
-- lives in: Data/Geometry/Sphere.hs
-- import nested modules
import Data.Geometry.Sphere
import Data.Geometry.Cube
-- re-export a whole module
module MyMod
( module Data.List -- re-export
, myFunc
) where
import Data.List
myFunc = sortApplicatives
Operador <*>
<*> aplica uma função dentro de um Functor
-- IO actions produce effects when run
greet :: IO ()
greet = do
putStrLn "What's your name?"
name <- getLine
putStrLn ("Hello, " ++ name)
-- run in GHCi
> greet
What's your name?
Alice
Hello, AliceAplicação de Função Pura
pure coloca um valor em um Applicative
-- every program starts in main
main :: IO ()
main = putStrLn "Hello, World!"
-- combine actions with do
main = do
greet
putStrLn "Done."
-- command-line arguments
import System.Environment
main = do
args <- getArgs
print argsApplicative de Lista
List <*> é um produto cartesiano
-- do is sugar for sequential actions
echo = do
s <- getLine
putStrLn s
-- desugars to bind (>>=)
echo' = getLine >>= putStrLn
-- 'let' needs no 'in' inside do
greet = do
let msg = "Hi!"
putStrLn msgFunções de entrada
getLine lê uma linha (sem a quebra), getChar um único caractere, getContents lê o stdin lazily. Use '<-' para vincular resultados. getContents é lazy — ótimo para pipelines de streaming.
-- read a line (without the newline)
> line <- getLine
hello world
> line
"hello world"
-- read a single character
> c <- getChar
a> c
'a'
-- read all of stdin lazily
process = do
text <- getContents
putStr (map toUpper text)Funções de saída
putStrLn e putStr escrevem uma String no stdout, com/sem quebra de linha no fim. print equivale a putStrLn . show, então adiciona aspas em strings. Escolha conforme a necessidade de quebra de linha e se o valor é uma String.
-- with a trailing newline
putStrLn :: String -> IO ()
-- without a newline
putStr :: String -> IO ()
-- any Show-able value
print :: Show a => a -> IO ()
> putStrLn "hi" -- hi
> putStr "hi" -- hi (no newline)
> print 5 -- 5
> print "hi" -- "hi" (with quotes)IO de arquivos
readFile lê lazily, writeFile sobrescreve, appendFile acrescenta ao fim. Use bracket para garantir que recursos se fechem em exceções. Arquivos são endereçados por FilePath (um alias de String).
-- read a whole file (lazy)
readFile :: FilePath -> IO String
-- write a file (overwrites)
writeFile :: FilePath -> String -> IO ()
-- append to a file
appendFile :: FilePath -> String -> IO ()
main = do
contents <- readFile "input.txt"
writeFile "output.txt" (map toUpper contents)
-- safe resource handling
import Control.Exception (bracket)IO
IO Básico
Operações de IO estão no Monad IO
-- Functor: a context you can map over
class Functor f where
fmap :: (a -> b) -> f a -> f b
-- '<$>' is fmap as an operator
> fmap (+1) (Just 5)
Just 6
> (+1) <$> Just 5
Just 6
> (+1) <$> Nothing
Nothing
> map (+1) [1,2,3] -- map is fmap for lists
[2,3,4]Ler/Escrever Arquivos
readFile/writeFile manipulam arquivos
-- Applicative: functions inside a context
class Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
-- apply a wrapped function
> pure (+) <*> Just 3 <*> Just 4
Just 7
> Just (+1) <*> Just 5
Just 6
-- for lists, <*> is the Cartesian product
> [(+1), (*2)] <*> [1,2,3]
[2,3,4,2,4,6]putStr/putChar
Diferentes funções de saída
-- Monad: sequential, dependent computations
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b -- bind
-- bind chains dependent computations
> Just 3 >>= \x -> Just (x+1)
Just 4
> Nothing >>= \x -> Just (x+1)
Nothing
-- '>>' ignores the left result
> putStrLn "a" >> putStrLn "b"
a
bInteração
getLine lê uma linha de entrada
-- do notation
greet = do
name <- getLine
putStrLn ("Hi " ++ name)
-- desugars to bind
greet' = getLine >>= \name ->
putStrLn ("Hi " ++ name)
-- 'let' becomes a regular binding
compute = do
let x = 5
print (x * x)
-- desugars to:
compute' = let x = 5 in print (x*x)Cadeia da Monad Maybe
A Monad de Maybe faz curto-circuito: uma vez que um passo retorna Nothing, o cálculo inteiro é Nothing sem trabalho adicional. O do esconde a checagem manual de Nothing, tornando a propagação de falha automática e limpa.
-- short-circuit on Nothing
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)
-- chain with do (auto-propagates failure)
calc = do
a <- safeDiv 10 2
b <- safeDiv a 2
return (b + 1)
> calc
Just 3.5
-- any Nothing stops the whole chain
> safeDiv 10 0 >>= \a -> safeDiv a 2
NothingMonad de lista
A monad de lista modela não-determinismo: cada bind explora todas as possibilidades, produzindo o produto cartesiano. do sobre listas equivale a list comprehensions. Isso unifica o estilo de comprehension e o monádico.
-- list bind = non-deterministic computation
> [1,2] >>= \x -> [x, x*10]
[1,10,2,20]
-- do over lists == list comprehension
pairs = do
x <- [1,2]
y <- ['a','b']
return (x, y)
> pairs
[(1,'a'),(1,'b'),(2,'a'),(2,'b')]
-- equivalent comprehension
> [(x,y) | x <- [1,2], y <- ['a','b']]Notação do
do Básico
açúcar sintático do simplifica operações com Monad
-- 'type' creates a synonym (not a new type)
type String = [Char]
type PhoneNumber = String
type Name = String
-- improves readability of signatures
printEntry :: Name -> PhoneNumber -> IO ()
printEntry name num = putStrLn (name ++ ": " ++ num)let em do
let em do não precisa de in
-- newtype: one constructor, one field, zero cost
newtype Dollars = Dollars Double
newtype Count = Count Int
-- pattern match or unwrap the field
addDollars :: Dollars -> Dollars -> Dollars
addDollars (Dollars a) (Dollars b) = Dollars (a + b)
-- distinct type: can't mix with raw Double
total :: Dollars
total = addDollars (Dollars 10) (Dollars 20)Desugaring do
do é açúcar sintático para >>=
-- type: just a synonym (no new type, no safety)
type Score = Int
-- newtype: distinct type, zero cost, one field
newtype Score' = Score' Int
-- data: full ADT, runtime cost,
-- can have multiple constructors/fields
data Score'' = Score'' Int | Bonus Int
-- newtype is strict: exactly one
-- constructor and one field, but a distinct typenewtype para novas instâncias
newtype permite anexar instâncias de typeclass diferentes ao mesmo tipo subjacente. Sum e Product embrulham o mesmo número, mas têm instâncias de Monoid diferentes (adição vs multiplicação). Um padrão comum e poderoso.
-- wrap to attach different typeclass instances
newtype Sum a = Sum { getSum :: a }
instance Num a => Monoid (Sum a) where
mempty = Sum 0
Sum a `mappend` Sum b = Sum (a + b)
newtype Product a = Product { getProduct :: a }
-- different Monoid: multiplication
-- same underlying type, different behavior
> getSum (Sum 3 <> Sum 4)
7
> getProduct (Product 3 <> Product 4)
12Sinônimos parametrizados
Sinônimos de tipo podem receber parâmetros, funcionando como abstrações leves. AssocList k v é [(k,v)], tornando assinaturas autoexplicativas. Use-os por clareza, mas lembre que são apenas aliases, sem segurança de tipos.
-- type synonyms can take parameters
type AssocList k v = [(k, v)]
-- used in signatures (self-documenting)
lookup :: Eq k => k -> AssocList k v -> Maybe v
lookup _ [] = Nothing
lookup k ((k',v):rest)
| k == k' = Just v
| otherwise = lookup k rest
-- more examples
type Parser a = String -> Maybe (a, String)
type Matrix a = [[a]]Snippets de Haskell relacionados
Copy-paste ready code for common tasks.
Tipos e Type Classes
Definir tipos de dados algébricos e type classes.
Mônadas Maybe e IO
Usar Maybe para segurança e IO para efeitos colaterais.
List Comprehensions e Preguiça
Gerar listas com comprehensions e aproveitar a preguiça.
Functors, Applicatives, Type Classes Monad
As três type classes de abstração central.
IO e do Notation
Programação com efeitos colaterais em Haskell.
Módulos e Imports
Organizar código com módulos e controlar exports.
Preguiça e Estriteza
Entender avaliação preguiçosa e quando ser estrito.
Applicative Functors
Aplicar funções em um contexto com menos poder que Monad.
Was this helpful?