Question

我在试图学习阅读GHC Core时注意到了枚举式数据类型的自动派生Eq实例，例如

data EType = ETypeA | ETypeB | ETypeC | ETypeD
           | ETypeE | ETypeF | ETypeG | ETypeH
           deriving (Eq)

在查看GHC的核心表示时，

似乎转变为 O（N）式查找：

$fEqEType_$c== =
  \ (a_ahZ :: EType) (b_ai0 :: EType) ->
    case a_ahZ of _ {
      ETypeA ->
        case b_ai0 of _ {
          ETypeA -> True;
          ETypeB -> False;
          ETypeC -> False;
          ETypeD -> False;
          ETypeE -> False;
          ETypeF -> False;
          ETypeG -> False;
          ETypeH -> False
        };
      ETypeB -> case b_ai0 of _ {__DEFAULT -> False; ETypeB -> True};
      ETypeC -> case b_ai0 of _ {__DEFAULT -> False; ETypeC -> True};
      ETypeD -> case b_ai0 of _ {__DEFAULT -> False; ETypeD -> True};
      ETypeE -> case b_ai0 of _ {__DEFAULT -> False; ETypeE -> True};
      ETypeF -> case b_ai0 of _ {__DEFAULT -> False; ETypeF -> True};
      ETypeG -> case b_ai0 of _ {__DEFAULT -> False; ETypeG -> True};
      ETypeH -> case b_ai0 of _ {__DEFAULT -> False; ETypeH -> True}
    }

我是否误解了GHC核心输出？代数数据类型是否应该为每个构造函数提供整数id，然后可以直接在 O（1）中进行比较？另外，为什么ETypeA的第一个案例条款没有像其他条款那样使用__DEFAULT？

更新

根据Simon Marlow的建议，我添加了第9个构造函数ETypeI，然后GHC转而使用dataToOtag#：

$fEqEType_$c/= =
  \ (a_ahS :: EType) (b_ahT :: EType) ->
    case dataToTag# @ EType a_ahS of a#_ahQ {
      __DEFAULT ->
        case dataToTag# @ EType b_ahT of b#_ahR {
          __DEFAULT ->
            case ==# a#_ahQ b#_ahR of _ {
              False -> True; True -> False
            }
        }
    }

对我来说，这增加了一个问题，即GHC核心case与dataToTag#的使用之间的权衡是什么，以及为什么这9个构造函数的特定截断使用{{1在GHC中实现。

Answer 1

EType的等式比较为O（1），因为case结构为O（1）。

构造函数可能有也可能没有整数标记。有几种低级别的表示选择，因此Core生成的所有这些都适用。也就是说，你总是可以为构造函数创建一个整数标记，这就是我编写Haskell编译器时通常实现派生比较的方式。

我不知道为什么ETypeA获得了不同的待遇。看起来像bug。

GHC的自动导出的`Eq`实例真的是* O（N）*吗？

1 个答案: