为连续可测量的现象创建行为

我想创建一个Behavior t a从一个IO a，其预期语义是每次行为发生时都会运行 IO 操作sampled:

{- language FlexibleContexts #-}
import Reflex.Dom
import Control.Monad.Trans

onDemand :: (MonadWidget t m, MonadIO (PullM t)) => IO a -> m (Behavior t a)

我希望我可以通过执行来做到这一点measurement in a pull:

onDemand measure = return $ pull (liftIO measure)

然而，由此产生的Behavior初始后永远不会改变measurement.

我能想到的解决方法是创建一个虚拟对象Behavior改变“足够频繁”，然后创建一个虚假的依赖关系：

import Data.Time.Clock as Time

hold_ :: (MonadHold t m, Reflex t) => Event t a -> m (Behavior t ())
hold_ = hold () . (() <$)

onDemand :: (MonadWidget t m, MonadIO (PullM t)) => IO a -> m (Behavior t a)
onDemand measure = do
    now <- liftIO Time.getCurrentTime
    tick <- hold_ =<< tickLossy (1/1200) now
    return $ pull $ do
        _ <- sample tick
        liftIO measure

然后这将按预期工作；但是由于Behavior无论如何，只能按需采样，这不是必要的。

创建一个的正确方法是什么Behavior对于连续的、随时可观察的现象？

这样做在Spider看起来不可能。Internal提前推理。

In the Spider实施Reflex，其中一种可能的Behavior https://hackage.haskell.org/package/reflex/docs/Reflex-Spider-Internal.html#t:Behaviors是拉取值。

data Behavior a
   = BehaviorHold !(Hold a)
   | BehaviorConst !a
   | BehaviorPull !(Pull a)

A Pull https://hackage.haskell.org/package/reflex/docs/Reflex-Spider-Internal.html#t:Pulled value 包括如何在需要时计算该值，pullCompute，以及一个缓存值以避免不必要的重新计算，pullValue.

data Pull a
   = Pull { pullValue :: !(IORef (Maybe (PullSubscribed a)))
          , pullCompute :: !(BehaviorM a)
          }

忽略了恶劣的环境BehaviorM https://hackage.haskell.org/package/reflex/docs/Reflex-Spider-Internal.html#t:BehaviorM, liftIO举起一个IO计算的明显方式，它运行时BehaviorM需要采样。在里面Pull，您的行为会被观察一次，但不会再次被观察，因为缓存的值并未失效。

缓存的值PullSubscribed a https://hackage.haskell.org/package/reflex/docs/Reflex-Spider-Internal.html#t:PullSubscribed由值组成a，如果该值无效则需要无效的其他值的列表，以及一些无聊的内存管理内容。

data PullSubscribed a
   = PullSubscribed { pullSubscribedValue :: !a
                    , pullSubscribedInvalidators :: !(IORef [Weak Invalidator])
                    -- ... boring memory stuff
                    }

An Invalidator https://hackage.haskell.org/package/reflex/docs/Reflex-Spider-Internal.html#t:Invalidator是一个量化的Pull这足以获取内存引用以递归地读取无效器以使其无效并将缓存的值写入Nothing.

为了不断地拉动，我们希望能够不断地使我们自己的BehaviorM。执行时，环境传递给BehaviorM有一个自己的失效器的副本，由依赖项使用BehaviorM当它们本身失效时使其失效。

从内部实现来看readBehaviorTracked https://hackage.haskell.org/package/reflex-0.4.0/docs/src/Reflex-Spider-Internal.html#readBehaviorTracked%5D似乎没有办法让行为自己的失效器（wi) 可能会出现在采样时失效的订阅者列表中 (invsRef).

    a <- liftIO $ runReaderT (unBehaviorM $ pullCompute p) $ Just (wi, parentsRef)
    invsRef <- liftIO . newIORef . maybeToList =<< askInvalidator
    -- ...
    let subscribed = PullSubscribed
          { pullSubscribedValue = a
          , pullSubscribedInvalidators = invsRef
          -- ...
          }

在内部结构之外，如果确实存在一种方法来不断地采样Behavior这将涉及MonadFix (PullM t)实例或通过修复相互递归pull https://hackage.haskell.org/package/reflex-0.4.0/docs/Reflex-Class.html#v:pull and sample https://hackage.haskell.org/package/reflex-0.4.0/docs/Reflex-Class.html#v:sample:

onDemand :: (Reflex t, MonadIO (PullM t)) => IO a -> Behavior t a
onDemand read = b
    where
        b = pull go
        go = do
             sample b
             liftIO read

我没有Reflex尝试这个的环境，但我认为结果不会很好。