Disciplina de Fundamentos da Programação

Transcrição

1 Exercício Desao N o 2 O Y funciona! Disciplina de Fundamentos da Programação Nota: Este exercício foi desenvolvido para aqueles alunos que pretendem ir mais além. Não substitui de forma alguma os exercícios preparados para a cadeira. Não faz parte da avaliação. E caso o consiga resolver não pense que basta para passar à cadeira. Deverá ser realizado no seu tempo livre. Depois destes avisos, algo desanimadores, espero que continue com vontade de realizar o exercício. Posso dizer-lhe que depois de o realizar se sentirá muito melhor consigo mesmo porque pelo menos tenho a certeza que aprenderá alguma coisa... não será com certeza um dia perdido! Boa sorte! Qualquer esclarecimento, dúvida ou se pretender conrmar a sua solução contacte o Docente Eng o Paulo Jorge Matos pelo pocm@sat.inesc-id.pt. (Versão de 20 de Novembro de 2005). Contextualização Neste desao abordaremos um conceito conhecido como combinador Y. Para introduzir este conceito verique-se que o seguinte calcula, trivialmente, a função factorial: (dene factorial ( n (factorial (sub n)))))) Esta função calcula o factorial, correcto? Óptimo! Então suponha-se que deixamos de ter o (dene ). Surge um problema. Deixamos de poder referir-nos ao factorial no corpo do factorial. Então nesse caso retiramos a chamada recursiva. (dene factorial

2 ( n (naointeressa (sub n)))))) Mas surge um problema. O (dene ) não funciona! Então camos com algo assim: ( n (naointeressa (sub n))))) Assim a função deixou de ser recursiva. E pior, só funciona se lhe passarmos zero. Mas e então o que é que faz o naointeressa? Não interessa! Seja como for a nossa função não funciona para valores diferentes de zero. Se esta função só funciona para o zero, passa a ser chamada de factorial 0. E se quisermos calcular também o factorial de? ( n (factorial0 (sub n))))) Mas como o dene não funciona substituimos o factorial 0 pela sua denição. ( n ( ( n (naointeressa (sub n))))) (sub n))))) Ah, esta função já calcula o factorial de zero e o de. Mas não é suciente. Quero o de 2 também. 2

3 ( n ( ( n ( ( n (naointeressa (sub n))))) (sub n))))) (sub n))))) E se quiser agora o de 3 tenho de voltar a substituir a função que calcula um passo da recursão no naointeressa. Bom, isto não é muito agradável. Se pudesse denir uma função innita o problema estaria resolvido. Dado que não podemos teremos que resolver o problema de outra forma. Seja como for, olhando para a função actual que calcula o factorial 2 esta apresenta muitos padrões e repetições. Vamos abstrair... Voltemos ao factorial 0 ( n (factorial (sub n)))))) naointeressa) Tentemos denir factorial usando o mesmo estilo: ( n (factorial (sub n)))))) ( n (factorial (sub n)))))) 3

4 naointeressa)) E factorial 2 ( n (factorial (sub n)))))) ( n (factorial (sub n)))))) ( n (factorial (sub n)))))) naointeressa))) Mas anal estávamos a tentar abstrair mas acabamos com mais repetições. Para simpli- car esta função e remover as repetições de uma vez por todas criemos uma função que recebe o factorial e devolve uma função que se parece com o factorial. Chamemos-lhe cria-factorial porque é isso que ela faz, cria o procedimento factorial. Então usaremos este truque para criar o factorial 0. (cria-factorial naointeressa)) (lambda (factorial) ( n (factorial (sub n))))))) Então e o factorial (cria-factorial 4

5 (cria-factorial naointeressa))) (lambda (factorial) ( n (factorial (sub n))))))) E o factorial 2 (cria-factorial (cria-factorial (cria-factorial naointeressa)))) (lambda (factorial) ( n (factorial (sub n))))))) Bom, e agora camos com uma torre de cria-factorial. Não é agradável. Recursão é então uma torre innita de aplicações de cria-factorial. No entanto, não precisamos de uma torre innita. Para cada valor do factorial, utilizamos sempre um número nito de vezes de aplicações da função factorial, nunca sabemos à partida é de quantas precisamos. Podemos criar uma torre muito grande mas nunca será igual à função factorial a que estamos habituados pois existem sempre muitos valores para os quais não funciona. A partir do momento que tentamos aplicar a função naointeressa começamos a ter sarilhos, signicando isto que a torre não era grande o suciente para o valor de factorial que estamos a tentar calcular. Como podemos resolver este problema? Visto que não interessa a função que passamos para cria-factorial podemos passar-lhe o próprio cria-factorial. Ah, esta é a ideia certa! Estamos no bom caminho. E depois invocamos cria-factorial com naointeressa e o resultado disto em (sub n). Vejamos 5

