Haskell中如何将记录字段建模为数据以实现可存储查询？

给定Haskell中的Person记录类型：

data Person = Person
  { name :: String
  , age :: Int
  , id :: Int
  }

我们能实现针对特定字段的搜索函数，比如根据名字查找：

findByName :: String -> [Person] -> Maybe Person
findByName s = find (\p -> name p == s)

现在需要把这类针对指定字段（或字段集合）的搜索逻辑建模成可存储的数据，用来做日志记录、批量执行等操作。

最开始想的是用字段到值的映射，但记录字段本身是函数，没法直接当Map的键。试过下面的方案：

data PersonField = Name | Age | Id  -- 原代码里的Int是笔误，应该是Id
type Search = Map PersonField (Maybe String)

但这会导致PersonField和Person的字段脱节——改了Person的字段，就得手动同步PersonField，很容易出错。有没有更好的实现方式？

你可以定义一个携带类型信息和字段访问器的PersonField类型，让它和Person的字段强绑定，彻底避免手动同步的问题：

完整实现（支持外部字符串解析） #

import Data.Map (Map)
import qualified Data.Map as Map
import Data.Maybe (find)
import Text.Read (readMaybe)

data Person = Person
  { name :: String
  , age :: Int
  , id :: Int
  } deriving (Show, Eq)

-- 字段描述器：每个构造器包含字段名、访问函数、字符串转字段类型的解析函数
data PersonField a = PersonField
  { fieldName :: String       -- 用于日志或序列化
  , getField :: Person -> a   -- 从Person中取出字段值
  , parseValue :: String -> Maybe a  -- 把外部字符串转成对应类型的值
  }

-- 为每个Person字段创建对应的描述器
nameField :: PersonField String
nameField = PersonField "name" name Just

ageField :: PersonField Int
ageField = PersonField "age" age readMaybe

idField :: PersonField Int
idField = PersonField "id" id readMaybe

-- 用存在类型包装不同类型的字段查询条件，支持多字段组合
data AnyPersonCondition = forall a. Eq a => AnyPersonCondition (PersonField a) a

type PersonQuery = [AnyPersonCondition]

-- 执行查询的函数
runQuery :: PersonQuery -> [Person] -> [Person]
runQuery conditions people = filter matches people
  where
    matches person = all (\(AnyPersonCondition field val) -> getField field person == val) conditions

方案好处 #

1. 强绑定无脱节：每个PersonField直接关联Person的字段访问函数，改Person字段时，对应的描述器必须同步调整，编译期就能发现错误，不会出现漏改的情况。
2. 类型安全：通过parseValue可以安全地把日志、配置里的字符串转成字段对应的类型，避免类型错误。
3. 扩展性强：要加新字段？只要新增一个对应的PersonField实例就行；要支持大于、小于这类复杂条件？只要修改AnyPersonCondition，加入比较操作的定义即可。

简化版（无需外部字符串解析） #

如果只是在内存里做类型安全查询，不需要处理外部字符串，可以把实现简化：

import Data.Maybe (find)

data Person = Person
  { name :: String
  , age :: Int
  , id :: Int
  } deriving (Show, Eq)

data PersonField a = PersonField (Person -> a)

nameField :: PersonField String
nameField = PersonField name

ageField :: PersonField Int
ageField = PersonField age

idField :: PersonField Int
idField = PersonField id

data QueryCondition = forall a. Eq a => QueryCondition (PersonField a) a

type PersonQuery = [QueryCondition]

runQuery :: PersonQuery -> [Person] -> [Person]
runQuery conds = filter (\p -> all (\(QueryCondition field val) -> field p == val) conds)

另一种思路：用泛型自动关联字段 #

借助Haskell的Generic和generic-lens库，可以自动推导Person的字段信息，完全不用手动维护字段枚举：

import Data.Generics.Labels ()
import Data.Generics.Product (HasField)
import Data.Maybe (find)

data Person = Person
  { name :: String
  , age :: Int
  , id :: Int
  } deriving (Show, Eq, Generic)  -- 派生Generic

-- 单个字段的查询条件
data Query (s :: Symbol) a = Query a

-- 按指定字段查找的通用函数
findByField :: forall s a. (HasField s Person a, Eq a) => Query s a -> [Person] -> Maybe Person
findByField (Query val) = find (\p -> p ^. #s == val)

-- 组合多字段查询
type PersonQuery = [Person -> Bool]

runCombinedQuery :: PersonQuery -> [Person] -> [Person]
runCombinedQuery queries = filter (\p -> all ($ p) queries)

-- 使用示例
nameQuery :: Query "name" String
nameQuery = Query "Alice"

ageQuery :: Query "age" Int
ageQuery = Query 30

combinedQuery :: PersonQuery
combinedQuery = [(\p -> p ^. #name == "Alice"), (\p -> p ^. #age == 30)]

这种方式下，Person的字段和查询逻辑完全绑定，改Person字段后，错误会直接在编译期暴露，彻底避免手动同步的麻烦。

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