Haskell如何为Floating与Integral类实现自定义类型类实例？

希望自定义类型类MyClass，让所有Floating和Integral类型都成为它的实例，但两者的func实现逻辑不同。最初尝试的代码如下：

class MyClass a where
    func :: a -> Bool

instance (Floating a) => MyClass a where
    func _ = True

instance (Integral b) => MyClass b where
    func _ = False

这段代码会抛出重复实例声明错误，原因是Haskell的实例匹配不考虑约束条件，避免同时实现Floating和Integral的类型出现行为歧义。

尝试过{-# INCOHERENT #-}编译指令但无效，之后改用类型族方案：

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}

import Data.Data (Proxy(..))

class MyClass a where
    func :: a -> Bool

data FromFloatingOrIntegralResult = FromFloating | FromIntegral

type family FromFloatingOrIntegral a :: FromFloatingOrIntegralResult where
    FromFloatingOrIntegral (Floating a) = 'FromFloating
    FromFloatingOrIntegral (Integral a) = 'FromIntegral

class MyClassImpl (r :: FromFloatingOrIntegralResult) a where
    funcImpl :: Proxy r -> a -> Bool

instance (Floating a) => MyClassImpl FromFloating a where
    funcImpl _ floating = True
instance (Integral b) => MyClassImpl FromIntegral b where
    funcImpl _ integral = False

但在关联MyClassImpl和MyClass时，再次遇到重复实例问题：

instance (MyClassImpl FromFloating a) => MyClass a where
    func = funcImpl (Proxy :: Proxy FromFloating)
instance (MyClassImpl FromIntegral a) => MyClass a where
    func = funcImpl (Proxy :: Proxy FromIntegral)

尝试通过类型族结果关联的方式：

instance (MyClassImpl (FromFloatingOrIntegral a) a) => MyClass a where
    func = funcImpl (Proxy :: Proxy (FromFloatingOrIntegral a))

却出现类型种类不匹配问题，因为FromFloatingOrIntegral的定义错误地接收约束类型而非普通类型。添加函数依赖也无法解决问题。

请问该需求是否无法实现？或是有特定语言扩展或技巧可以解决？

这个需求完全可以实现，核心是修正类型族的定义逻辑，结合合适的语言扩展来编写无歧义的实例。

完整实现代码 #

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE InstanceSigs #-}

class MyClass a where
    func :: a -> Bool

-- 类型族：判断当前类型属于Floating还是Integral
type family IsFloatingType a where
    IsFloatingType a = (Floating a) `IfTrue` True `Else` (Integral a) `IfTrue` False

-- 辅助类型族：实现条件判断逻辑
type family c `IfTrue` res where
    True `IfTrue` res = res
    False `IfTrue` res = res
type family a `Else` b where
    a `Else` b = b

-- 实现类：根据布尔标记区分两种逻辑
class MyClassImpl (isFloating :: Bool) a where
    funcImpl :: Proxy isFloating -> a -> Bool

instance Floating a => MyClassImpl True a where
    funcImpl _ _ = True

instance Integral a => MyClassImpl False a where
    funcImpl _ _ = False

-- 统一的MyClass实例，通过类型族结果绑定对应的实现
instance (res ~ IsFloatingType a, MyClassImpl res a) => MyClass a where
    func :: a -> Bool
    func = funcImpl (Proxy :: Proxy res)

关键细节解析 #

1. 修正类型族定义：IsFloatingType接收普通类型a，通过IfTrue辅助类型族结合上下文约束，判断a是否属于Floating或Integral类型，返回布尔标记区分两类实现。
2. 避免重复实例：只声明一个MyClass实例，通过类型族的结果（True/False）动态关联对应的MyClassImpl实现，从根源避免重复实例冲突。
3. 必要语言扩展：
   • FlexibleInstances：允许实例头使用更灵活的类型表达式
   • TypeFamilies：支持自定义类型族实现类型级逻辑
   • UndecidableInstances：允许类型族进行复杂的条件判断（编译器无法提前终止检查）
   • InstanceSigs：显式标注实例方法的签名，提升代码可读性（可选）

测试验证 #

main :: IO ()
main = do
    print (func (3.14 :: Double)) -- 输出：True（Double属于Floating）
    print (func (5 :: Int))       -- 输出：False（Int属于Integral）

内容的提问来源于stack exchange，提问作者Dániel Mihalik