Question

我正在尝试使用Haskell编写基本词法分析器。为了实现DFA和NFA，我决定将一些常用函数放入FA和FAState类中。

-- |A class for defining the common functionality of all finite automatons.
class FA a b where
    mutateId :: a -> Int -> a               -- ^Returns a new FA by changing the sId of the input FA.
    mutateType :: a -> StateType -> a       -- ^Returns a new FA by changing the stateType of the input FA.
    addTransition :: a -> (b, a) -> a       -- ^Returns a new FA by adding a new transition to the input FA.


-- |A class for defining the common functionality of all finite automaton states.
class FA a b => FAState a b where
    sId :: a -> Int                         -- ^An unique identifier for the state(hence the prefix s).
    sType :: a -> StateType                 -- ^The type of the state.
    sTransitions :: a -> Transitions b a    -- ^The transitions that occur from this state.

其中，

-- |A type which identifies different types of a FA state.
data StateType = Start | Normal | Final
    deriving (Show, Read, Eq)

-- |A type which represents a list of transitions on input a to b.
-- Eg. [(Char, DFA)] represents the transition on a Char input.
type Transitions a b = [(a, b)]

因此，b表示发生转换的数据类型。对于DFA，b = Char，而对于NFA，b = Symbol。

data Symbol = Alphabet Char | Epsilon
    deriving (Show, Read, Eq)

DFA和NFA分别定义为：

data DFA = DState Int StateType (Transitions Char DFA)
    deriving (Show, Read)
data NFA = NState Int StateType (Transitions Symbol NFA)
    deriving (Show, Read)

我对FA＆amp;的实例定义有疑问。 FAState：

instance FA DFA Char where
    mutateId (DState i ty ts) new_i = DState new_i ty ts
    mutateType (DState i ty ts) new_ty = DState i new_ty ts
    addTransition (DState i ty ts) state = DState i ty (state:ts)

instance FAState DFA Char where
    sId (DState i t ts) = i
    sType (DState i t ts) = t
    sTransitions (DState i t ts) = ts

instance FA NFA Symbol where
    mutateId (NState i ty ts) new_i = NState new_i ty ts
    mutateType (NState i ty ts) new_ty = NState i new_ty ts
    addTransition (NState i ty ts) state = NState i ty (state:ts)

instance FAState NFA Symbol where
    sId (NState i t ts) = i
    sType (NState i t ts) = t
    sTransitions (NState i t ts) = ts

在尝试运行任何函数时，我得到一个无实例错误：

>>sId egNFA

<interactive>:15:1:
    No instance for (FAState NFA b0)
      arising from a use of `sId'
    Possible fix: add an instance declaration for (FAState NFA b0)
    In the expression: sId egNFA
    In an equation for `it': it = sId egNFA

我不明白这里发生了什么。

Answer 1

问题的根源是：实例调度永远不会使推断类型更具体，即使这样可以选择实例。这个设计决策与所谓的“开放世界”类模型有关：目标是代码的行为（包括“是否编译”）不应仅仅通过添加类型类的实例来改变。

现在，记住这个原则，考虑一下你要求编译器做什么：你给了一个FAState NFA Symbol的实例，写了一个类型为多态的表达式而只修复了第一种到NFA;另一个完全打开。编译器可以选择范围内的单个实例（其他变量单个化为Symbol），但这违反了我们的设计原则：现在为（例如）添加一个实例{{ 1}}会导致模糊的代码，将工作，可编译的代码转换为不可编译的代码。所以编译器保守地拒绝编译甚至只有一个实例的版本。

有一些标准修复：

提供类型签名以修复其他类型，告诉编译器选择哪个实例。遗憾的是，此解决方案不适合您：您的类型类多态值FAState NFA Widget未在其类型中提及类型变量sId :: FAState a b => a -> Int和a。既然你永远不能使用这个值，我认为现代GHC会稍早拒绝这个类型的类（在你编写任何实例之前或者尝试调用类方法之前），尽管我现在还没有一个人在旁边测试

只是举一个这个解决方案的例子，考虑b而不是sTransitions：这里类型签名确实提到了两个变量，因此您可以将非编译sId转换为是 - 编译sTransitions nfa。（更具原则性的，可推广的转换仅在方法上提供类型签名;例如，您可以轻松地将转换从sTransitions nfa :: Transitions Symbol NFA推广到sTransitions nfa。）
使用函数依赖项。这里的想法是状态的类型完全由自动机的类型决定，所以在道德上它应该足以修复类中的第一个类型变量。告诉GHC关于这个事实的语法如下：
```
(sTransitions :: NFA -> Transitions Symbol NFA) dfa
```
这有两件事：首先，它告诉GHC，如果它知道class FAState a b | a -> b where {- ...same as before -} -- instance declarations look the same as before, too，它可以使用它来选择一个实例，即使它还不知道a，其次，它告诉它GHC要仔细检查该类的实例对没有违反功能约束，即没有两个实例具有相同的b但不同的a。
使用（关联）类型系列。这与前一个观点相同，但可能是一个更为熟悉的范例。这个的语法如下所示：
```
b
```
这引入了一个名为class FAState a where type State a sId :: a -> Int sType :: a -> StateType sTransitions :: a -> Transitions (State a) a instance FAState NFA where type State NFA = Symbol -- methods are the same as before的新类型构造函数（可以在类型签名中使用，等等）。您可以将其视为类型级别的函数，该函数将作为类State的实例的输入类型，并输出与该类型的自动机相关联的状态的类型。
使您的实例声明更具多态性。如果GHC抱怨它对第二个变量知之甚少，那么......你总是可以告诉它第二个变量的所有实例都同样好（直到某些等式约束）。例如：
```
FAState
```
-- class definition same as before instance b ~ Symbol => FAState NFA b where -- methods same as before是GHC对类型级别相等的表示法。它的工作方式非常狡猾，并在其他地方得到很好的描述（如果你真的需要它我会挖掘一些链接），但解释的简短版本是这告诉GHC如果它知道足够挑选{{1作为第一个变量，然后它可以立即提交到这个实例，并且只有在它提交后才会仔细检查第二个参数是否为~。

享受！

多参数类没有实例错误

1 个答案: