haskell - 防止相互递归的默认方法在运行时循环

Question

我目前有如下结构:

class F a where
   f :: ...
   default f :: (G a...) => ...
   f = (some definition in terms of g)

class F a => G a where
   g :: ...
   default g :: (C a...) => ...
   g = (some definition in terms of f)

希望用简单的英语，我可以写 f根据 g总是。我可以写 g根据 f有时，即当 a满足 C约束。

我在这里看到的问题是，如果有人写，比如说类型 T满足 C T

instance F T
instance G T

这将在运行时编译和循环。虽然两个默认定义都是正确的，但重要的是至少定义了一个。

我可以用 MINIMAL 解决这个问题编译指示 f和 g在同一个类(class)，但在这种情况下，他们不是。

同时放置 f和 g在同一类中似乎是不可能的，因为有 f 的定义对于 g 的每个定义, 没有 g 的定义对于 f 的每个定义.一种可能是移动 g进入 F还要放一个 C a限制它，但这会阻止我定义 g任何 a 的非默认定义不满足 C a .

有没有办法重组它来解决我面临的这个困境？

Answer 1

我之前的回答是胡说八道，所以这里是一个(希望)更好的回答。这至少会在编译时给你一个警告。诀窍是实现 f'或 g在类里面G如果两者都是 a有两个 F 的实例和 G , 但仅限 f如果 G 的实例是不可能的。

{-# LANGUAGE DefaultSignatures #-}

class C a where

class F a where
  f :: a -> a
  default f :: (G a) => a -> a
  f = g

class F a => G a where
  {-# MINIMAL (f'|g) #-}

  f' :: a -> a
  f' = f

  g :: a -> a
  default g :: (C a) => a -> a
  g = f'

instance F Integer where
  f = succ

instance F Int
instance G Int where
  g = succ

instance C Float
instance F Float
instance G Float where
  f' = succ

-- This will give a compile time warning, but will still
-- loop at runtime:
instance C Double
instance F Double
instance G Double