He definido un árbol binario:

data Tree = Null | Node Tree Int Tree

y he implementado una función que generará la suma de los valores de todos sus nodos:

sumOfValues :: Tree -> Int
sumOfValues Null = 0
sumOfValues (Node Null v Null) = v
sumOfValues (Node Null v t2) = v + (sumOfValues t2)
sumOfValues (Node t1 v Null) = v + (sumOfValues t1)
sumOfValues (Node t1 v t2) = v + (sumOfValues t1) + (sumOfValues t2)

Funciona como se esperaba. También tuve la idea de intentar implementarlo usando guardias:

sumOfValues2 :: Tree -> Int
sumOfValues2 Null = 0
sumOfValues2 (Node t1 v t2)
    | t1 == Null && t2 == Null  = v
    | t1 == Null            = v + (sumOfValues2 t2)
    |               t2 == Null  = v + (sumOfValues2 t1)
    |   otherwise       = v + (sumOfValues2 t1) + (sumOfValues2 t2)

pero este no funciona porque no lo he implementadoEq, Yo creo:

No instance for (Eq Tree)
  arising from a use of `==' at zzz3.hs:13:3-12
Possible fix: add an instance declaration for (Eq Tree)
In the first argument of `(&&)', namely `t1 == Null'
In the expression: t1 == Null && t2 == Null
In a stmt of a pattern guard for
             the definition of `sumOfValues2':
        t1 == Null && t2 == Null

La pregunta que debe hacerse, entonces, es cómo puede Haskell hacer una coincidencia de patrones sin saber cuándo coincide un argumento aprobado, sin recurrir aEq?

Editar

Sus argumentos parecen girar en torno al hecho de que Haskell no está comparando los argumentos de la función, sino la "forma" y los tipos de firma para saber qué subfunción debe coincidir. ¿Pero qué tal esto?

f :: Int -> Int -> Int
f 1 _ = 666
f 2 _ = 777
f _ 1 = 888
f _ _ = 999

Cuando se ejecutaf 2 9, no tendrá que usarEq saber cuál de las subfunciones es la correcta? Todos son iguales (contrario a mi ejemplo inicial de Tree cuando teníamos Tree / Node / Null). O es la definición real de unInt algo como

data Int = -2^32 | -109212 ... | 0 | ... +2^32 

?