Trabajo Práctico 1 - Programación Funcional Fecha de entrega: Jueves 20 de abril, hasta las 21 hs.

Transcripción

1 1. Introducción Trabajo Práctico 1 - Programación Funcional Fecha de entrega: Jueves 20 de abril, hasta las 21 hs. El presente trabajo tiene por objetivo estudiar el subconjunto de las funciones computables conocidas como funciones primitivas recursivas (FPR) desde la programación funcional. Para ello, definiremos dos presentaciones alternativas de las mismas, escribiremos funciones para operar sobre ellas y para relacionarlas. Si bien las FPR ya fueron estudiadas en la materia correlativa Lógica y Computabilidad, recordamos brevemente su definición. FPR es el conjunto inductivo de funciones de N n N cuyos esquemas son: Esquemas básicos: La función constante cero: cero(x) = 0. La función sucesor: sucesor(x) = x + 1. Para todo 1 i n, la función de proyección: proy n i (x 1... x n ) = x i. Esquemas inductivos: Si g 1,..., g m son FPR en n variables y si h es una FPR en m variables, entonces la función composición h (g 1,..., g m ) es FPR. Si g y h son FPR en n y n + 2 variables respectivamente, entonces la función f definida por recursión primitiva sobre g y h es FPR. f(x 1,..., x n, 0) = g(x 1,..., x n ) f(x 1,..., x n, y + 1) = h(x 1,..., x n, y, f(x 1,..., x n, y)) La primera de las dos presentaciones de las FPR, que llamaremos presentación nativa consiste en definirlas como funciones de tipo [Int] Int. La segunda, la presentación de datos, consiste en definirlas como un tipo de datos algebraico recursivo. 2. Presentación nativa En esta primera aproximación tomaremos las FPR como un subconjunto de las funciones numéricas, funciones con dominio en N n y codominio en N, para cualquier n. Usaremos el tipo básico de Haskell Int para representar los números naturales, y una lista para modelar la aridad n-aria, con n variable. type NumF = [Int] Int Es fácil escribir las funciones cero, sucesor y proy n i zero :: NumF zero = λ[x] 0 como funciones numéricas: successor :: NumF Página 1 de 9

2 successor = λ[x] x+1 proj :: Int Int NumF proj n m = λxs xs!! (m-1) Observar que en el caso de proj se asume que el tamaño de la lista que toma como argumento es correcto (i.e. que el tamaño de xs es n). Ejercicio 1: Completar la presentación nativa definiendo los esquemas inductivos Definir la función compose :: NumF [NumF] NumF, que representa el esquema inductivo de composición. compose successor [successor] [4] 6 compose successor [zero] [4] 1 compose (proj 3 1) [zero, successor, zero] [4] 0 compose (proj 3 2) [zero, successor, zero] [4] Definir la función primrec :: NumF NumF NumF, que representa el esquema inductivo de recursión primitiva. Puede usarse recursión explícita. primrec (proj 1 1) (proj 3 3) [4,11] 4 3. Presentación de datos En esta presentación definimos las FPR como un tipo algebraico recursivo. data PRF = Zero Succ Proj Int Int Comp PRF [PRF] PrimRec PRF PRF De esta forma, las expresiones que representan funciones primitivas recursivas son expresiones de tipo PRF, y como tales, a diferencia de la presentación nativa, no pueden ser aplicadas directamente a argumentos. Los siguientes son algunos ejemplos de expresiones que representan una función primitiva recursiva. idprf :: PRF idprf = Proj 1 1 plustwoprf :: PRF plustwoprf = Comp Succ [Succ] Ejercicio 2: Definir (por pattern matching) la función eval :: PRF NumF que toma un FPR en la representación de datos y devuelve una función en la representación nativa. Puede asumirse que las expresiones están bien formadas con respecto a la definición de la sección 1. Ejercicio 3: PRF. Representar las siguientes funciones primitivas recursivas como elementos de 3.1. cstprf :: Int PRF, que dado un número devuelve la función constante de un argumento que siempre devuelve ese valor. Se puede hacer recursión explícita sobre el número entero. eval (cstprf 5) [3] 5 Página 2 de 9

