Сложность оператора равенства F #

У меня вопрос об операторе по умолчанию « = » (равно) в F #. Это позволяет сравнивать пользовательские типы объединений. Возникает вопрос: в чем это сложность? Например, давайте рассмотрим следующий тип:

type Tree<'a> =
  | Nil
  | Leaf of 'a
  | Node of Tree<'a> * Tree<'a>

и следующие деревья:

let a : Tree<int> = Node (Node (Node (Leaf 1, Leaf 2), Node (Leaf 3, Node (Leaf 4, Leaf 5))), Node (Leaf 6, Nil))
let b : Tree<int> = Node (Node (Node (Leaf 1, Leaf 2), Node (Leaf 3, Node (Leaf 4, Leaf 5))), Node (Leaf 6, Nil))
let c : Tree<int> = Node (Node (Node (Leaf 1, Leaf 2), Nil), Node (Node (Leaf 3, Node (Leaf 4, Leaf 5)), Leaf 6))

Очевидно, что этот код:

printfn "a = b: %b" (a = b)
printfn "a = c: %b" (a = c)
printfn "a = a: %b" (a = a)

дает следующий результат:

a = b: true
a = c: false
a = a: true

Я ожидаю, что « a = b » а сравнение " a = c " занимает линейное время. Но как насчет " a = a "? Если он постоянен, как насчет более сложных структур, таких как эта:

let d : Tree<int> = Node (a, c)
let e : Tree<int> = Node (a, c)

Пройдет ли он через всю структуру d и e или остановится на " a = a "и" c = c "?