Funções de ordem superior

Transcrição

1 Funções de ordem superior Pedro Kröger 5 de outubro de 26 1 Introdução Nós vimos que procedimentos são abstrações que descrevem operações compostas em números independentemente dos numeros particulares. Por exemplo, quando nós denimos cubo como: (defun cubo (x) (* x x x)) não estamos falando do cubo de algum número em particular mas sobre um método para obter o cubo de qualquer número. Naturalmente nós poderíamos nos virar sem denir esse procedimento, escrevendo expressões como (* 3 3 3) (* x x x) (* y y y) e nunca mencionar cubo explicitamente. Isso nos colocaria em uma desvantagem séria, nos forçando a sempre trabalhar no nível das operações primitivas da linguagem (multiplicação nesse caso) ao invés de trabalhar em termos de operações em um nível mais alto. Nossos programas poderia computar cubos, mas nossa linguagem não teria a habilidade de expressar o conceito de cubo. Uma das coisas que devemos demandar de uma linguagem de programação poderosa é a habilidade de construir abstrações através da designação de nomes a padrões comuns e então trabalhar em termos dessas abstrações diretamente. Ainda assim, mesmo em processamento numérico nós vamos estar severamente limitado na nossa habilidade de criar abstrações se nós nos restringirmos a procedimentos cujos parâmetros devem ser números. Frequentemente o mesmo padrão de programação será usado com um número diferente de procedimentos. Para expressar esses padrões como conceitos nós vamos precisar construir procedimentos que podem aceitar procedimentos como argumentos ou retornar procedimentos como valores. Procedimentos que manipulam procedimentos são chamados de procedimentos de ordem superior (high-order procedures). Essa seção mostra como procedimentos de ordem superior podem servir como mecanismos poderosos de abstração, aumentando o poder expressivo da nossa linguagem. 2 Procedimentos como argumentos b Considere as três funções a seguir. A primeira calcula a soma de inteiros de a a b, i (defun soma-inteiros (a b) (+ a (soma-integers (+ a 1) b)))) 1

2 b A segunda calcula a soma dos cubos dos inteiros em um ambito dado, i 3 : (+ (cubo a) (soma-cubos (+ a 1) b)))) A terceira calcula a soma da sequencia dos termos na série: b 1 Ou seja, i(i + 2) por4 (defun soma-pi (a b) (+ (/ 1. (* a (+ a 2))) (soma-pi (+ a 4) b)))) (defun <nome> (a b) (+ (<termo> a) (<nome> (<proximo> a) b)))) Isso se traduz no código abaixo: (+ (termo a) (soma termo (proximo a) proximo b)))) Observe que termo e proximo são chamadas a funções (sublinhados abaixo): (+ (termo a) (soma termo (proximo a) proximo b)))) termo é um procedimento que dado um índice, calcula o valor do termo para aquele índice. proximo é um procedimento que dado um índice vai produzir o próximo índice. Então eles devem ser precedidos por funcall: (+ (funcall termo a) (soma termo (funcall proximo a) proximo b)))) 2

3 Funcall é denido como (funcall <função> <argumentos>). Ele aplica a <função> aos <argumentos>. Com funcall dá para fazer coisas como: (funcall ' ) => 6 (funcall 'first '(1 2 3)) => 1 (funcall 'second '(1 2 3)) => 2 (funcall 'position 1 '( ) :start 1) => 4 Tendo denido soma e uma função inc que incrementa seu argumento por 1, podemos denir soma-cubos em termos de soma: (defun inc (n) (+ n 1)) (soma (function cubo) a (function inc) b)) Observe que dizemos explicitamente para soma que cubo e inc são funções. Common Lisp tem um açucar sintático para a notação <function foo> através do uso de #', como #'foo: (soma #'cubo a #'inc b)) Tendo denido soma-cubos, podemos usa-lo para computar a soma dos cubos dos inteiros de 1 a 1: (soma-cubos 1 1) => 325 Com a ajuda de uma função de indentidade para computar o termo, podemos denir soma-inteiros em termos de soma: (defun identidade (x) x) (defun soma-inteiros (a b) (soma #'identidade a #'inc b)) Então podemos somar os inteiros de 1 a 1: (soma-inteiros 1 1) => 55 Também podemos denir soma-pi da mesma maneira: (defun soma-pi (a b) (flet ((pi-termo (x) (/ 1. (* x (+ x 2)))) (pi-proximo (x) (+ x 4))) (soma #'pi-termo a #'pi-proximo b))) Observe o uso de flet para criar os procedimentos pi-termo e pi-proximo dentro de soma-pi. Usando esses procedimentos nós podemos calcular uma aproximação de π: 3

4 (* 8 (soma-pi 1 1)) => Uma vez que temos soma, nós podemos usa-lo como um bloco de básico para formular outros conceitos. Por exemplo, uma integral denida de uma função f entre os limites a e b pode ser aproximada numericamente usando a fórmula: ( ) ( ) ( ) ] a + dx 2 + f a + dx + dx 2 + f a + 2dx + dx 2 + dx para valores pequenos de dx. Nós podemos expressar isso diretamente como um procedimento: b a f = [ f (defun integral (f a b dx) (flet ((add-dx (x) (+ x dx))) (* (soma f (+ a (/ dx 2.)) #'add-dx b) dx))) (integral #'cubo 1.1) => Uma das vantagens de abstração é que pode mudar a implementação básica mas o uso é o mesmo. 4

5 3 Exemplos de funções de ordem superior (reduce #'+ '( )) (remove-if-not #'evenp '( )) (remove-if #'evenp '( )) (remove-if #'oddp '( )) (defun maior-que-5 (x) (if (<= x 5) x)) (remove-if #'maior-que-5 '( )) (remove-if #'(lambda (x) (if (<= x 5) x)) '( )) (defun dobro (x) (* x 2)) (mapcar #'dobro '( )) (mapcar #'(lambda (x) (* x 2)) '( )) 4 Licença Este trabalho está licenciado sob a Licença Creative Commons Atribuição-Uso Não-Comercial- Não a obras derivadas 2. Brasil. Você tem permissão para copiar e distribuir esse trabalho para ns não-comerciais contanto que dê crédito ao autor original e mantenha esse texto em distribuições ou cópias. 5