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 = Stringtype 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)

u vg f

g >.> f

t

f . g

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 twicetwice 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 :: Int -> (t -> t) -> (t -> t)

iter 0 f = iditer 0 f = id

iter n f = f >.> iter (n-1) fiter 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 :: (t -> u) -> (u -> u -> v) ->

(t -> t -> v)

comp2 f g = (\x y -> g (f x) (f y))

\x y -> g (f x) (f y)

y

f

f

g g (f x) (f y)

comp2x

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) -> Intg 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

Valor ::= ValorConcreto

ValorConcreto ::= ValorInteiro| ValorBooleano

| ValorString

ExpUnaria ::= "-" Expressao | "not"

Expressao | "length"

Expressao

ExpBinaria ::=

Expressao "+" Expressao| Expressao "-" Expressao| Expressao "and" Expressao| Expressao "or" Expressao| Expressao "==" Expressao| Expressao "++" Expressao

Programas de Exp1

Programa 14

Programa 24 + 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 -> Stringinterprete (PROG e) = show (eval e)

-- Funcao de Avaliacao de Expressoes

eval :: Expressao -> Valoreval (LIT i) = ieval (NOT e) = not (eval e)eval (SOMA e1 e2) = (eval e1) + (eval e2)...