有没有一种很好的方法可以让函数签名在Haskell中提供更多信息？

Question

我意识到这可能被认为是一个主观或可能是一个非主题的问题,所以我希望它不会被关闭,而是会被迁移,也许是程序员.

我开始学习Haskell,主要是为了我自己的教化,我喜欢支持语言的很多想法和原则.在参加了我们玩Lisp的语言理论课之后,我对函数式语言着迷了,而且我听说过很多关于Haskell有多高效的好东西,所以我想我会自己调查一下.到目前为止,我喜欢这种语言,除了一件我无法摆脱的事情:那些母亲正在起作用的功能签名.

我的专业背景主要是做OO,特别是在Java中.我工作过的大多数地方都在许多标准的现代教条中受到重创; 敏捷,清洁代码,TDD等.经过几年的工作,它一定成为我的舒适区; 尤其是"好"代码应该是自我记录的想法.我已经习惯了在IDE中工作,其中具有非常描述性签名的冗长和详细的方法名称对于智能自动完成和用于导航包和符号的大量分析工具来说不是问题; 如果我可以在Eclipse中按Ctrl + Space,那么从查看其名称和与其参数关联的本地范围变量而不是拉起JavaDocs推断出方法正在做什么,我和大便中的猪一样高兴.

这显然不是Haskell社区最佳实践的一部分.我已经阅读了很多关于此事的不同意见,我理解Haskell社区认为其简洁性是"专业人士".我已经阅读了如何阅读Haskell,我理解了很多决策背后的理由,但这并不意味着我喜欢它们; 一个字母的变量名称等对我来说并不好玩.我承认,如果我想继续使用该语言,我将不得不习惯这一点.

但我无法克服功能签名.以这个例子为例,从学习Haskell [...]关于函数语法的部分开始:

bmiTell :: (RealFloat a) => a -> a -> 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!"

我知道这是只用于解释警卫和类约束的目的而创建一个愚蠢的例子,但如果你要检查只是该函数的签名,你根本不知道它的它的参数是意欲在重或高度.即使你使用Float或Double代替任何类型,它仍然不会立即可辨别.

起初,我认为我会很可爱,聪明又聪明,并尝试使用具有多个类约束的较长类型变量名来欺骗它:

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

这吐了一个错误(顺便说一句,如果有人能向我解释错误,我将不胜感激):

Could not deduce (height ~ weight)
    from the context (RealFloat weight, RealFloat height)
      bound by the type signature for
                 bmiTell :: (RealFloat weight, RealFloat height) =>
                            weight -> height -> String
      at example.hs:(25,1)-(27,27)
      `height' is a rigid type variable bound by
               the type signature for
                 bmiTell :: (RealFloat weight, RealFloat height) =>
                            weight -> height -> String
               at example.hs:25:1
      `weight' is a rigid type variable bound by
               the type signature for
                 bmiTell :: (RealFloat weight, RealFloat height) =>
                            weight -> height -> String
               at example.hs:25:1
    In the first argument of `(^)', namely `height'
    In the second argument of `(/)', namely `height ^ 2'
    In the first argument of `(<=)', namely `weight / height ^ 2'

不完全理解为什么不起作用,我开始谷歌搜索,我甚至发现这个小帖子建议命名参数,特别是欺骗命名参数通过newtype,但这似乎有点多.

有没有可接受的方法来制作信息功能签名？"哈斯克尔之路"只是对哈多克的一切废话吗？

Answer 1

类型签名不是Java样式的签名.Java样式的签名将告诉您哪个参数是权重,哪个是高度,因为它将参数名称与参数类型混合在一起.Haskell不能将此作为一般规则,因为函数是使用模式匹配和多个方程定义的,如:

map :: (a -> b) -> [a] -> [b]
map f (x:xs) = f x : map f xs
map _ [] = []

这里第一个参数f在第一个等式中命名,并且_(在第二个中,它几乎意味着"未命名").第二个参数不具有任何方程中的名称; 在它的第一部分有名称(程序员可能会把它想象成"xs列表"),而在第二部分它是一个完全文字的表达.

然后是无点定义,如:

concat :: [[a]] -> [a]
concat = foldr (++) []

