Variaciones sobre un evaluador Objetivo: Mostrar cómo un estilo de programación monádica puede capturar similitudes entre distintas variaciones de un elemental evaluador de expresiones. Más importante, como permite que cada variación sea introducida sin cambiar la estructura básica del programa. Comenzaremos con un (muy) simple evaluador, al que luego le agregaremos: Manejo de errores Conteo de operaciones efectuadas Traza de ejecuciones.

El evaluador data Term = Con Int | Div Term Term eval :: Term Int eval (Con x) = x eval (Div t u) = (eval t) div (eval u) answer, wrong :: Term answer = Div (Div (Con 1972) (Con 2)) (Con 23) wrong = Div (Con 2) (Div (Con 1) (Con 0)) ? eval answer 42 ? eval wrong [BOOM!]

Excepciones Modificar al evaluador para que controle división por 0 y devuelva un mensaje apropiado. No queremos usar error (prolijidad, interacción, etc.) data Exc = Raise Exception | Return type Exception = String El tipo Exc representa computaciones de valores de tipo que pueden generar una excepción.

Evaluador con excepciones eval :: Term Exc Int eval (Con x) = Return x eval (Div t u) = h (eval t) where h (Raise e) = Raise e h (Return x) = h (eval u) where h (Raise e) = Raise e h (Return y) = if y = = 0 then Raise division by zero else Return (x div y)

Evaluador con excepciones (2) En cada llamada de eval la forma del resultado es inspeccionada. Si una excepción fue levantada, entonces sigue siendo levantada. Cómo desplegar excepciones: instance Show Show (Exc where show (Raise e) = exception: ++ e show (Return x) = value: ++ show x ? eval answer value: 42 ? eval wrong exception: division by zero

Estado Ahora queremos contar el número de divisiones efectuadas al evaluar una expresión. Se intoduce un componente adicional Estado: Un valor de tipo Int, inicializado en 0 e incrementado en 1 cada vez que ocurre una división. newtype St = MkSt (State (, State)) type State = Int apply :: St State (, State) apply (MkSt f) s = f s

Evaluador con estado eval :: Term St Int eval (Con x) = MkSt f where f s = (x,s) eval (Div t u) = MkSt f where f s = (x div y, s + 1) where (x, s) = apply (eval t) s (y, s) = apply (eval u) s En cada llamada del evaluador el transformador de estado es aplicado a un estado y devuelve un valor y el estado modificado. instance Show Show (St where show f = value: ++ show x ++, count: ++ show s where (x,s) = apply f 0

Salida Ahora se quiere desplegar una traza de los pasos de ejecución de la evaluación de una expresión. Para eso introduciremos un tipo que nos permite representar computaciones que generan output. newtype Out = MkOut (Output, type Output = String eval :: Term Out Int eval (Con x) = MkOut (line (Con x) x), x) eval (Div t u) = MkOut (ox ++ oy ++ line (Div t u) z, z) where MkOut (ox, x) = eval t MkOut (oy, y) = eval u z = x div y line :: Term Int Output line t x = term: ++ show t ++,yields ++ show x ++ \n

Salida (2) En cada llamada al evaluador las salidas son colectadas y ensambladas para formar la salida de la llamada principal. instance Show Show (Out where show (MkOut (ox,x)) = ox ++ value: ++ show x ? eval answer term: Con 1972, yields 1972 term: Con 2, yields 2 term: Div (Con 1972) (Con 2), yields 986 term: Con 23, yields 23 term: Div (Div (Con 1972) (Con 2)) (Con 23), yields 42 value: 42 Notar que la traza de ejecución puede ser fácilmente cambiada para que imprima en orden inverso.