Почему (-) не удается выполнить проверку типа, когда я помещаю двойную матрицу слева и двойную справа?

Question

Поскольку hmatrix предоставляет экземпляр Num для типов Matrix, я могу выразить поэлементное вычитание как:

m = (2><2)[1..] :: Double Matrix 
m' = m - 3 

Это прекрасно работает, так как 3 является Num, и результаты в матрице создается путем вычитания 3 из каждого элемент m.

Почему это также не работает:

m' = m - (3::Double) 

Ошибка я получаю:

Couldn't match expected type ‘Matrix Double’ 
      with actual type ‘Double’ 
In the second argument of ‘(-)’, namely ‘(3 :: Double)’ 
In the expression: m - (3 :: Double) 

Я ожидал, что компилятор, чтобы понять, что Double также Num. Почему это, похоже, не так?

Answer 1

Что происходит, когда вы делаете m - 3 с m :: Matrix Double является то, что 3 :: Matrix Double. Тот факт, что Matrix Double является экземпляром Num, означает, что компиляторы знают, как перевести литер 3. Однако, когда вы делаете m - (3 :: Double), вы получаете ошибку типа, потому что (-) :: (Num a) => a -> a -> a, поэтому тип вычитаемого элемента должен быть экземплярами Num и соответствовать. Следовательно, вы можете вычесть два Double s, два Matrix Double s, но не Matrix Double и Double.

В конце концов, это кажется мне довольно логичным, не имеет смысла вычитать матрицу и скаляр.

Answer 2

Это распространенное недоразумение людей, новых для стиля Haskell, связанных с перегрузкой на основе типов, особенно тех, кто используется для перегрузки на основе подкласса, используемой в популярных языках OO.

Оператор вычитания имеет тип Num a => a -> a -> a; поэтому он принимает два аргумента любого типа, который находится в классе классов Num. Это кажется нравится то, что происходит, когда вы делаете m - 3, так это то, что оператор вычитания принимает Matrix Double слева и некоторый простой числовой тип справа. Но это на самом деле неверно.

Когда типа подпись, как Num a => a -> a -> a использует тот же тип переменные несколько раз, вы можете выбрать любой тип вы любите (в зависимости от contstraints перед =>: Num a в данном случае), чтобы использовать для a, но он должен быть в точно такой же тип везде, что появляется a. Matrix Double -> Double -> ??? недействительный экземпляр типа Num a => a -> a -> a (и если бы это было так, как бы вы узнали, что он вернулся?).

Причина m - 3 работы является то, что из-за оба аргумента должны быть того же типа, и m определенно типа Matrix Double, компилятор видит, что 3 также должен быть типа Matrix Double. Поэтому вместо использования 3, появившегося в исходном тексте, чтобы построить Double (или Integer или один из многих других числовых типов), он использует исходный текст 3 для создания Matrix Double. Эффективно вывод типа изменил способ, которым компилятор читает текст исходного кода 3.

Но если вы используете m' = m - (3::Double) тогда вы не позволяя ему просто выяснить, какой тип 3 должны сделать использование оператора вычитания действительно, вы говорите это, что это 3 является конкретно Double. Нет никакого пути к тому, чтобы быть правдой (ваше утверждение :: Double и требование, чтобы оператор вычитания получал два аргумента одного и того же типа), поэтому вы получаете ошибку типа.