类型签名告诉我们它接受一个类型的参数[[a]],但该参数的名称不会出现在系统的任何地方.

在函数的单个等式之外,除了作为文档之外,它用于引用其参数的名称无关紧要.由于函数参数的"规范名称"的概念在Haskell中没有很好地定义,因此信息的位置" bmiTell表示权重的第一个参数,而第二个表示高度"在文档中,而不是在类型签名中.

我完全同意,功能所做的事情应该从关于它的"公共"信息中清楚地表达出来.在Java中,这是函数的名称,以及参数类型和名称.如果(通常)用户需要更多信息,请将其添加到文档中.在Haskell中,有关函数的公共信息是函数的名称和参数类型.如果用户需要更多信息,请将其添加到文档中.注意Haskell的IDE(如Leksah)将很容易向您显示Haddock注释.

请注意,在具有强大且富有表现力的类型系统(如Haskell)的语言中,首选的方法是尝试尽可能多地将错误视为类型错误.因此,像bmiTell我一样立即向我发出警告标志的功能,原因如下:

1. 它需要两个相同类型的参数代表不同的东西
2. 如果以错误的顺序传递参数,它将做错误的事情
3. 这两种类型没有自然的位置(作为两个[a]参数++)

通常用于增加类型安全性的一件事就是制作新类型,就像你找到的链接一样.我并不认为这与命名参数传递有很大关系,更多的是关于创建一个明确表示高度的数据类型,而不是您可能想用数字测量的任何其他数量.所以我不会只在呼叫时出现newtype值; 我将使用newtype值,无论我从哪里获得高度数据,并将其作为高度数据而不是数字传递,以便我在各处获得类型安全(和文档)的好处.当我需要将值传递给操作数字而非高度(例如内部算术运算bmiTell)的东西时,我只会将值解包为原始数字.

请注意,这没有运行时开销; newtypes与newtype包装器"内部"的数据表示相同,因此wrap/unwrap操作在底层表示中是no-ops,并且在编译期间被简单地删除.它只在源代码中添加了额外的字符,但这些字符正是您正在寻找的文档,还有编译器强制执行的额外好处; Java风格的签名告诉你哪个参数是权重,哪个是高度,但编译器仍然无法判断你是否意外地以错误的方式传递它们!

Answer 2

还有其他选择,取决于你想要的类型有多愚蠢和/或迂腐.

例如,你可以这样做......

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)

我认为,做到这一点并不像我们应有的那样普遍.这是一个额外的打字(ha,ha),但它不仅使你的类型签名更具信息性,即使扩展了类型同义词,它还允许类型检查器捕获,如果你错误地使用权重作为高度,或类似.使用GeneralizedNewtypeDeriving扩展,您甚至可以获得自动实例,即使对于通常无法派生的类型类也是如此.

Answer 3

Haddocks和/或也在查看函数方程(你绑定的名字)是我告诉你发生了什么的方式.你可以Haddock个人参数,像这样,

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是相同的类型,即使它们必须是(也就是说,您提出的类型签名不够严格并且允许无效使用该函数).

Answer 4

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!"

我相信,这是你在OOP中明确表达的方式.我真的不相信你正在使用你的OOP方法参数的类型来获取这些信息,你必须秘密使用参数名称而不是类型,并且期望haskell告诉你参数名称是不公平的当你排除在你的问题中读取参数名称时.[见*下面] 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

或者更聪明的东西会是一个更好的主意.关于类型安全的非常重要的一点,请参阅Ben的答案.

[*]好的,你可以这样做:在ghci中获取没有参数名称的类型签名,但是ghci用于源代码的交互式开发.你的库或模块不应该没有文档和hacky,你应该使用非常轻量级的语法haddock文档系统并在本地安装haddock.更合理的投诉版本是没有:v命令打印函数bmiTell的源代码.度量标准表明,相同问题的Haskell代码将缩短一个因子(在我的情况下,我发现与等效的OO或非oo命令式代码相比大约为10),因此在gchi中显示定义通常是明智的.我们应该提交功能请求.

Answer 5

试试这个:

type Height a = a
type Weight a = a

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

Answer 6

可能与具有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,所以类型签名会记录正确的参数顺序,如果你混淆它们会得到一个编译时错误.