haskell - 处理有限但任意数量的异构元素的函数

Question

我正在图书馆工作以研究博弈论学习。
在此设置中，N代理被聚集在一起并与环境交互。
每个代理派生一个交互模型。
一个代理的模型取决于它的 N-1对手。
我为 1 编写了确定该模型的代码代理和2代理，并试图概括它。这是我拥有的代码的一部分:

data System w x a s h h' = System { signaling :: SignalingWXAS w x a s
                                  , dynamic   :: DynamicXAS x a s
                                  , strategy  :: MockupStrategy x a s h h' }

data JointState w x a s h h' = JointState { worldState  :: w
                                          , state       :: x
                                          , mockupState :: MockupState a s h h' }

systemToMockup :: ( Bounded w, Ix w, Bounded x, Ix x
                  , Bounded a, Ix a, Bounded s, Ix s
                  , Bounded (h a), Ix (h a), Bounded (h' s), Ix (h' s)
                  , History h, History h'
                  ) => System w x a s h h' -> Mockup a s h h'
systemToMockup syst = mock
    where
      mock z   = norm $ statDist >>=? condit z >>= computeStatesAndAction >>= sig >>=$ extractSignal
      statDist = ergodicStationary $ transition syst
      condit z = just z . mockupState
      sig      = uncurryN $ signaling syst
      strat    = strategy syst
      computeStatesAndAction joint = do
        let w = worldState joint
        let x = state joint
        a <- strat x (mockupState joint)
        return (w, x, a)
      extractSignal (_, s) = s

和

data System2 w x1 a1 s1 h1 h1' x2 a2 s2 h2 h2' = System2 { signaling :: SignalingWXAS2 w x1 a1 s1 x2 a2 s2
                                                         , dynamic1  :: DynamicXAS x1 a1 s1
                                                         , dynamic2  :: DynamicXAS x2 a2 s2
                                                         , strategy1 :: MockupStrategy x1 a1 s1 h1 h1'
                                                         , strategy2 :: MockupStrategy x2 a2 s2 h2 h2' }

data JointState2 w x1 a1 s1 h1 h1' x2 a2 s2 h2 h2' = JointState2 { worldState   :: w
                                                                 , state1       :: x1
                                                                 , mockupState1 :: MockupState a1 s1 h1 h1'
                                                                 , state2       :: x2
                                                                 , mockupState2 :: MockupState a2 s2 h2 h2' }
systemToMockups2 syst = (mock1, mock2)
    where
      mock1 z1   = norm $ statDist >>=? condit1 z1 >>= computeStatesAndActions >>= sig >>=$ extractSignal1
      mock2 z2   = norm $ statDist >>=? condit2 z2 >>= computeStatesAndActions >>= sig >>=$ extractSignal2
      statDist   = ergodicStationary $ transition2 syst
      condit1 z1 = just z1 . mockupState1
      condit2 z2 = just z2 . mockupState2
      sig        = uncurryN $ signaling syst
      strat1     = strategy1 syst
      strat2     = strategy2 syst
      computeStatesAndActions joint = do
        let w  = worldState joint
        let x1 = state1 joint
        let x2 = state2 joint
        a1 <- strat1 x1 (mockupState1 joint)
        a2 <- strat2 x2 (mockupState2 joint)
        return (w, x1, a1, x2, a2)
      extractSignal1 (_, s, _) = s
      extractSignal2 (_, _, s) = s

我正在寻找 systemToMockupN 的函数定义可以容纳任何有限数量的代理。

代理是异构的，因此不能直接使用列表。
我不能使用元组，因为我事先不知道大小。
我尝试使用 curryN , uncurryN等，但没有设法对元组的每个元素进行一次操作。
我尝试以类似于 printf 的方式构建可变参数函数没有成功。

我知道我可以使用模板 haskell，但我想知道是否有我忽略的更好的解决方案。
任何指向处理有限但任意数量的异构元素的代码的指针都将不胜感激。

Answer 1

异质。我不认为你应该这样做，但你确实问过。

您可以将现有的库用于异构列表，例如 HList .无论如何，这会 secret 使用 Template Haskell，但是您不需要像自己动手那样弄脏手。

由于需要强制转换等，具有动态类型的语言有各种各样的问题。 HList 是类型安全的，但在我看来，编写运行良好且没有错误的代码仍然不容易。你比元组更有优势，因为你不需要改变类型，并且跨元素映射更新应该更容易，但它仍然不漂亮。