Есть ли хороший способ сделать сигнатуры функций более информативными в Haskell?

есть и другие варианты, в зависимости от того, как глупо и/или педантичный вы хотите сделать с вашими типами.

например,может сделать это...

type Meaning a b = a

bmiTell :: (RealFloat a) => a `Meaning` weight -> a `Meaning` height -> String  
bmiTell weight height = -- etc.

...но это невероятно глупо, потенциально запутанно и не помогает в большинстве случаев. То же самое касается и этого, что дополнительно требует использования языковых расширений:

bmiTell :: (RealFloat weight, RealFloat height, weight ~ height) 
        => weight -> height -> String  
bmiTell weight height = -- etc.

чуть более разумным было бы следующее:

type Weight a = a
type Height a = a

bmiTell :: (RealFloat a) => Weight a -> Height a -> String  
bmiTell weight height = -- etc.

...но это все равно глупо и имеет тенденцию теряться, когда GHC расширяет синонимы типов.

один из вариантов, конечно, состоит в том, чтобы просто иметь дело с неинформативными переменными типа. Но это не очень удовлетворительно, если есть существенное различие между двумя вещами одного и того же типа, которое не очевидно из того порядка, в котором они отданы.

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

newtype Weight a = Weight { getWeight :: a }
newtype Height a = Height { getHeight :: a }

bmiTell :: (RealFloat a) => Weight a -> Height a -> String  
bmiTell (Weight weight) (Height height)

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

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

bmiTell :: (RealFloat a) => a      -- ^ your weight
                         -> a      -- ^ your height
                         -> String -- ^ what I'd think about that

так что это не просто клякса текста, объясняющая все вещи.

причина, по которой ваши милые переменные типа не работают, заключается в том, что ваша функция:

(RealFloat a) => a -> a -> String

но ваша попытка изменить:

(RealFloat weight, RealFloat height) => weight -> height -> String

эквивалентно этому:

(RealFloat a, RealFloat b) => a -> b -> String

так, в сигнатуре этого типа вы сказали, что первые два аргумента имеют разные типы, но GHC определил, что (на основе вашего использования) они должны иметь то же самое тип. Поэтому он жалуется, что не может определить, что weight и height являются одним и тем же типом, даже если они должны быть (то есть ваша предлагаемая подпись типа недостаточно строга и допускает недопустимое использование функции).

weight должен быть того же типа, что и height потому что вы разделяете их (без неявных приведений). weight ~ height означает, что они одного типа. ghc немного объяснил, как он пришел к выводу, что weight ~ height надо было, к сожалению. Вы можете сказать ему, что он / вы хотели использовать синтаксис из расширения семейства типов:

{-# LANGUAGE TypeFamilies #-}
bmiTell :: (RealFloat weight, RealFloat height,weight~height) => weight -> height -> String
bmiTell weight height  
  | weight / height ^ 2 <= 18.5 = "You're underweight, you emo, you!"  
  | weight / height ^ 2 <= 25.0 = "You're supposedly normal. Pffft, I bet you're ugly!"  
  | weight / height ^ 2 <= 30.0 = "You're fat! Lose some weight, fatty!"  
  | otherwise                   = "You're a whale, congratulations!"

однако, это тоже не идеально. Вы должны иметь в виду, что Haskell использует очень действительно другая парадигма, и вы должны быть осторожны, чтобы не оказаться предполагая, что то, что было важно на другом языке важно здесь. Вы учитесь больше всего, когда находитесь вне своей зоны комфорта. Это похоже на то, что кто-то из Лондона появляется в Торонто и жалуется, что город сбивает с толку, потому что все улицы одинаковы, в то время как кто-то из Торонто может утверждать, что Лондон сбивает с толку, потому что на улицах нет регулярности. Что ты называешь запутывания называется ясности Haskellers.

если вы хотите вернуться к более объектно-ориентированной ясности цели, а затем заставить bmiTell работать только на людей, поэтому

data Person = Person {name :: String, weight :: Float, height :: Float}
bmiOffence :: Person -> String
bmiOffence p
  | weight p / height p ^ 2 <= 18.5 = "You're underweight, you emo, you!"  
  | weight p / height p ^ 2 <= 25.0 = "You're supposedly normal. Pffft, I bet you're ugly!"  
  | weight p / height p ^ 2 <= 30.0 = "You're fat! Lose some weight, fatty!"  
  | otherwise                   = "You're a whale, congratulations!"

это, я полагаю, тот способ, которым вы бы прояснили это в ООП. Я действительно не верю, что вы используете тип своих аргументов метода ООП для получения этой информации, вы должны тайно использовать имена параметров для ясности, а не типы, и вряд ли справедливо ожидать, что Хаскелл скажет вам имена параметров, когда вы исключили чтение имена параметров в вашем вопросе.[см. * ниже] система типов в Haskell удивительно гибкая и очень мощная, пожалуйста, не отказывайтесь от нее только потому, что она изначально отчуждает вас.

если вы действительно хотите, типа, чтобы сказать вам, мы можем сделать это для вас:

type Weight = Float -- a type synonym - Float and Weight are exactly the same type, but human-readably different
type Height = Float

bmiClear :: Weight -> Height -> String
....

это подход, используемый со строками, которые представляют имена файлов, поэтому мы определяем

type FilePath = String
writeFile :: FilePath -> String -> IO ()  -- take the path, the contents, and make an IO operation

что дает ясность вы были после. Однако он чувствовал, что

type FilePath = String

не хватает безопасности типа, а то

newtype FilePath = FilePath String

или что-то еще умнее было бы намного лучше Идея. См. ответ Бена для очень важного пункта о безопасности типа.

[*] хорошо, вы можете сделать :t в ghci и получить подпись типа без имени параметра, но ghci предназначен для интерактивной разработки исходного кода. Ваша библиотека или модуль не должны оставаться недокументированными и взломанными, вы должны использовать невероятно легкий синтаксис пикши документирование системы и установка пикши локально. Более законной версией вашей жалобы было бы то, что нет команды a :v, которая печатает исходный код для вашей функции bmiTell. Метрики предполагают, что ваш код Haskell для той же проблемы будет короче в несколько раз (я нахожу около 10 в моем случае по сравнению с эквивалентным OO или не-OO императивным кодом), поэтому показ определения внутри gchi часто является разумным. Мы должны отправить запрос на функцию.

попробуйте это:

type Height a = a
type Weight a = a

bmiTell :: (RealFloat a) => Weight a -> Height a -> String

возможно, не имеет отношения к функции с двумя аргументами piffling,... Если у вас есть функция, которая принимает много и много аргументов, похожих типов или просто неясного порядка, возможно, стоит определить структуру данных, которая их представляет. Например,

data Body a = Body {weight, height :: a}

bmiTell :: (RealFloat a) => Body a -> String

теперь вы можете написать либо

bmiTell (Body {weight = 5, height = 2})

или

bmiTell (Body {height = 2, weight = 5})

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

наверное стоит для функций с большим количеством аргументов, хотя. Всего за два, я бы пошел со всеми остальными и просто newtype таким образом, подпись типа документирует правильный порядок параметров, и вы получаете ошибку времени компиляции, если вы их смешиваете.