6 ( n (cria-factorial (sub n))))))) Isto decerto que é factorial 0. Mas se aplicarmos cria-factorial uma vez mais obteremos factorial. ( n ((cria-factorial naointeressa) (sub n))))))) Se quisermos o factorial 2 podemos aplicar de novo o cria-factorial. Então e se continuarmos a passar o cria-factorial para si próprio? ( n ((cria-factorial cria-factorial) (sub n))))))) Este sim, este é o factorial. Acontece que já não tem aquela função que todos reconhecemos como sendo o factorial. Podemos extrair a auto-aplicação do cria-factorial e chamar-lhe factorial. Mas (cria-factorial cria-factorial) não é uma função, nem sequer é a função factorial porque devolve uma função. Mas não tem problema porque podemos criar um lambda à sua volta de modo a receber um número e a calcular o factorial desse número. ( n ((lambda (x) ((cria-factorial cria-factorial) x)) (sub n))))))) 6

7 Vamos retirar esta nova função para obter de volta a nossa função factorial. ( n (factorial (sub n)))))) (lambda (x) ((cria-factorial cria-factorial) x))))) Pensemos sobre isto. No fundo não zemos nada de mais. Apenas inserimos a aplicação...)) de uma nova função em que lhe passamos como argumento (lambda (x)...), ou seja, a nossa auto-aplicação do cria-factorial. Podemos então extrair agora a nossa função que se parece com o factorial e dar-lhe um nome dado que não depende em nada de cria-factorial. ((lambda (ft) (ft (lambda (x) ((cria-factorial cria-factorial) x)))))) (lambda (factorial) ( n (factorial (sub n))))))) Anal o que é que conseguimos obter? Conseguimos separar a função cria-factorial da função que calcula o factorial. Olhemos apenas para a função cria-factorial. (lambda (ft) 7

8 (ft (lambda (x) ((cria-factorial cria-factorial) x)))))) Esta função tem um nome??? SIM! É o combinador Y. Pelo menos assim é se o reescrevermos um pouco. (dene Y (lambda (ft) ((lambda (f ) (ft (lambda (x) ((f f ) x)))) (lambda (f ) (ft (lambda (x) ((f f ) x))))))) Então mas agora o (dene......) já funciona? Claro... Já sabemos o que é a recursão! E já sabemos o que é o Y! E já sabemos porque é que o Y funciona. Não sabem? Então leiam tudo de novo! E o (Y Y) também funciona! Já percebemos então como escrever uma função recursiva sem utilizar o dene. Passemos ao desao. 2. Desao O desao consiste em escrever um procedimento anónimo que resolva o problema das torres de Hanoi. É tudo! Divirta-se!!! Por uma questão de curiosidade, neste enunciado escrevi lambda 69 vezes... ou melhor, escrevi lambda 70 vezes... ou melhor, escrevi lambda 7 vezes... ou melhor, escrevi lambda 72 vezes... ou melhor, escrevi lambda 73 vezes... ou melhor, escrevi lambda 74 vezes... ou melhor, escrevi lambda 75 vezes... OK, JÁ SE PERCEBEU! 3. Referências A introdução para este desao é baseada no (Y Y) Works! por Matthias Felleisen e Daniel Friedman. Poderão ler também...and Again, and Again, and Again,... dos mesmos autores. outra leitura interesssnte é Y in Practical Programs (Extended Abstract) de Bruce McAdam. 8