4

我正在尝试使用 netwire 包尝试了解 FRP，我有一个简单的问题。

从以下简单的电线开始，我能够每 5 秒（大约）发出一个事件

myWire :: (Monad m, HasTime t s) => Wire s () m a Float
myWire = timeF

myWire' :: (Monad m, HasTime t s) => Wire s () m a Int
myWire' = fmap round myWire

myEvent :: (Monad m, HasTime t s) => Wire s () m a (Event Int)
myEvent = periodic 5 . myWire'

这是非常好的和直截了当的，但我接下来要做的是将产生的每个事件映射到一个线路，然后我可以观看更新。我有一个累加器功能，如下所示：

eventList :: (Monad m, HasTime t s) 
            => Wire s () m a (Event [Wire s () m a Int])
eventList = accumE go [] . myEvent
  where go soFar x = f x : soFar
        f x = for 10 . pure x --> pure 0

eventList然后，我引入了一条新线，它将在开始触发事件之前进行抑制，如下所示：

myList :: (Monad m, HasTime t s) => Wire s () m a [Wire s () m a Int]
myList = asSoonAs . eventList

所以我已经从事件转到包含电线列表的电线。最后，我引入了一条线来对这些线中的每一个进行步进并生成一个结果列表：

myNums :: (Monad m, HasTime t s) => Wire s () m [Wire s () m a Int] [Int]
myNums = mkGen $ \dt wires -> do
  stepped <- mapM (\w -> stepWire w dt $ Right undefined) wires
  let alive = [ (r, w) | (Right r, w) <- stepped ]
  return (Right (map fst alive), myNums)

myNumList :: (Monad m, HasTime t s) => Wire s () m a [Int]
myNumList = myNums . myList

最后，我有我的主要程序来测试它：

main = testWire clockSession_ myNumList

我期望看到的是一个不断增长的列表，其中列表中的每个元素将显示它的创建时间 10 秒，之后元素将显示为零。相反，我得到的是不断增长的静态值列表。例如，我期望在几个步骤后看到的是

[0]
[5, 0]
[10, 5, 0]
[15, 10, 0, 0]

等等。我实际看到的是

[0]
[5, 0]
[10, 5, 0]
[15, 10, 5, 0]

所以我知道我的累加器功能正在工作：创建的每个事件都被转换成一条线。但我没有看到这些电线随着时间的推移发出不同的值。我的声明for 10 . pure x --> pure 0应该在时间过去后将它们切换为发射 0。

我还是 FRP 的新手，所以我可能从根本上误解了它的一些重要内容（可能是这种情况。）

4

2 回答 2

2

正如Mokosha 建议的那样，我们可以保留我们从以前的事件中已经知道的电线的状态，并从最新的事件中引入电线。例如，如果我们已经知道没有事件，并且得到一个包含一根线的列表，我们应该使用新的线。

      [] -- we already know about
w0' : [] -- we got as input
w0' : [] -- what we should keep

如果我们已经知道一根或多根电线并发现更多电线，我们需要保留我们已经知道的电线并添加我们刚刚发现的新电线。

            w2  : w1  : w0  : [] -- we already know about
w4' : w3' : w2' : w1' : w0' : [] -- we got as input
w4' : w3' : w2  : w1  : w0  : [] -- what we should keep

这更容易从列表的前端定义。第一个参数将是结果的前缀。如果剩下任何第二个参数，我们会将它们添加到列表的末尾。

makePrefixOf :: [a] -> [a] -> [a]
makePrefixOf [] ys = ys
makePrefixOf xs [] = xs
makePrefixOf (x:xs) (_:ys) = x:makePrefixOf xs ys

我们可以通过反转输入和输出来为列表的后端定义相同的东西。第一个参数将是结果的后缀，如果第二个参数有任何多余的，则将它们添加到列表的前面。

makeSuffixOf :: [a] -> [a] -> [a]
makeSuffixOf xs ys = reverse $ makePrefixOf (reverse xs) (reverse ys)

现在我们可以实现myNums跟踪oldWires我们已经拥有的状态。

myNums :: (Monad m, HasTime t s) => Wire s () m [Wire s () m a b] [b]
myNums = go []
  where
    go oldWires = mkGen $ \dt newWires -> do
        let wires = makeSuffixOf oldWires newWires
        stepped <- mapM (\w -> stepWire w dt $ Right undefined) wires
        let alive = [ (r, w) | (Right r, w) <- stepped ]
        return (Right (map fst alive), go (map snd alive))

如果我们想学究气，我们应该使用Maybe电线列表，这样当电线不再存在时，我们可以在其位置留下 a Nothing，以便电线列表仍然匹配。如果我们这样做，即使对状态进行了巧妙的表示，当电线死亡时，我们也会泄漏空间。它们的原始定义仍将保留在由eventList.

这给出了所需的输出

            [ 0]
         [ 5, 0]
      [10, 5, 0]
   [15,10, 0, 0]
[20,15, 0, 0, 0]
于 2015-03-08T01:48:38.020 回答
2

问题是从事件生成的连线不是持久的。type 的给定值Wire s e m a b实际上是从 type 的值产生 type 的值的函数的时间实例。由于 Haskell 使用不可变的值，为了步进线，您必须对生成的线做一些事情，否则您会为相同的输入获得相同的输出。看看结果：bastepWiremyList

Event 1: [for 10 . pure 0 --> pure 0]
Event 2: [for 10 . pure 5 --> pure 0, for 10 . pure 0 --> pure 0]
Event 3: [for 10 . pure 10 --> pure 0, for 10 . pure 5 --> pure 0, for 10 . pure 0 --> pure 0]
... etc

当你踩每根电线时，你只会[.., 10, 5, 0]每次都得到，因为你正在重用for 10 . pure x --> pure 0电线的原始价值。查看签名stepWire：

stepWire :: Monad m => Wire s e m a b -> s -> Either e a -> m (Either e b, Wire s e m a b)

这意味着对于诸如

(result, w') <- stepWire w dt (Right underfined)

...w'应该在下次需要调用时使用stepWire，因为它是下一个实例的行为。如果您有生产电线的电线，那么您需要将生产的电线卸载到某个地方，以便可以单独处理它们。

对于（我相信）为您提供所需行为的程序，请参阅此代码。

$ ghc -o test test.hs
[1 of 1] Compiling Main             ( test.hs, test.o )
Linking test ...
$ ./test
[0]
[5,0]
[10,5,0]
[15,10,0,0]
[20,15,0,0,0]
...
于 2015-03-08T00:54:21.757 回答