Question

我正在尝试为alternative version numbering approach定义Eq运算符。

type VersionCompound = Maybe Int -- x, 0, 1, 2, ...

type VersionNumber = [VersionCompound] -- x.x, x.0, x.1, x.2, ... , 1.0, 1.1, 1.2, ... 1.x.x, 2.x.x, 3.x.x, ...

instance Eq VersionNumber where
        [] == [] = True
        (x:[]) == (y:[]) = x == y
        (Nothing:xs) == ys = (xs == ys)
        xs == (Nothing:ys) = (xs == ys)

对于以下情况，它会返回True：x.x.x == x，1.x.x == x.1.x.x，x.1 == 1等。但它会返回错误：

VersionNumber.hs:58:34:
    Overlapping instances for Eq [VersionCompound]
      arising from a use of ‘==’
    Matching instances:
      instance Eq a => Eq [a] -- Defined in ‘GHC.Classes’
      instance Eq VersionNumber -- Defined at VersionNumber.hs:55:10
    In the expression: (xs == ys)
    In an equation for ‘==’: (Nothing : xs) == ys = (xs == ys)
    In the instance declaration for ‘Eq VersionNumber’

任何想法如何解决？

编辑：我通过列表上的模式匹配解决此问题的方法结果不完整。我想忽略给定版本左侧的x（或Nothing s）的任意列表。因此，例如，x.x.x.x.x将等于x.x.x和x。同样，x.x.x.1等于x.x.1和1。如果中间有x，则不会被丢弃。因此，对于这种情况，x.x.1.x.0将等于x.1.x.0和1.x.0。又一个示例：x.1.x.x.0.x等于1.x.x.0.x，x.1.x.0.x等于1.x.0.x（您只需删除左侧的x）

修复错误Overlapping instances for Eq [VersionCompound]后我遇到的问题是如何获取x.x.x == x - ＆gt;具有模式匹配的True。但是，正如@WillemVanOnsem出色地指出的那样，它不应该通过模式匹配来实现，而应该通过功能组合来实现。

PS。我个人鼓励你通过@WillemVanOnsem来回答这个问题，因为他的解决方案非常优雅，需要付出一些努力来代表Haskell功能的本质。

Answer 1

您使用类型别名。这意味着您尚未定义单独的类型VersionNumber或VersionCompound;你只是构建了一个别名。在幕后，Haskell认为VersionNumber只是[Maybe Int]。

现在，如果我们看一下Haskell的库，我们就会看到：

instance Eq Int where
    -- ...

instance Eq a => Eq (Maybe a) where
    -- ...

instance Eq a => Eq [a] where
    -- ...

这意味着Eq Int已定义，Eq (Maybe Int)也已定义，因此Eq [Maybe Int]也由Haskell库定义。所以你实际上已经构建了一个Eq VersionNumber而没有写一个。现在你尝试写一个额外的，当然，编译器会与选择哪一个混淆。

有多种方法可以解决重叠的实例，但这可能只会产生更多麻烦。

因此，您最好使用单个构造函数构造data类型。例如：

type VersionCompound = Maybe Int
data VersionNumber = VersionNumber [VersionCompound]

现在，由于只有一个构造函数，因此最好使用newtype：

type VersionCompound = Maybe Int
newtype VersionNumber = VersionNumber [VersionCompound]

现在我们可以定义我们的特殊实例，如：

instance Eq VersionNumber where
    (VersionNumber a) == (VersionNumber b) = a =*= b
        where [] =*= [] = True
              (x:[]) =*= (y:[]) = x == y
              (Nothing:xs) =*= ys = (xs =*= ys)
              xs =*= (Nothing:ys) = (xs =*= ys)

因此，我们解开构造函数，然后使用另一个本地定义的函数=*=，其功能与您在问题中定义的函数类似。

请注意，您忘记了程序中的一些模式，例如左侧和右侧的Just x : xs。所以，你最好先解决这些问题。如果我通过编译器运行代码，我会收到以下警告：

Pattern match(es) are non-exhaustive
In an equation for ‘=*=’:
    Patterns not matched:
        [] (Just _:_)
        [Just _] []
        [Just _] (Just _:_:_)
        (Just _:_:_) []

您希望如何处理这些案件当然取决于您。 @DanielWagner建议使用：

import Data.Function(on)
import Data.Maybe(catMaybes)

instance Eq VersionNumber where
    (VersionNumber a) == (VersionNumber b) = on (==) catMaybes a b

这将过滤掉Nothing两个VersionNumber的值，然后检查Just中的值是否生成相同的列表。因此3.x.2.x.x.1将等于3.2.1和x.x.x.x.x.3.2.1。

编辑：根据您在评论中的说明，您可能正在寻找：

import Data.Function(on)

instance Eq VersionNumber where
    (VersionNumber a) == (VersionNumber b) = on (==) (dropWhile (Nothing ==)) a b

替代版本编号方法的Eq定义

1 个答案: