Linguagem Funcional 2 Linguagem Funcional 2 LF 2

Linguagem Funcional 2

Linguagem Funcional 2 - LF 2 n n n Estende LF 1 com funções de alta ordem Uma função passa a ser um valor O contexto inclui um único componente: • mapeamento de identificadores em valores

Linguagem Funcional 2 - LF 2 n n Portanto, o resultado da avaliação de uma expressão pode ser uma função, uma função pode ser argumento de outra função, . . . Um programa é uma expressão

Dificuldades da LF 1 para LF 2 • Funções podem ser retornadas para um escopo mais externo [ver implementação de aplicação em LF 2] (let var x = 10, fun f a = a+x in f)(5) • • • f seria retornado como (fn a. a+x), mas quem é x no escopo externo? O valor da função deveria ser reduzido antes de ser retornado: (fn a. a+10) Redução – Aumenta a complexidade computacional da execução (visitar toda subexpressão). – Cuidado para não substituir identificadores redefinidos! Ex: (let var x = 10 in fn x. x+1)(5)

Dificuldades da LF 1 para LF 2 • Com funções recursivas é preciso um último cuidado. (let fun dec n = n+dec(n-1) in dec)(5) No caso acima o valor retornado na cláusula let é (fn n. n+dec(n-1)). Mas quem é dec no escopo externo? • • • Funções recursivas não podem ser indefinidamente reduzidas. Solução: – Adicionar o id para funções recursivas – Ela se autoadiciona no ambiente quando é aplicada a algum argumento [ver implementação de aplicação em LF 2]

Explorando conceitos na LF 2 O tipo função n Apesar de LF 2 não possuir tipos explícitos, adotamos a seguinte convenção quando for necessário explicitar o tipo de uma função: f: T 1 ->T 2 - indica que o argumento de f tem tipo T 1 e o resultado tem tipo T 2 f: (T 1 x. . . x Tn) -> T - indica que f possui n argumentos de tipos T 1, . . . , Tn, respectivamente, e resultado do tipo T n Observe que uma declaração da forma f: ((T 1 -> T 2) x T 3) -> T 4 indica que f tem 2 argumentos: uma função (T 1 -> T 2) e um outro do tipo T 3; O resultado de f é do tipo T 4

Explorando conceitos na LF 2 O tipo função n Como um outro exemplo, considere a declaração f: T 1 -> (T 2 -> T 3) n que indica que f tem 1 argumento (T 1) e produz como resultado uma função (T 2 -> T 3) Observe que esta flexibilidade é uma conseqüência de funções serem valores (cidadãs de primeira classe)!

Explorando conceitos na LF 2 Funções como parâmetros de funções n Vários exemplos apresentados em sala compara - compara dois elementos, fornecida uma ordem aplicação - aplica uma função dada a um argumento dado composição - aplica a composição de duas funções dadas a um argumento dado

Explorando conceitos na LF 2 Funções como resultado n n A avaliação de uma função é o próprio texto da função: fn x. x + 1 é um programa (expressão) válido em LF 2 cuja avaliação retorna o próprio Várias versões da função composição apresentadas em sala: com dois, um e até zero argumentos

LF 2 permite currificação (Currying) n Considere as seguintes definições para min fun min x y = if (x <= y) then x else y fun min’ x = fn y. min (x, y) n Observe que min é sempre aplicada a dois argumentos e retorna o menor deles, enquanto min’ pode ser aplicada só a um argumento, retornando uma função que espera o outro argumento.

LF 2 permite currificação (Currying) n n Portanto, a expressão: min’(x) é válida, mas min(x) não. Note que (min’(x))(y) = min(x, y) Tipos: min : (int x int) -> int min´ : int -> (int -> int)

LF 2 permite currificação (Currying) n Um outro exemplo: fun add x = fn y. (x + y) n n n Qual o tipo de add O que as funções add 0 e add 1 computam? Mais exemplos: • As diversas versões de composição apresentadas em sala

Polimorfismo n n Por não ter tipos explícitos, funções em LF 2 podem apresentar comportamento polimórfico Por exemplo, a declaração • Let fun Id x = x in. . . n Permite que Id seja aplicada a qualquer argumento (de qualquer tipo) Mas cuidado! LF 2 não é de fato polimórfica; como não há verificação de tipos, certas aplicações podem causar erro em tempo de execução

Prova e Transformação de Programas n n n Computação em LF 2 (e em programação funcional em geral) é baseada em reescrita de termos A computação (avaliação) de uma expressão e resultar em um valor v é também a prova da equação e = v Portanto, além de ser um mecanismo de computação, reescrita é um método de dedução (largamente difundido)

Reescrita e Lógica Equacional n n n Teoria com igualdade que permite a substituição do lado esquerdo pelo lado direito de uma equação, e vice-versa. Igualdade é uma relação de ordem: reflexiva, simétrica e transitiva Uma propriedade fundamental: substitutividade: " f: T 1 T 2; x, y: T 1 (x = y) (f x = f y)

Mais sobre reescrita e lógica equacional n Igualdade entre funções é definida por extensionalidade (f = g) dom f = dom g x : dom f f(x) = g(x)

Prova envolvendo funções não recursivas n n n Um exemplo simples usando apenas substituição Considere as funções: Suc x = x + 1 Pred x = x – 1 Id x = x Provar que a composição de Suc e Pred equivale a Id

Provas envolvendo funções recursivas n n Prova por indução. A prova de que uma função recursiva satisfaz uma propriedade n : P(n) é feita por indução Caso base (0). Provar P(0) Caso indutivo (n+1). Provar P(n+1) assumindo P(n), ou seja: P(n) P(n+1)

