Ну, это довольно сложно. Начнем с неоднозначной ошибки:
<interactive>:1:1:
Ambiguous type variable `b0' in the constraint:
(Arity b0) arising from a use of `arity'
Probable fix: add a type signature that fixes these type variable(s)
In the expression: arity foldr
In an equation for `it': it = arity foldr
Обычно, без перекрывающихся экземпляров, при попытке сопоставления типа с классом он сравнивает тип со всеми экземплярами этого класса. Если есть только одно совпадение, он будет использовать этот экземпляр. В противном случае вы либо получите ошибку отсутствия экземпляра (например, с show (*)), либо ошибку перекрывающихся экземпляров. Например, если вы удалите языковую функцию OverlappingInstances из вышеуказанной программы, вы получите эту ошибку с arity (&&):
<interactive>:1:1:
Overlapping instances for Arity (Bool -> Bool -> Bool)
arising from a use of `arity'
Matching instances:
instance Arity f => Arity (a -> f)
-- Defined at tmp/test.hs:9:10-36
instance Arity x -- Defined at tmp/test.hs:12:10-16
In the expression: arity (&&)
In an equation for `it': it = arity (&&)
Это соответствует Arity (a -> f), поскольку a может быть Bool, а f может быть Bool -> Bool. Это также соответствует Arity x, поскольку x может быть Bool -> Bool -> Bool.
С OverlappingInstances, когда сталкивается с ситуацией, когда два или более экземпляров могут совпадать, если есть наиболее конкретный, он будет выбран. Экземпляр X является более конкретным, чем экземпляр Y, если X может соответствовать Y, но не наоборот.
В этом случае (a -> f) соответствует x, но x не соответствует (a -> f) (например, x означает Int). Таким образом, Arity (a -> f) является более конкретным, чем Arity x, поэтому, если оба совпадения, будет выбран первый.
Используя эти правила, arity (&&) сначала будет соответствовать Arity ((->) a f), с a, равным Bool, и f, равным Bool -> Bool. В следующем матче a будет Bool и f будет bool. Наконец, он закончится совпадением Arity x, где x будет Bool.
Обратите внимание, с помощью вышеуказанной функции, (&&) результат - конкретный тип Bool. Что происходит, когда тип не конкретен? Например, давайте посмотрим на результат arity undefined. undefined имеет тип a, поэтому это не конкретный тип:
<interactive>:1:1:
Ambiguous type variable `f0' in the constraint:
(Arity f0) arising from a use of `arity'
Probable fix: add a type signature that fixes these type variable(s)
In the expression: arity undefined
In an equation for `it': it = arity undefined
Вы получаете ошибку переменной типа, такую же, как и для foldr. Почему это происходит? Это потому, что в зависимости от того, что a, потребуется другой экземпляр. Если a было Int, то экземпляр Arity x должен быть сопоставлен. Если a было Int -> Int, то экземпляр Arity ((->) a f) должен быть сопоставлен. Из-за этого ghc отказывается компилировать программу.
Если вы заметите тип foldr: foldr :: forall a b. (a -> b -> b) -> b -> [a] -> b, вы заметите ту же проблему: результат не является конкретной переменной.
Вот где приходит IncoherentInstances: с включенной функцией языка она проигнорирует вышеуказанную проблему и просто выберет экземпляр, который всегда будет соответствовать переменной. Например, с arity undefined, Arity x всегда будет соответствовать a, поэтому результат будет 0. Аналогичная вещь делается для foldr.
Теперь для второй проблемы, почему arity $ \x y -> 3 возвращает 0, когда IncoherentInstaces включено?
Это очень странное поведение. Следующий сеанс ghci покажет, насколько это странно:
*Main> let f a b = 3
*Main> arity f
2
*Main> arity (\a b -> 3)
0
Это заставляет меня думать, что в ghc есть ошибка, где \a b -> 3, как замечено IncoherentInstances, имеет тип x вместо a -> b -> Int. Я не могу придумать причину, по которой эти два выражения не должны быть абсолютно одинаковыми.