避免 Haskell 中的名称空间污染

Question

我在程序中使用许多不同的记录，其中一些使用相同的字段名称，例如，

data Customer = Customer { ..., foo :: Int, ... }
data Product = Product { ..., foo :: Int, ... }

现在由于访问器函数“foo”被定义了两次，我收到“多重声明”错误。避免这种情况的一种方法是使用完全限定导入的不同模块，或者简单地重命名字段（我不想这样做）。

Haskell 中处理此问题的官方建议方法是什么？

Answer 1

这是一个非常棘手的问题。有几个修复记录系统的建议。有关相关说明，请参阅 TDNR 和 cafe 相关讨论.

使用当前可用的语言功能，我认为最好的选择是在两个不同的模块中定义两种类型，并进行合格的导入。除此之外，如果您愿意，您可以实现一些类型类机制。

在 Customer.hs

module Customer where
data Customer = Customer { ..., foo :: Int, ... }

在 Product.hs

module Product where
data Product = Product { ..., foo :: Int, ... }

在使用它们时，在 Third.hs

module Third where

import qualified Customer as C
import qualified Product as P

.. C.foo ..
.. P.foo ..

然而，我想在您遇到有关 递归依赖模块。

Answer 2

（仅供参考，这个问题几乎肯定是重复的）

解决方案：

1）在字段前添加一个指示类型的标签前缀（非常常见）

data Customer = Customer {..., cFoo :: Int, ...}

2）使用类型类（不太常见，人们抱怨像 cFoo 这样的前缀是不方便，但显然还不错，他们会编写一个类和实例，或者使用 TH 来做同样的事情）。

class getFoo a where
    foo :: a -> Int

instance getFoo Customer where
    foo = cFoo

3）使用更好的字段名称
如果这些字段实际上不同（这并不总是正确的，我的计算机和我的员工一样都有年龄），那么这是最好的解决方案。

Answer 3

有一个语言扩展DuplicateRecordFields，它允许复制字段函数并使其类型可以通过类型注释来推断。

这是一个小例子（haskell-stack 脚本）：

#!/usr/bin/env stack
-- stack runghc --resolver lts-8.20 --install-ghc

{-# LANGUAGE DuplicateRecordFields #-}

newtype Foo = Foo { baz :: String }
newtype Bar = Bar { baz :: String }

foo = Foo { baz = "foo text" }
bar = Bar { baz = "bar text" }

main = do
  putStrLn $ "Foo: " ++ baz (foo :: Foo) -- Foo: foo text
  putStrLn $ "Bar: " ++ baz (bar :: Bar) -- Bar: bar text

Answer 4

另请参阅 Has 包： http://chrisdone.com/posts/duck-typing- in-haskell

如果您现在确实需要可扩展记录，则可以随时使用 HList。但在你真正熟悉并熟悉中高级 Haskell 之前我不会推荐这个，即使这样我也会三重检查你是否需要它。

Haskelldb 有一个稍微轻量级的版本： http://hackage.haskell.org/packages/archive/haskelldb/2.1.0/doc/html/Database-HaskellDB-HDBRec.html

然后还有另一个版本的可扩展记录作为柚子的一部分frp 库： http://hackage.haskell.org/package/grapefruit-records

再次，为了您的目的，我会硬着头皮重命名字段。但这些参考资料表明，当您确实需要可扩展记录的全部功能时，有很多方法可以做到这一点，即使没有一种方法像精心设计的语言扩展那样令人愉快。

Answer 5

一种可能的解决方案是，将 <.> 定义为：

(<.>) :: (Emiter e1, Emiter e2) => e1 -> e2 -> String
lhs <.> rhs = emit lhs <> emit rhs

那么发射器可以如下所示：

class Emiter n where
    emit :: n -> String 

instance Emiter String where
    emit = id

instance Emiter A where 
    emit A {
        foo = foo'
        bar = bar'
    } = foo' <.> "--" <.> bar'

instance Emiter B where
    emit B {
        foo = foo'
        bar = bar'
    } =  "[" <.> bar' <.> foo' <.> "]"