Exemplo 1 n Considere a função exp(x, 0) = 1 (1) exp(x, n+1) = x * exp(x, n) (2) Provar: exp(x, m+n) = exp(x, m) * exp(x, n) Caso (0). Caso (n+1), assumindo que vale para n.

Exemplo 2 n Considere a função a seguir, para x e y naturais prod(0, y) = 0 (1) prod(x, y) = y + prod(x-1, y) (2) Provar: (A) prod(x, 0) = 0 (B) prod(y, x+1) = y + prod(y, x) (C) prod(x, y) = prod(y, x)

Prova Exemplo 2 (B) n Considere a função a seguir, para x e y naturais prod(0, y) = 0 (1) prod(x, y) = y + prod(x-1, y) (2) Provar: (B) prod(y, x+1) = y + prod(y, x) (Y = 0). prod(0, x+1) = 0+ prod(0, x) (Y+1). prod(y+1, x+1) = y+1 + prod(y+1, x) prod(y+1, x+1) = x+1 + prod(y, x+1) (2) = x+1 + y + prod(y, x) H. I = y+1 + x + prod(y, x) Aritmética = y+1 + prod(y+1, x) (2)

Prova Exemplo 2 (C) n Considere a função a seguir, para x e y naturais prod(0, y) = 0 (1) prod(x, y) = y + prod(x-1, y) (2) Provar: (C) prod(x, y) = prod(y, x) (x = 0). prod(0, y) = 0 = prod(y, 0), por (A) (x+1). prod(x+1, y) = prod(y, x+1) prod(x+1, y) = y + prod(x, y) (2) = y + prod(y, x) H. I = prod(y, x+1) (B)

Explorando Conceitos Adicionais de Programação Funcional

Tipos estruturados de dados: Listas n Coleção de elementos onde • A ordem dos elementos é relevante • A repetição “ “ n Notação • • • n [] : [T] [1, 2, 3] : [int] [[1, 2], [3]] : [[int]] [suc, pred] : [int int] 1. . 5 : [int] Qual o tipo das listas acima

Construtor de listas - cons (: ) n n A notação [x 1, . . . , xn] é uma abreviação para x 1 : x 2 : . . . : xn : [] Exemplos 1 : [] = [1] 1 : 2 : [3, 4] = [1, 2, 3, 4] n n Qual o tipo de cons pode ser usado em casamento de padrão

Exemplos de funções sobre listas n n head e tail head(x : xs) = x tail(x : xs) = xs Concatenação [] ^^ ys = ys (x : xs) ^^ ys = x : (xs ^^ ys) Qual o tipo de ^^ Que propriedades ^^ satisfaz

Linguagem Funcional 3 – LF 3 n n n Implementa listas, mas não casamento de padrão head e tail em LF 3 são operadores prédefinidos e não requerem parênteses head xs tail xs Concatenação em LF 3 também é um operador pré-definido xs ^^ ys

Padrão recursivo: fold n fold op a [x 1, . . . , xn] = x 1 op. . . (xn-1 op (xn op a)) fold op a [] = a fold op a (x : xs) = x op (fold op a xs) Defina operações soma e produto de uma lista de elementos usando fold

Fold em LF 3 let fun fold op a xxs = if (xxs==[]) then a else (let var x = head xxs, var xs = tail op(x, fold(op, a, xs))) in … xxs in

Outros padrões recursivos map f [] =[] map f (x : xs) = f(x) : map(f, xs) filter p [] = [] filter p (x : xs) = x : filter(p, xs), if p(x) = filter(p, xs), otherwise n Alguns exemplos • map lengh [“PLP”, “ES”, “Redes”] • filter positivo [-5, 3, -2, 0, 4] onde positivo(x) = (x > 0)

Filter e Map em LF 3 let fun filter p xxs = if xxs == [] then [] else let var x = head xxs, var xs = tail (if p(x) then x : filter(p, xs) else filter(p, xs)) in. . . xxs in fun map f xxs = if (xxs==[])then [] else (let var x = head xxs, var xs = tail xxs in f(x) : map(op, xs))

Compreensão de Listas em LF 3 n Notação [exp qualificador, . . . , qualificador] Onde exp é uma expressão qualificador é um gerador da forma for x in lista O ultimo qualificador pode ser uma condição da forma if exp

Compreensão de Listas em LF 3 n [x+1 for x in 3. . 1 ] = [4, 3, 2] n [x+1 for x in 3. . 1 if x==1] = [2] n [[x, y] for x in 0. . 2, for y in 3. . 5 if x + y == 5] = [[0, 5], [1, 4], [2, 3]] n let fun id x = x in [ f(x) for x in 1. . 3, for f in [id]] = [1, 2, 3]

Compreensão de Listas n n Redefina as funções map e filter usando compreensão Defina quicksort usando compreensão; primeiro para uma lista de números e depois para listas de um tipo arbitrário, com uma relação de ordem

Compreensão de Listas n quicksort em LF 3 let fun quicksort op xs = if (xs ==[]) then [] else (quicksort(op, [k for k in tail(xs) if op(k, head(xs))])) ^^ ([head(xs)] ^^ (quicksort(op, [y for y in tail(xs) if (not op(y, head(xs)))]))) in let fun maior. Que x y = x > y in quicksort(maior. Que, [2, 1, 4, 3])

Mais sobre Programação Funcional Indução em Listas n n Uma prova indutiva de xs P(xs) é estabelecida provando-se: Caso []. P([]) Caso (x: xs) P(xs) P(x: xs) Exercício: provar associatividade de concatenação de listas • (xs ^^ ys) ^^ zs = xs ^^ (ys ^^ zs)

Leitura n Programming Language Design Concepts • Capítulo 2 (Seção 2. 4) • Capítulo 14 n Introduction to Functional Programming • Capítulos 3 e 5