问题
This problem actually emerged from attempt to implement few mathematical groups as types.
Cyclic groups have no problem (instance of Data.Group
defined elsewhere):
newtype Cyclic (n :: Nat) = Cyclic {cIndex :: Integer} deriving (Eq, Ord)
cyclic :: forall n. KnownNat n => Integer -> Cyclic n
cyclic x = Cyclic $ x `mod` toInteger (natVal (Proxy :: Proxy n))
But symmetric groups have some problem on defining some instances (implementation via factorial number system):
infixr 6 :.
data Symmetric (n :: Nat) where
S1 :: Symmetric 1
(:.) :: (KnownNat n, 2 <= n) => Cyclic n -> Symmetric (n-1) -> Symmetric n
instance {-# OVERLAPPING #-} Enum (Symmetric 1) where
toEnum _ = S1
fromEnum S1 = 0
instance (KnownNat n, 2 <= n) => Enum (Symmetric n) where
toEnum n = let
(q,r) = divMod n (1 + fromEnum (maxBound :: Symmetric (n-1)))
in toEnum q :. toEnum r
fromEnum (x :. y) = fromInteger (cIndex x) * (1 + fromEnum (maxBound `asTypeOf` y)) + fromEnum y
instance {-# OVERLAPPING #-} Bounded (Symmetric 1) where
minBound = S1
maxBound = S1
instance (KnownNat n, 2 <= n) => Bounded (Symmetric n) where
minBound = minBound :. minBound
maxBound = maxBound :. maxBound
Error message from ghci (only briefly):
Overlapping instances for Enum (Symmetric (n - 1))
Overlapping instances for Bounded (Symmetric (n - 1))
So how can GHC know whether n-1
equals to 1 or not? I'd also like to know whether the solution can be written without FlexibleInstances
.
回答1:
Add Bounded (Symmetric (n-1))
and Enum (Symmetric (n-1))
as constraints, because fully resolving those constraints would require knowing the exact value of n.
instance (KnownNat n, 2 <= n, Bounded (Symmetric (n-1)), Enum (Symmetric (n-1))) =>
Enum (Symmetric n) where
...
instance (KnownNat n, 2 <= n, Bounded (Symmetric (n-1))) =>
Bounded (Symmetric n) where
...
To avoid FlexibleInstances
(which is not worth it IMO, FlexibleInstances
is a benign extension), use Peano numbers data Nat = Z | S Nat
instead of GHC's primitive representation. First replace the instance head Bounded (Symmetric n)
with Bounded (Symmetric (S (S n')))
(this plays the role of the constraint 2 <= n
), and then break up the instance with an auxiliary class (possibly more) to satisfy the standard requirement on instance heads. It might look like this:
instance Bounded_Symmetric n => Bounded (Symmetric n) where ...
instance Bounded_Symmetric O where ...
instance Bounded_Symmetric n => Bounded_Symmetric (S n) where ...
来源:https://stackoverflow.com/questions/54000646/overlapping-instances-via-nat-kind