Haskell: Arreglo posible: agregue (Eq a) al contexto de

Question

Soy algo nuevo para Haskell y estoy teniendo dificultades para entender qué está mal con mi código aquí.

Esto es lo que se supone que debo hacer:
Considere la siguiente definición de un árbol binario

data BinaryTree a = Empty | Node a (BinaryTree a) (BinaryTree a) 

Considere la función refleja que forma la imagen especular de un árbol binario el intercambio de izquierda y derecha hasta el fondo

reflect :: BinaryTree a -> BinaryTree a 
reflect Empty = Empty 
reflect (Node x l r) = Node x (reflect r) (reflect l) 

Escribe una función areMirrorImages que determina si dos árboles binarios t y u satisfacen t = reflect u. La función no debe construir árboles nuevos, por lo que no debe llamar a reflect o Node; aunque puede usar Node en patrones.

Esto es lo que he escrito:

areMirrorImages :: BinaryTree a -> BinaryTree a -> Bool 
areMirrorImages Empty Empty = True 
areMirrorImages (Node _ _ _) Empty = False 
areMirrorImages Empty (Node _ _ _) = False 
areMirrorImages (Node x l r) (Node y ll rr) 
    | x==y = ((areMirrorImages l rr) && (areMirrorImages r ll)) 
    | otherwise = False 

cuando intento ejecutarlo me sale el siguiente error en la línea 49:
No se pudo deducir (Eq a) a partir del contexto() gracias a la utilización de '=='
solución posible: añadir (Eq a) al contexto de la declaración de tipo de 'areMirrorImages'
En la expresión: x == y

I Estoy confundido sobre por qué estoy recibiendo este error e intenté encontrar soluciones en línea, pero no he encontrado nada hasta el momento. Gracias.

Answer 1

Por el momento, sus árboles binarios pueden contener cualquier tipo, incluso los tipos que no se pueden comparar con ==. Entonces, si llamaste al areMirrorImages en un árbol que contiene ese tipo ... ¿qué debería pasar?

Lo que hay que hacer es colocar una restricciónen la función areMirrorImages, de modo que sólo puede aceptar los árboles binarios que se pueda comparar el contenido de.

algo como lo siguiente:

areMirrorImages :: Eq a => BinaryTree a -> BinaryTree a -> Bool 

Answer 2

Así como una pequeña nota al margen: A menudo es una buena idea poner todos "juego" de los casos de una función en la parte superior, ya que a menudo simplifica el "no que coinciden "unos:

areMirrorImages :: Eq a => BinaryTree a -> BinaryTree a -> Bool 
areMirrorImages Empty Empty = True 
areMirrorImages (Node x l r) (Node y ll rr) = 
    and [x==y, areMirrorImages l rr, areMirrorImages r ll] 
areMirrorImages _ _ = False