Haskell :: Funções como valores
George Darmiton da Cunha Cavalcanti
(gdcc@cin.ufpe.br)
Monitores:
Bruno Barros (blbs @ cin.ufpe.br)
Glerter Sabiá (gas2 @ cin.ufpe.br)
Thiago Lacerda (tbl2 @ cin.ufpe.br)
Composição de funções
 Estruturar programas compondo funções
type Word = String
type Line = [Word]
fill :: String -> [Line]
fill st = splitLines (splitWords st)
splitWords :: String -> [Word]
splitLines :: [Word] -> [Line]
fill = splitLines . splitWords
A função de composição
 (f . g) x = f (g x)
f . g
t
v
u
g
f
g >.> f
A função de composição
(.) :: (u -> v) -> (t -> u) -> (t -> v)
(.) f g x = f (g x)
 a composição é associativa
Composição para a frente
(>.>) :: (t -> u) -> (u -> v) -> (t -> v)
g >.> f = f . g
(g >.> f) x = (f . g) x = f (g x)
fill = splitWords >.> splitLines
Resultados
twice :: (t -> t) -> (t -> t)
twice f = f . f
(twice succ) 12
= (succ . succ) 12
= succ (succ 12)
= 14
Resultados
 Generalizar twice passando um argumento que diz o
número de vezes que a função-argumento será
composta com ela mesma:
iter :: Int -> (t -> t) -> (t -> t)
iter 0 f = id
iter n f = f >.> iter (n-1) f
Expressões que definem funções
listMult :: Int -> (Int -> [Int])
listMult n = f
where
f m = [m*1,m*2..,m*n]
 Notação Lambda
(\m -> 3+m)
addNum n = (\m -> [m*1,m*2..m*n])
comp2
x
y
f
g
g (f x) (f y)
f
\x y -> g (f x) (f y)
comp2 :: (t -> u) -> (u -> u -> v) ->
(t -> t -> v)
comp2 f g = (\x y -> g (f x) (f y))
Associatividade
 f a b = (f a) b
 f a b  f (a b)
 t -> u -> v = t -> (u -> v)
 t -> u -> v  (t -> u) -> v
 g :: (Int -> Int) -> Int
g h = h 0 + h 1
Currying (currificação)
curry :: ((t,u) -> v) -> (t -> u -> v)
curry g a b = g (a,b)
uncurry :: (t -> u -> v) -> ((t,u) -> v)
uncurry f (a,b) = f a b
flip :: (t -> u -> v) -> (u -> t -> v)
flip f b a = f a b
Haskell :: Um Interpretador para Exp1
George Darmiton da Cunha Cavalcanti
(gdcc@cin.ufpe.br)
Monitores:
Bruno Barros (blbs @ cin.ufpe.br)
Glerter Sabiá (gas2 @ cin.ufpe.br)
Thiago Lacerda (tbl2 @ cin.ufpe.br)
Linguagem Exp1
 Inclui apenas valores constantes (literais) e
operações sobre valores
 Valores e operações sobre inteiros, booleanos e
string são admitidos
 Um programa é uma expressão
 Agrupa valores em tipos e uma verificação de
tipos pode ser implementada
Sintaxe Abstrata de Exp1
Programa ::= Expressao
Expressao ::= Valor
| ExpUnaria
| ExpBinaria
ExpUnaria ::= "-"
Expressao
| "not"
Expressao
| "length" Expressao
ExpBinaria ::=
Valor ::= ValorConcreto
ValorConcreto ::= ValorInteiro
| ValorBooleano
| ValorString
|
|
|
|
|
Expressao
Expressao
Expressao
Expressao
Expressao
Expressao
"+" Expressao
"-" Expressao
"and" Expressao
"or" Expressao
"==" Expressao
"++" Expressao
Programas de Exp1
 Programa 1
4
 Programa 2
4 + 5
 Programa 3
(5+(-2))-3
Sintaxe Abstrata de Exp1
data Programa = PROG Expressao
data Expressao = LIT Valor
-- ExpUnaria
| MINUS Expressao
| NOT Expressao
| LENGTH Expressao
-- ExpBinaria
| SOMA Expressao Expressao
| SUBTRACAO Expressao Expressao
| AND Expressao Expressao
| OR Expressao Expressao
| IGUAL Expressao Expressao
| CONCATENA Expressao Expressao
Exemplos de programas Exp1
p1 = PROG (LIT (V_INT 4))
p2 = PROG (SOMA (LIT (V_INT 4)) (LIT (V_INT 5)))
...
Entidades Semânticas
 Valores
data Valor = V_INT Int | V_BOOL Bool | V_STR String
instance Show Valor where
show (V_INT int) = (show int)
show (V_BOOL bool) = (show bool)
show (V_STR str) = (show str)
Função de Interpretação
interprete :: Programa -> String
interprete (PROG e) = show (eval e)
-- Funcao de Avaliacao de Expressoes
eval :: Expressao -> Valor
eval (LIT i) = i
eval (NOT e) = not (eval e)
eval (SOMA e1 e2) = (eval e1) + (eval e2)
...
Download

haskell-funcoes-como-valores