Question

标题有点不准确，因为我的特殊情况涉及更多：与第一条记录中的函数不直接作用于第二条记录中的值相反，它们作用于值的列表（或其他可遍历）。如果可以购买任何东西，我们可以假设某个特定字段的申请结果返回的值与该字段的类型相同。

例如：

data Foo = Foo {
  v1 :: Int
, v2 :: Double
}

data FooFuns = FooFuns {
  v1 :: [Int] -> Int
, v2 :: [Double] -> Double
}

所以现在的目标是自动构建例如

result = Foo {
  v1 = (v1 FooFuns) (v1 <$> listOfFoos)
, v2 = (v2 FooFuns) (v2 <$> listOfFoos)
}

当前，我将函数包装在值列表上，作为newtype（因此Higgledy的HKD可以使用该函数）以及用于遍历约束的GADT ，但后一部分可能是不必要的，或者可能更好地建模为类型类：

data TraversableFun a t where
  TraversableFun :: Traversable t => (t a -> a) -> TraversableFun t a
newtype ListFun a = ListFun {unTravFun :: TraversableFun [] a}

type RecSummaryFuns a = HKD a ListFun

现在RecSummaryFuns a应该具有与a相同的“字段名称”（构造函数参数）。理想情况下，应该有一种方法可以轻松地将sFuns应用于下面的recs以获得单条记录。

applyStatFuns :: Traversable t => RecSummaryFuns r -> t r -> r
applyStatFuns sFuns recs = ???

我也很好奇这是否是对情况进行建模的最佳方法：基本上，我正在将摘要统计信息应用于记录中保存的值，但是我需要一种方法来封装每种记录类型的摘要统计信息。

Answer 1

现在RecSummaryFuns a应该具有相同的“字段名称”（构造函数参数）作为

此答案使用red-black-record来构造具有与原始Foo记录相同的字段名称的“通用记录”。首先，我们必须自动推导一些supporting typeclasses：

{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE PartialTypeSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeApplications #-}
{-# OPTIONS_GHC -Wno-partial-type-signatures #-} -- hide some scary types

import Data.RBR (FromRecord (..), Record, ToRecord (..), fromNP, insert, toNP, unit)
import Data.SOP (I (I), NP) -- from sop-core
import Data.SOP.NP (liftA2_NP, liftA_NP) --   useful functions for n-ary products
import GHC.Generics

data Foo
  = Foo
      { v1 :: Int,
        v2 :: Double
      }
  deriving (Show, Generic, FromRecord, ToRecord)

现在，我们可以定义通用记录的值，该记录的字段将包含函数。遗憾的是，我们不能采用通常的记录语法：

newtype Func a = Func ([a] -> a) -- helper newtype encapsulating the function

type FooFunc = Record Func (RecordCode Foo) -- wrap every field in Func

exampleFunc :: FooFunc
exampleFunc =
      insert @"v1" (Func head) -- field names give with TypeApplications
    . insert @"v2" (Func last) -- same order as in the original record
    $ unit -- unit is the empty record

下一步是借助n-ary product提供的sop-core数据类型来定义此泛型应用功能：

applyFunc ::  _ => Record Func _ -> [r] -> r
applyFunc func foos =
  let foos_NP :: [NP I _] -- a list of n-ary products. I is an identity functor
      foos_NP = toNP . toRecord <$> foos
      listfoos_NP :: [NP [] _] -- turn every component into a singleton list
      listfoos_NP = liftA_NP (\(I x) -> [x]) <$> foos_NP
      listfoo_NP :: NP [] _ -- a single n-ary product where each component is a list
      listfoo_NP = mconcat listfoos_NP
      func_NP :: NP Func _ -- turn the function record into a n-ary prod
      func_NP = toNP func
      resultFoo_NP_I :: NP I _ -- apply the functions to each list component
      resultFoo_NP_I = liftA2_NP (\(Func f) vs -> I (f vs)) func_NP listfoo_NP
   in fromRecord . fromNP $ resultFoo_NP_I -- go back to the nominal record Foo

将它们放在一起：

main :: IO ()
main =
  print $
    applyFunc exampleFunc [Foo 0 0.0, Foo 1 1.0]
-- result: Foo {v1 = 0, v2 = 1.0}

此解决方案的可能缺点是编译时间较长，并且可能会将Foo的列表转换为Foo中的带有列表字段的applyFunc对于长列表而言效率低下。

我们可以抛弃red-black-record（我们只是使用它来保留通用记录中的字段名称），而直接依赖于sop-core / generics-sop；在这种情况下，字段名称的处理方式会有所不同，或者我们可以仅依靠位置匹配。

给定功能记录和功能所作用类型的数据记录，如何通用地应用功能记录？

1 个答案: