Перегрузка сигнатур функций Haskell

Специальный полиморфизм (и перегрузка имен) обеспечивается в Haskell классами типов:

class CanFindVal a where
          findVal :: [ValPair] -> a -> Double

instance CanFindVal Double where
     findVal xs d = ...

instance CanFindVal Int where
     findVal xs d = findVal xs (fromIntegral d :: Double)

Обратите внимание, что в этом случае, поскольку findVal «действительно» нуждается в Double, я бы всегда использовал двойное число, а когда мне нужно было передать ему целое число, просто использовал fromIntegral на месте вызова. Обычно вам нужны классы типов, когда на самом деле задействовано другое поведение или логика, а не беспорядочно.

Для поддержки как findVal :: [ValPair] -> Double -> Double, так и findVal :: [ValPair] -> Int -> Double требуется специальный полиморфизм (см. http://www.haskell.org/haskellwiki/Ad-hoc_polymorphism), что обычно опасно. Причина в том, что специальный полиморфизм позволяет изменять семантику с одним и тем же синтаксисом.

Haskell предпочитает так называемый параметрический полиморфизм. Вы видите это все время с сигнатурами типов, где у вас есть переменная типа.

Haskell поддерживает более безопасную версию специального полиморфизма через классы типов.

У вас есть три варианта.

1. Продолжите то, что вы делаете, с явным именем функции. Это разумно, это даже используется некоторыми библиотеками c, например opengl.
2. Используйте класс пользовательского типа. Это, вероятно, лучший способ, но он тяжелый и требует большого количества кода (по очень компактным стандартам haskell). Посмотрите на ответ sclv для кода.
3. Попробуйте использовать существующий класс типов и (если вы используете GHC) получите производительность со специализациями.

Так:

findVal :: Num a => [ValPair] -> a -> Double
{-# SPECIALISE findVal :: [ValPair] -> Int -> Double #-}
{-# SPECIALISE findVal :: [ValPair] -> Double -> Double #-}
findVal = ...

Haskell не поддерживает перегрузку в стиле C++ (ну, вроде как, с классами типов, но мы не используем их таким же образом). И да, есть некоторые драконы, связанные с его добавлением, в основном связанные с выводом типа (становится экспоненциальным временем или неразрешимым или что-то в этом роде). Однако увидеть такой «удобный» код довольно редко в Haskell. Какой из них, Int или Double? Поскольку ваш метод Int делегирует метод Double, я предполагаю, что Double является "правильным". Просто используйте тот. Из-за буквальной перегрузки вы все равно можете называть это так:

findVal whatever 42

И 42 будет рассматриваться как Double. Единственный случай, когда это нарушается, - это если вы где-то получили что-то, что фундаментально является Int, и вам нужно передать это как этот аргумент. Затем используйте fromIntegral. Но если вы стремитесь, чтобы ваш код везде использовал «правильный» тип, этот случай будет необычным (и когда вам все же придется конвертировать, на это стоит обратить внимание).

В этом случае, я думаю, легко написать функцию, которая обрабатывает как Int, так и Double для второго аргумента. Просто напишите findVal, чтобы он вызывал realToFrac во втором аргументе. Это преобразует Int в Double и просто оставит Double в покое. Затем позвольте компилятору вывести тип за вас, если вы ленивы.

Во многих других языках программирования вы можете объявлять (своего рода) функции, имеющие одно и то же имя, но разные другие вещи в их подписях, например, разные типы параметров. Это называется перегрузка и, безусловно, является наиболее популярным способом достижения специального полиморфизма.

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