Haskell中使用Dynamic/fromDynamic恢复约束及类型表跟踪问题

我明白你想构建一个能跟踪不同数据表类型的系统，原本打算用Dynamic存储Proxy列表来获取各类型的TypeRep，但遇到了编译错误。先帮你拆解下这个错误的核心原因，再分享可行的解决思路（包括你最终采用的更健壮的方案）。

错误原因解析 #

你遇到的编译错误：

• No instance for (Typeable proxy0) arising from a use of ‘fromDynamic’
• In the expression: fromDynamic d
  In the expression: case fromDynamic d of
                        Just x -> Just $ typeRep x
                        Nothing -> Nothing
  In an equation for ‘toTypeRep’:
      toTypeRep d = case fromDynamic d of
                      Just x -> Just $ typeRep x
                      Nothing -> Nothing

本质问题是：当你把不同类型的Proxy打包进Dynamic后，取出时Haskell无法自动推导要还原成哪种具体的Proxy类型，编译器找不到对应的Typeable实例约束，因此直接抛出编译错误，而不是你期望的返回Nothing。

方案一：修复原Dynamic方案 #

如果你想坚持用Dynamic的思路，可以通过显式类型注解帮编译器明确匹配逻辑，利用Typeable的多态性处理任意Proxy类型：

import Data.Dynamic
import Data.Typeable
import Data.Maybe (catMaybes)

allCowProxies :: [Dynamic]
allCowProxies = [ toDyn $ Proxy @HoboRecord
                , toDyn $ Proxy @AF.AfiFarmRecord
                , toDyn $ Proxy @DCP.DcPrediction
                , toDyn $ Proxy @DCF.DcFreshFeatures
                , toDyn $ Proxy @DCH.DcHistorical
                , toDyn $ Proxy @SA.ShActivity
                , toDyn $ Proxy @SRE.ShRumAndEating
                , toDyn $ Proxy @SX.SxRecord
                ]

allCowRecs :: [TypeRep]
allCowRecs = catMaybes $ map extractTypeRep allCowProxies
  where
    extractTypeRep :: Dynamic -> Maybe TypeRep
    extractTypeRep d = do
      -- 显式指定匹配任意Proxy a类型，只要该类型有Typeable实例即可
      proxy <- fromDynamic d :: Maybe (Proxy a)
      Just $ typeRep proxy

方案二：你最终采用的自定义代数类型方案 #

你后来用的自定义CowRecTbl类型方案其实更靠谱，它充分利用Haskell的静态类型系统做编译时检查，彻底避免了Dynamic带来的运行时不确定性，优势很明显：

• 编译时安全：启用-Werror=incomplete-patterns后，只要你在allCowProxies里新增表类型，类型系统会立刻提醒你补全cowRecTblApplyPx的模式匹配，绝不会遗漏任何情况
• 扩展性强：cowRecTblApplyPx是高阶函数，你可以传入任意接受Proxy r的逻辑（比如需要EntityRec约束的操作），轻松对所有表类型执行统一处理

完整代码回顾：

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeApplications #-}

import Data.Proxy
import Data.Typeable

data CowRecTbl = Hobo (Proxy HoboRecord)
               | Afi (Proxy AF.AfiFarmRecord)
               | DcPred (Proxy DCP.DcPrediction)
               | DcFf (Proxy DCF.DcFreshFeatures)
               | DcHist (Proxy DCH.DcHistorical)
               | ShAct (Proxy SA.ShActivity)
               | ShRum (Proxy SRE.ShRumAndEating)
               | SxTec (Proxy SX.SxRecord)

allCowProxies :: [CowRecTbl]
allCowProxies = [ Hobo $ Proxy @HoboRecord
                , Afi $ Proxy @AF.AfiFarmRecord
                , DcPred $ Proxy @DCP.DcPrediction
                , DcFf $ Proxy @DCF.DcFreshFeatures
                , DcHist $ Proxy @DCH.DcHistorical
                , ShAct $ Proxy @SA.ShActivity
                , ShRum $ Proxy @SRE.ShRumAndEating
                , SxTec $ Proxy @SX.SxRecord
                ]

cowRecTblApplyPx :: forall a. (forall r k. EntityRec r k => Proxy r -> a) -> CowRecTbl -> a
cowRecTblApplyPx f (Hobo px) = f px
cowRecTblApplyPx f (Afi px) = f px
cowRecTblApplyPx f (DcPred px) = f px
cowRecTblApplyPx f (DcFf px) = f px
cowRecTblApplyPx f (DcHist px) = f px
cowRecTblApplyPx f (ShAct px) = f px
cowRecTblApplyPx f (ShRum px) = f px
cowRecTblApplyPx f (SxTec px) = f px

allCowRecs :: [TypeRep]
allCowRecs = (cowRecTblApplyPx typeRep) <$> allCowProxies

额外思路：编译时自动枚举实例 #

你提到过想直接在运行时查询某类型类的所有实例，标准Haskell确实没有原生支持，但可以借助模板Haskell工具（比如th-abstraction）写自定义脚本，自动生成所有实例的列表，避免手动维护allCowProxies。不过这种方式会增加代码复杂度，适合需要频繁新增表类型的场景。

内容的提问来源于stack exchange，提问作者bbarker