Haskell Hero

Ya sabemos de las lecciones anteriores sobre tipos que un tipo es una caja de valores relacionados. Por ejemplo Integer es una caja que contiene todos números enteros.

¿Qué es el tipo de la función (==)? Puede comparar números enteros, así que podríamos decir que es de tipo Integer -> Integer -> Bool. Puede también comparar caracteres, así que podríamos decir que es de tipo Char -> Char -> Bool. En este momento nos acordamos de tipos polimórficos y decimos que la función es de tipo a -> a -> Bool. Sin embargo, esto significaría que esta función puede comparar también árboles binarios, lo que no es verdad.

¿Cómo hacer entonces la declaración de tipo de (==)? En este momento nos sirven clases de tipos.

La representación de la clase de tipo Eq

Esta es la caja Eg (de la palabra inglés equal) que contiene todos los tipos de valores que se pueden comparar por igualdad. El tipo de la función (==) será entonces el siguiente:

(==)  ::  Eq a  =>  a -> a -> Bool

¿Qué es el tipo de la función (+)? Puede sumar números enteros, puede sumar números decimales pero no puede sumar por ejemplo valores booleanos. Nos gustaría entonces expresar que puede sumar cualesquier valores numéricos. La caja de todos números se llama Num.

La representación de la clase de tipo Num

El tipo de la función (+) es entonces el siguiente:

(+)  ::  Num a  =>  a -> a -> a

Nos queda mencionar la caja Ord que contiene todo lo que se puede ordenar. En otras palabras, contiene todos los valores que se pueden comparar entre sí con operadores < y >.

Operadores < y > son entonces de tipo

(<)  ::  Ord a  =>  a -> a -> Bool

Ahora ya sabemos que hay funciones que toman como parámetro "cualquier cosa que se puede comparar por igualdad". Por ejemplo la función

zipWith (==)  ::  Eq a => [a] -> [a] -> [Bool]

data Nat  =  Zero  |  Succ Nat

zipWith  (==)  [Zero, Succ Zero]  [Zero, Succ (Succ Zero)]

~>*  [True, False]

¿Cuándo son iguales dos valores de tipo Nat?

• cuando son ambos Zero
• cuando el primer valor es Succ x, el segundo valor es Succ y y x es igual a y, lo que se comprueba de manera recursiva
• otros casos (Zero, Succ x o Succ x, Zero) no son iguales

Lo vamos a definir de esta manera. Primero hay que mencionar que hacemos. Insertamos el tipo Nat en la caja Eq, es decir, definimos una nueva instancia de la clase Eq.

instance Eq Nat

instance Eq Nat

  where Zero   == Zero    =  True
        Succ x == Succ y  =  x == y
        _      == _       =  False

Y ya está. Ahora podemos usar valores de tipo Nat siempre cuando se necesita un tipo de la clase Eq.

Si el tipo está en la clase de tipo Ord, la operación <= tiene que estar definida. La clase Num requiere más. Estas operaciones tienen que ser definidas para que un tipo pueda estar en la clase Num:

• (+) (la adición)
• (-) (la resta)
• (*) (la multiplicación)
• abs (el valor absoluto)
• fromInteger (la función que convierte un número entero en un número del tipo requerido)
• signum (la función en la que la expresión signum x se evalúa a 1 si x es un número positivo, a -1 si x es nu número negativo, y a 0 si x es cero)