Не удалось сопоставить ожидаемый тип с фактическим типом. Переменные типа неоднозначны

In

res :: Int
res = (2, 3) `vdot` (5, 5)

ничто не заставляет 2 и 3 быть Int или даже быть одного типа друг с другом. Таким образом, экземпляр Vector (a, a) может не применяться. Насколько известно GHC, вы можете захотеть написать еще один экземпляр Vector (Float, Double) с type Scalar (Float, Double) = Int и совершенно другой реализацией vdot, а res по-прежнему будет проверять тип. Следовательно, типы 2 и 3 неоднозначны, как сказал вам GHC.

Похоже, вы действительно хотите сказать: пара (a, b) может только быть экземпляром Vector, когда b имеет тот же тип, что и a (и затем использовать написанный вами экземпляр). Вы можете выразить это в GHC следующим образом:

instance (a ~ b, Num a) => Vector (a, b) where
  type Scalar (a,b) = a
  (a, b) `vplus` (c, d) = (a + c, b + d)
  (a, b) `vmult` m = (a * m, b * m)
  (a, b) `vdot`  (c, d) = a * c + b * d

a ~ b — это ограничение равенства, утверждающее, что два типа a и b одинаковы.

Теперь ваш пример res может работать правильно:

*Main> (2, 3) `vdot` (5, 5) :: Int
25

Вот рассуждение, которое означает, что типы больше не являются неоднозначными.

• vdot имеет тип Vector v => v -> v -> Scalar v. Итак, чтобы res набрала проверку, нам нужно найти v, чтобы (2, 3) :: v, (5, 5) :: v и Scalar v ~ Int.

• Но (2, 3) имеет тип формы (a, b) и есть экземпляр, голова которого имеет форму Vector (a, b). Итак, мы должны использовать этот экземпляр. (В вашей исходной программе мы не можем сделать этот шаг, потому что нет достаточно общего экземпляра.)

• Определение связанного типа этого экземпляра говорит нам, что Scalar (a, b) ~ a. Но мы знаем, что Scalar (a, b) должно было быть Int, поэтому у нас должно быть a ~ Int.

• Ограничения этого экземпляра говорят нам a ~ b и что должен быть экземпляр Num a. Значит, у нас тоже должно быть b ~ Int (и действительно Num Int имеет место).

• Итак, мы пришли к выводу, что 2 :: Int и 3 :: Int, а так как еще и (5, 5) :: v, то у нас есть еще и 5 :: Int и 5 :: Int.

• Теперь мы определили, какой класс типов использовать для каждого перегруженного имени в нашем выражении (2, 3, 5, 5 и vdot), так что двусмысленности нет, и мы наконец можем вычислить выражение.

Упростим дело:

class Vector v where
  type Scalar v :: *
  vdot  :: v -> v -> Scalar v
  ...    
instance Num a => Vector (a, a) where
  type Scalar (a,a) = a
  ...
res :: Int
res = (2, 3) `vdot` (5, 5)

Теперь у нас есть

vdot :: v     -> v  -> Scalar v
vdot    (2,3) (5,5)

поэтому двойное приложение должно иметь этот тип

(2,3) :: v
(5,5) :: v
res = vdot (2,3) (5,5) :: Scalar v

Расширение типа пар:

(2,3) :: (a1, a2) ~ v     for some a1, a2 in class Num
(5,5) :: (b1, b2) ~ v     for some b1, b2 in class Num
res = vdot (2,3) (5,5) :: Scalar v

По транзитивности (a1, a2) ~ (b1, b2), следовательно, a1 ~ b1 и a2 ~ b2.

(2,3) :: (a1, a2)         for some a1, a2 in class Num
(5,5) :: (a1, a2)
res = vdot (2,3) (5,5) :: Scalar (a1, a2)

Мы также знаем из аннотации, что

res :: Int

следовательно

Scalar (a1, a2) ~ Int

Но из этого невозможно узнать, что такое a1, a2. В конце концов, для этого можно использовать пользовательские типы:

data A1 = ...
data A2 = ...
instance Num A1 where ...
instance Num A2 where ...
instance Vector (A1, A2) where
   type Scalar (A1, A2) = Int  -- !!!!

Обратите внимание на последнее Int. Это вызывает оба

type Scalar (Int, Int) = Int
type Scalar (A1 , A2 ) = Int

что делает невозможным выбор типов a1, a2. Обычно это обозначается предложением «семейства типов не обязательно должны быть инъективными».

Также обратите внимание, что отсутствие instance Vector (A1, A2) в вашем коде не помогает. GHC должен скомпилировать ваш код, ожидая, что такой экземпляр будет объявлен позже, возможно, в других модулях (предположение об "открытом мире"). Это в значительной степени необходимо для обеспечения возможности отдельной компиляции.