3 3.2. addprf :: PRF, que representa la función suma, de dos argumentos. eval addprf [4,8] predprf :: PRF, que representa la función predecesor. En este contexto, el predecesor de 0 se define como 0. Sugerencia: Usar funciones que se definen más adelante en este punto. eval predprf [3] subprf :: PRF que representa la función diferencia, de dos argumentos. eval subprf [8,4] 4 eval subprf [4,4] 0 eval subprf [4,8] mulprf :: PRF, que representa la función de multiplicación, de dos argumentos. eval mulprf [4,8] flipprf :: PRF PRF que toma una función binaria y devuelve una igual pero que toma los parámetros en orden inverso. eval (flipprf subprf) [4,8] sgprf :: PRF, de un argumento, que devuelve su signo. eval sgprf [4] 1 eval sgprf [8] 1 eval sgprf [0] changearityprf :: Int Int PRF PRF, que dada una función f, su aridad actual n y una aridad deseada m (n, m > 0), devuelve una función equivalente que tiene la aridad deseada. Si m > n, los nuevos argumentos se ignoran. Si m < n, la función f se llama con los n argumentos originales n 1,... n n y se rellena al principio con n 1 repetido m n veces. eval (changearityprf 1 4 Succ) [1,2,3,4] 2 eval (changearityprf 1 4 (cstprf 5)) [1,2,3,4] 5 eval (changearityprf 2 1 (Proj 2 2)) [20] 20 eval (changearityprf 3 2 (Proj 3 2)) [20, 30] ifthenelseprf :: Int PRF PRF PRF que toma un entero n y dos funciones g y h de n variables, y devuelve la función f definida como: Ejercicio 4: f(x 1... x n+1 ) = { g(x2... x n+1 ) si x 1 > 0 h(x 2... x n+1 ) si x 1 = 0 eval (ifthenelseprf 1 idprf Succ) [1,2] 2 eval (ifthenelseprf 1 idprf Succ) [0,2] Dar el tipo y definir foldprf, un esquema de recursión para el tipo de datos PRF Definir eval2, una redefinición de la función eval del ejercicio 2 usando el esquema de recursión. Página 3 de 9

4 Ejercicio 5: Definimos la aridad de los elementos de tipo PRF introducidos por el esquema básico de la siguiente manera: La aridad de Zero es 1. La aridad de Succ es 1. La aridad de Proj n m es n. No toda expresión de tipo PRF representa una FPR bien formada en términos de la definición de la sección 1, por ejemplo, las siguientes expresiones no representan ninguna FPR. Proj 3 6 Comp (Proj 2 1) [Zero] PrimRec (Proj 1 1) (Proj 1 1) Se pide definir una función arity :: PRF Maybe Int que computa la aridad de una expresión PRF cualquiera: si la misma está bien formada, devuelve Just n, donde n es su aridad; si no, devuelve Nothing. Esta función puede definirse con pattern matching. arity Zero Just 1 arity Succ Just 1 arity (Comp (Proj 2 1) [Proj 3 1, Proj 3 2]) Just 3 arity (Comp (Proj 2 1) [Proj 3 1, Proj 3 2, Proj 3 3]) Nothing arity (Comp (Proj 2 1) [Proj 3 1, Proj 4 2]) Nothing arity (Comp Zero [Proj 1 2]) Nothing arity addprf Just 2 arity predprf Just 1 arity (PrimRec idprf (Proj 4 2)) Nothing Sugerencia: Este ejercicio es una muy buena oportunidad para armar funciones de alto orden y reutilizar código! Vean el apéndice A para algunas sugerencias. Ejercicio 6: Considere las expresiones aritméticas con indeterminadas en {x 1,..., x n } representadas por el tipo algebraico data Exp = Cst Int Var Int Add Exp Exp Mul Exp Exp Cst i representa la constante numérica i, Var i representa la indeterminada x i con i n y Add e1 e2 y Mul e1 e2 representan la suma y multiplicación, respectivamente, de e1 y e2. Por ejemplo, la expresión 2 (x 1 + 4) se representa como Mul (Cst 2) (Add (Var 1) (Cst 4)) 6.1. Dar el tipo y definir una esquema de recursión sobre el tipo algebraico Exp 6.2. Usando el esquema del punto anterior, definir la función translate :: Exp PRF que traduce una expresión aritmética a una función primitiva recursiva usando la representación de datos. eval (translate (Var 3)) [1,2,3] 3 eval (translate (Add (Var 1) (Cst 2))) [3] 5 eval (translate (Add (Var 1) (Var 1))) [3] 6 eval (translate (Add (Var 1) (Var 2))) [3,4] 7 eval (translate (Mul (Cst 2) (Add (Var 1) (Cst 4)))) [3] 14 Página 4 de 9

5 Ejercicio 7: Algunas expresiones de tipo PRF pueden optimizarse en otras expresiones que representan la misma FPR pero tienen menos constructores: Comp Zero [f], si f es de aridad 1, representa la misma función que Zero. Comp (Proj n i) [f1,..., fn] representa la misma función que fi. PrimRec f (Proj n n), si f tiene aridad n 2, representa la misma función que f 1. Se pide definir una función optimize :: PRF PRF, que optimice la función recibida según estas dos reglas, tanto como sea posible. Puede usarse pattern matching, pero sólo para definir las reglas (no para la función principal que optimiza). optimize (Comp Zero [Proj 1 1]) Zero optimize (Comp Zero [Proj 2 1]) Comp Zero [Proj 2 1] optimize (Comp (Proj 3 1) [Zero, Succ, Succ]) Zero optimize (Comp (Comp (Proj 3 2) [Zero, Succ, Succ]) [Proj 2 2]) Comp Succ [Proj 2 2] optimize (PrimRec Succ (Proj 3 3)) Succ optimize (Comp (PrimRec Zero (Proj 3 3)) [Succ]) Zero optimize (Comp Succ [Comp Zero [Succ], PrimRec (Proj 2 2) (Proj 4 4)]) Comp Succ [Zero, Proj 2 2] 4. Y de yapa... Ejercicio 8: Definir la expresion mejuegopor :: Int, que devuelva un número primo. Este ejercicio no cambia la nota final del trabajo, pero habrá un premio para el grupo cuyo resultado sea el menor primo no devuelto por ningún otro grupo. 5. Pautas de entrega Se debe entregar el código impreso con la implementación de las funciones pedidas. Cada función debe contar con un comentario donde se explique su funcionamiento. Asimismo, se debe enviar un mail conteniendo el código fuente Haskell a la dirección ebonelli@dc.uba.ar. Dicho mail debe cumplir con el siguiente formato: El subject debe ser [PLP;TP-PF] seguido inmediatamente del nombre del grupo sin acentos. El cuerpo debe contener solamente el código Haskell. El mismo debe poder ejecutarse en Hugs. Importante: Se admitirá una única submisión, sin excepción alguna. Por favor planifiquen el trabajo para llegar a tiempo con la entrega. Tener especialmente en cuenta que los objetivos a evaluar en la implementación de las funciones son: 1 En este caso cambia la aridad entre la función original y la optimizada, pero en el contexto de este ejercicio no es importante. Página 5 de 9

6 Correctitud. Declaratividad. Reuso de funciones previamente definidas. Uso de funciones de alto orden, currificación y listas por comprensión. Uso de esquemas de recursión en lugar de recursión explícita y pattern matching, salvo aclaración en contrario. Junto con este enunciado, está disponible un módulo de Hugs donde se definen los tipos de datos básicos (NumF, PRF, Exp, etc.) y algunas funciones útiles para operar con ellos. Página 6 de 9

7 A. Algunas ideas para trabajar con Maybe El tipo Maybe es útil para expresar errores sin que la computación en sí misma los tenga (esto es, sin que se cuegue el programa). Supongamos una función para computar la división de dos números. dividir :: Float Float Maybe Float dividir n 0 = Nothing dividir n m = Just (n / m) Ahora bien, toda vez que aplicamos una operación de este estilo varias veces, el error puede ocurrir en más de un lugar. La intención es que el resultado final sea Nothing toda vez que cualquiera de las computaciones intermedias haya arrojado Nothing. Supongamos, por ejemplo, que queremos calcular la parte entera de la división entre dos números. parteenteradivision :: Float Float Maybe Int parteenteradivision x y = case dividir x y of Nothing Nothing Just x Just (floor x) Ahora queremos hacer una doble división : dados a, b, c y d, computar a/b c/d. dobledivision :: Float Float Float Float Maybe Float dobledivision a b c d = case dividir a b of Nothing Nothing Just div1 case dividir c d of Nothing Nothing Just div2 dividir div1 div2 Notemos como estamos repitiendo siempre el mismo patrón: hacemos la computación intermedia, si dio Nothing lo propagamos al resultado final, y si dio Just x aplicamos alguna función a x (que eventualmente también podría dar Nothing). Nos vendría bien una función que se encargue de hacer este trabajo! spread :: Maybe a (a Maybe b) Maybe b spread Nothing _ = Nothing spread (Just x) f = f x Entonces ahora: parteenteradivision x y = spread (dividir x y) (λdivision Just (floor division) ) dobledivision a b c d = spread (dividir a b) (λdivab spread (dividir c d) (λdivcd dividir divab divcd ) ) De esta forma prácticamente nos olvidamos de que estamos trabajando con posibilidad de errores! El código de arriba puede leerse como dividimos x por y y llamamos division al resultado; luego devolvemos la parte entera de division. El otro, como dividimos a por b y llamamos divab al resultado; luego dividimos c por d y llamamos divcd al resultado; Página 7 de 9

8 finalmente devolvemos la división entre divab y divcd. La función spread se encarga de propagar el error, sea donde sea que ocurra. También podemos aplicar esta idea cuando trabajamos con listas. Como vimos, la función foldr :: (a b b) b [a] b aplica recursivamente una función de tipo a b b a una lista de tipo [a] para obtener un b acumulado. Si ahora tenemos una función de tipo a b Maybe b y una lista [Maybe a], deberíamos poder obtener un Maybe b ( qué tipo tendría el caso base en esta función?). Podemos llamarla foldmaybe y definirla en términos de foldr y de spread; la función foldmaybe1 se define fácilmente a partir de foldmaybe. Nota: Estas ideas están inspiradas en un concepto mucho más general: las mónadas. Las mónadas son familias de tipos que cumplen ciertas propiedades y tienen ciertas operaciones. Su objetivo, intuitivamente, es permitir trabajar con efectos secundarios en un lenguaje funcional puro como Haskell. En particular, Maybe es una mónada, cuyo efecto secundario es la presencia de errores. Este tema está fuera del alcance de esta materia, pero acá van unas (pocas) referencias para quienes quieran saber algo más. Por supuesto, quien conozca la notación de mónadas puede usarla en lugar de la función spread en este trabajo. Philip Wadler, Monads for functional programming, University of Glasgow. Aspectos teóricos y prácticos de las mónadas explicados muy elegantemente. homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/marktoberdorf.pdf El capítulo de mónadas de A gentle introduction to Haskell. Tutorial completísimo. Mónadas en Wikipedia! en.wikipedia.org/wiki/monads in functional programming Página 8 de 9

9 B. Funciones del Preludio usadas en la solución de la cátedra Esta es la lista de funciones del preludio que la cátedra usó en su solución. Por supuesto, no es obligatorio usarlas y pueden aplicarse otras. Se trata sólo de darlas a conocer, ya que pueden resultar útiles, para que no tengan que programarlas en caso de necesitarlas. ($) :: (a b) a b (!!) :: [a] Int a (++) :: [a] [a] [a] foldr :: (a b b) b [a] b fromjust :: Maybe a a init :: [a] [a] last :: [a] a length :: [a] Int map :: (a b) [a] [b] null :: [a] Bool replicate :: Int a [a] La función fromjust no es del módulo Prelude sino de Maybe. Para usarla, hay que agregar la línea import Maybe al principio del código. Página 9 de 9