Как Haskell выполняет сопоставление с образцом без определения Eq для наших типов данных?

Я определил двоичное дерево:

data Tree = Null | Node Tree Int Tree

и реализовал функцию, которая возвращает сумму значений всех его узлов:

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)

Оно работает, как ожидалось. У меня была идея также попытаться реализовать это с помощью охранников:

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)

но этот не работает, потому что я не реализовал Eq , я считаю:

 Нет экземпляра для (Eq Tree)
 возникает из-за использования `== 'на zzz3.hs: 13: 3-12
Возможное исправление: добавьте объявление экземпляра для (Eq Tree)
В первом аргументе `(&&) ', а именно` t1 == Null'
В выражении: t1 == Null && t2 == Null
В качестве охранника для
 определение sumOfValues2:
 t1 == Null && t2 == Null

Тогда возникает вопрос, как Haskell может выполнять сопоставление с образцом, не зная, когда переданный аргумент совпадает, не прибегая к уравнению ?

Править

Ваши аргументы кажутся вращаются вокруг того факта, что Haskell на самом деле сравнивает не аргументы функции, а вместо этого сравнивает «форму» и типы подписи, чтобы узнать, какой подфункции соответствовать. Но как насчет этого?

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

При запуске f 2 9 не придется ли использовать уравнение , чтобы узнать, какая из подфункций является правильной? Все они равны (в отличие от моего первоначального примера Tree, когда у нас было Tree / Node / Null). Или фактическое определение Int похоже на

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

?