@@ -239,18 +239,13 @@ subscribeCoincidenceInner inner outerHeight subscribedUnsafe = do
239239-- Subscriber
240240--------------------------------------------------------------------------------
241241
242−data Subscriber x a
243− = forall b. SubscriberPush (a -> ComputeM x (Maybe b)) (PushSubscribed x a b) --TODO: Why does this have the pushCompute in it?
244− | forall k. GCompare k => SubscriberMerge !(k a) (MergeSubscribed x k) --TODO: Can we inline the GCompare?
245− | forall k. (a ~ R.PatchDMap (DMap k (Event x)), GCompare k) => SubscriberMergeChange (MergeSubscribed x k)
246− | forall k. (GCompare k, a ~ DMap k Identity) => SubscriberFan (FanSubscribed x k)
247− | forall p b. (a ~ p b, R.Patch p) => SubscriberHold !(Hold x p b)
248− | forall b. (a ~ Identity b) => SubscriberHoldIdentity !(Hold x Identity b)
249− | SubscriberSwitch (SwitchSubscribed x a)
250− | forall b. a ~ Event x b => SubscriberCoincidenceOuter (CoincidenceSubscribed x b)
251− | SubscriberCoincidenceInner (CoincidenceSubscribed x a)
252− | SubscriberHandle
242+data Subscriber x a = Subscriber
243+ { subscriberPropagate :: !(a -> EventM x ())
244+ , subscriberInvalidateHeight :: !(Height -> IO ())
245+ , subscriberRecalculateHeight :: !(Height -> IO ())
246+ }
253247
248+--TODO: Move this comment to WeakBag
254249-- These function are constructor functions that are marked NOINLINE so they are
255250-- opaque to GHC. If we do not do this, then GHC will sometimes fuse the constructor away
256251-- so any weak references that are attached to the constructors will have their
@@ -261,105 +256,8 @@ data Subscriber x a
261256-- the weak pointer to it in some cases.
262257
263258newSubscriberPush :: (a -> ComputeM x (Maybe b)) -> PushSubscribed x a b -> IO (Subscriber x a)
264−newSubscriberPush compute subd = return $! SubscriberPush compute subd
265−
266−newSubscriberHold :: R.Patch p => Hold x p a -> IO (Subscriber x (p a))
267−newSubscriberHold h = return $! SubscriberHold h
268−
269−newSubscriberMerge :: GCompare k => k a -> MergeSubscribed x k -> IO (Subscriber x a)
270−newSubscriberMerge k subd = return $! SubscriberMerge k subd
271−
272−newSubscriberMergeChange :: GCompare k => MergeSubscribed x k -> IO (Subscriber x (R.PatchDMap (DMap k (Event x))))
273−newSubscriberMergeChange subd = return $! SubscriberMergeChange subd
274−
275−newSubscriberFan :: GCompare k => FanSubscribed x k -> IO (Subscriber x (DMap k Identity))
276−newSubscriberFan subd = return $! SubscriberFan subd
277−
278−newSubscriberSwitch :: SwitchSubscribed x a -> IO (Subscriber x a)
279−newSubscriberSwitch subd = return $! SubscriberSwitch subd
280−
281−newSubscriberCoincidenceOuter :: CoincidenceSubscribed x b -> IO (Subscriber x (Event x b))
282−newSubscriberCoincidenceOuter subd = return $! SubscriberCoincidenceOuter subd
283−
284−newSubscriberCoincidenceInner :: CoincidenceSubscribed x a -> IO (Subscriber x a)
285−newSubscriberCoincidenceInner subd = return $! SubscriberCoincidenceInner subd
286−
287−invalidateSubscriberHeight :: Height -> Subscriber x a -> IO ()
288−invalidateSubscriberHeight old s = case s of
289− SubscriberPush _ subscribed -> do
290− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberPush" <> showNodeId subscribed
291− WeakBag.traverse (pushSubscribedSubscribers subscribed) $ invalidateSubscriberHeight old
292− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberPush" <> showNodeId subscribed <> " done"
293− SubscriberMerge _ subscribed -> do
294− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberMerge" <> showNodeId subscribed
295− removeMergeHeight old subscribed
296− invalidateMergeHeight subscribed
297− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberMerge" <> showNodeId subscribed <> " done"
298− SubscriberMergeChange _ -> return () -- Doesn't affect the height of the merge, because its changes are delayed
299− SubscriberFan subscribed -> do
300− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed
301− subscribers <- readIORef $ fanSubscribedSubscribers subscribed
302− forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ invalidateSubscriberHeight old
303− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"
304− SubscriberHold _ -> return ()
305− SubscriberHoldIdentity _ -> return ()
306− SubscriberSwitch subscribed -> do
307− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed
308− oldHeight <- readIORef $ switchSubscribedHeight subscribed
309− when (oldHeight /= invalidHeight) $ do
310− writeIORef (switchSubscribedHeight subscribed) $! invalidHeight
311− WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight
312− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed <> " done"
313− SubscriberCoincidenceOuter subscribed -> do
314− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberCoincidenceOuter" <> showNodeId subscribed
315− invalidateCoincidenceHeight subscribed
316− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberCoincidenceOuter" <> showNodeId subscribed <> " done"
317− SubscriberCoincidenceInner subscribed -> do
318− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberCoincidenceInner" <> showNodeId subscribed
319− invalidateCoincidenceHeight subscribed
320− when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberCoincidenceInner" <> showNodeId subscribed <> " done"
321− SubscriberHandle -> return ()
322−
323−recalculateSubscriberHeight :: Height -> Subscriber x a -> IO ()
324−recalculateSubscriberHeight new s = case s of
325− SubscriberPush _ subscribed -> do
326− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberPush" <> showNodeId subscribed
327− WeakBag.traverse (pushSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new
328− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberPush" <> showNodeId subscribed <> " done"
329− SubscriberMerge _ subscribed -> do
330− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberMerge" <> showNodeId subscribed
331− addMergeHeight new subscribed
332− revalidateMergeHeight subscribed
333− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberMerge" <> showNodeId subscribed <> " done"
334− SubscriberMergeChange _ -> return ()
335− SubscriberFan subscribed -> do
336− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed
337− subscribers <- readIORef $ fanSubscribedSubscribers subscribed
338− forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ recalculateSubscriberHeight new
339− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"
340− SubscriberHold _ -> return ()
341− SubscriberHoldIdentity _ -> return ()
342− SubscriberSwitch subscribed -> do
343− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed
344− updateSwitchHeight new subscribed
345− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed <> " done"
346− SubscriberCoincidenceOuter subscribed -> do
347− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberCoincidenceOuter" <> showNodeId subscribed
348− recalculateCoincidenceHeight subscribed
349− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberCoincidenceOuter" <> showNodeId subscribed <> " done"
350− SubscriberCoincidenceInner subscribed -> do
351− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberCoincidenceInner" <> showNodeId subscribed
352− recalculateCoincidenceHeight subscribed
353− when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberCoincidenceInner" <> showNodeId subscribed <> " done"
354− SubscriberHandle -> return ()
355−
356−-- | Propagate everything at the current height
357−propagate :: a -> WeakBag (Subscriber x a) -> EventM x ()
358−propagate a subscribers = withIncreasedDepth $ do
359− -- Note: in the following traversal, we do not visit nodes that are added to the list during our traversal; they are new events, which will necessarily have full information already, so there is no need to traverse them
360− --TODO: Should we check if nodes already have their values before propagating? Maybe we're re-doing work
361− WeakBag.traverse subscribers $ \s -> case s of
362− SubscriberPush compute subscribed -> {-# SCC "traversePush" #-} do
259+newSubscriberPush compute subscribed = return $ Subscriber
260+ { subscriberPropagate = \a -> {-# SCC "traversePush" #-} do
363261 tracePropagate $ "SubscriberPush" <> showNodeId subscribed
364262 occ <- runComputeM $ compute a
365263 case occ of
@@ -368,7 +266,26 @@ propagate a subscribers = withIncreasedDepth $ do
368266 liftIO $ writeIORef (pushSubscribedOccurrence subscribed) occ
369267 scheduleClear $ pushSubscribedOccurrence subscribed
370268 propagate o $ pushSubscribedSubscribers subscribed
371− SubscriberMerge k subscribed -> {-# SCC "traverseMerge" #-} do
269+ , subscriberInvalidateHeight = \old -> do
270+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberPush" <> showNodeId subscribed
271+ WeakBag.traverse (pushSubscribedSubscribers subscribed) $ invalidateSubscriberHeight old
272+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberPush" <> showNodeId subscribed <> " done"
273+ , subscriberRecalculateHeight = \new -> do
274+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberPush" <> showNodeId subscribed
275+ WeakBag.traverse (pushSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new
276+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberPush" <> showNodeId subscribed <> " done"
277+ }
278+
279+newSubscriberHold :: R.Patch p => Hold x p a -> IO (Subscriber x (p a))
280+newSubscriberHold h = return $ Subscriber
281+ { subscriberPropagate = {-# SCC "traverseHold" #-} propagateSubscriberHold h
282+ , subscriberInvalidateHeight = \old -> return ()
283+ , subscriberRecalculateHeight = \new -> return ()
284+ }
285+
286+newSubscriberMerge :: GCompare k => k a -> MergeSubscribed x k -> IO (Subscriber x a)
287+newSubscriberMerge k subscribed = return $ Subscriber
288+ { subscriberPropagate = \a -> {-# SCC "traverseMerge" #-} do
372289 tracePropagate $ "SubscriberMerge" <> showNodeId subscribed
373290 oldM <- liftIO $ readIORef $ mergeSubscribedAccum subscribed
374291 let newM = DMap.insertWith (error $ "Same key fired multiple times for Merge" <> showNodeId subscribed) k (Identity a) oldM
@@ -387,10 +304,30 @@ propagate a subscribers = withIncreasedDepth $ do
387304 stacks <- forM nodesInvolvedInCycle $ \(Some.This es) -> whoCreatedEventSubscribed es
388305 error $ "Causality loop found:\n" <> drawForest (listsToForest stacks)
389306 scheduleMerge height subscribed
390− SubscriberMergeChange subscribed -> {-# SCC "traverseMergeChange" #-} do
307+ , subscriberInvalidateHeight = \old -> do
308+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberMerge" <> showNodeId subscribed
309+ removeMergeHeight old subscribed
310+ invalidateMergeHeight subscribed
311+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberMerge" <> showNodeId subscribed <> " done"
312+ , subscriberRecalculateHeight = \new -> do
313+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberMerge" <> showNodeId subscribed
314+ addMergeHeight new subscribed
315+ revalidateMergeHeight subscribed
316+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberMerge" <> showNodeId subscribed <> " done"
317+ }
318+
319+newSubscriberMergeChange :: GCompare k => MergeSubscribed x k -> IO (Subscriber x (R.PatchDMap (DMap k (Event x))))
320+newSubscriberMergeChange subscribed = return $ Subscriber
321+ { subscriberPropagate = \a -> {-# SCC "traverseMergeChange" #-} do
391322 tracePropagate $ "SubscriberMerge" <> showNodeId subscribed
392323 defer $ SomeMergeUpdate a subscribed
393− SubscriberFan subscribed -> {-# SCC "traverseFan" #-} do
324+ , subscriberInvalidateHeight = \old -> return ()
325+ , subscriberRecalculateHeight = \new -> return ()
326+ }
327+
328+newSubscriberFan :: GCompare k => FanSubscribed x k -> IO (Subscriber x (DMap k Identity))
329+newSubscriberFan subscribed = return $ Subscriber
330+ { subscriberPropagate = \a -> {-# SCC "traverseFan" #-} do
394331 subs <- liftIO $ readIORef $ fanSubscribedSubscribers subscribed
395332 tracePropagate $ "SubscriberFan" <> showNodeId subscribed <> ": " ++ show (DMap.size subs) ++ " keys subscribed, " ++ show (DMap.size a) ++ " keys firing"
396333 --TODO: We need a better DMap intersection; here, we are assuming that the number of firing keys is small and the number of subscribers is large
@@ -401,14 +338,41 @@ propagate a subscribers = withIncreasedDepth $ do
401338 Just subsubs -> do
402339 propagate v $ _fanSubscribedChildren_list subsubs
403340 return ()
404− SubscriberHold h -> {-# SCC "traverseHold" #-} propagateSubscriberHold h a
405− SubscriberHoldIdentity h -> {-# SCC "traverseHoldIdentity" #-} propagateSubscriberHold h a
406− SubscriberSwitch subscribed -> {-# SCC "traverseSwitch" #-} do
341+ , subscriberInvalidateHeight = \old -> do
342+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed
343+ subscribers <- readIORef $ fanSubscribedSubscribers subscribed
344+ forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ invalidateSubscriberHeight old
345+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"
346+ , subscriberRecalculateHeight = \new -> do
347+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed
348+ subscribers <- readIORef $ fanSubscribedSubscribers subscribed
349+ forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ recalculateSubscriberHeight new
350+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"
351+ }
352+
353+newSubscriberSwitch :: SwitchSubscribed x a -> IO (Subscriber x a)
354+newSubscriberSwitch subscribed = return $ Subscriber
355+ { subscriberPropagate = \a -> {-# SCC "traverseSwitch" #-} do
407356 tracePropagate $ "SubscriberSwitch" <> showNodeId subscribed
408357 liftIO $ writeIORef (switchSubscribedOccurrence subscribed) $ Just a
409358 scheduleClear $ switchSubscribedOccurrence subscribed
410359 propagate a $ switchSubscribedSubscribers subscribed
411− SubscriberCoincidenceOuter subscribed -> {-# SCC "traverseCoincidenceOuter" #-} do
360+ , subscriberInvalidateHeight = \old -> do
361+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed
362+ oldHeight <- readIORef $ switchSubscribedHeight subscribed
363+ when (oldHeight /= invalidHeight) $ do
364+ writeIORef (switchSubscribedHeight subscribed) $! invalidHeight
365+ WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight
366+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed <> " done"
367+ , subscriberRecalculateHeight = \new -> do
368+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed
369+ updateSwitchHeight new subscribed
370+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed <> " done"
371+ }
372+
373+newSubscriberCoincidenceOuter :: CoincidenceSubscribed x b -> IO (Subscriber x (Event x b))
374+newSubscriberCoincidenceOuter subscribed = return $ Subscriber
375+ { subscriberPropagate = \a -> {-# SCC "traverseCoincidenceOuter" #-} do
412376 tracePropagate $ "SubscriberCoincidenceOuter" <> showNodeId subscribed
413377 outerHeight <- liftIO $ readIORef $ coincidenceSubscribedHeight subscribed
414378 tracePropagate $ " outerHeight = " <> show outerHeight
@@ -427,7 +391,19 @@ propagate a subscribers = withIncreasedDepth $ do
427391 liftIO $ writeIORef (coincidenceSubscribedOccurrence subscribed) occ
428392 scheduleClear $ coincidenceSubscribedOccurrence subscribed
429393 propagate o $ coincidenceSubscribedSubscribers subscribed
430− SubscriberCoincidenceInner subscribed -> {-# SCC "traverseCoincidenceInner" #-} do
394+ , subscriberInvalidateHeight = \old -> do
395+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberCoincidenceOuter" <> showNodeId subscribed
396+ invalidateCoincidenceHeight subscribed
397+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberCoincidenceOuter" <> showNodeId subscribed <> " done"
398+ , subscriberRecalculateHeight = \new -> do
399+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberCoincidenceOuter" <> showNodeId subscribed
400+ recalculateCoincidenceHeight subscribed
401+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberCoincidenceOuter" <> showNodeId subscribed <> " done"
402+ }
403+
404+newSubscriberCoincidenceInner :: CoincidenceSubscribed x a -> IO (Subscriber x a)
405+newSubscriberCoincidenceInner subscribed = return $ Subscriber
406+ { subscriberPropagate = \a -> {-# SCC "traverseCoincidenceInner" #-} do
431407 tracePropagate $ "SubscriberCoincidenceInner" <> showNodeId subscribed
432408 occ <- liftIO $ readIORef $ coincidenceSubscribedOccurrence subscribed
433409 case occ of
@@ -436,7 +412,28 @@ propagate a subscribers = withIncreasedDepth $ do
436412 liftIO $ writeIORef (coincidenceSubscribedOccurrence subscribed) $ Just a
437413 scheduleClear $ coincidenceSubscribedOccurrence subscribed
438414 propagate a $ coincidenceSubscribedSubscribers subscribed
439− SubscriberHandle -> {-# SCC "traverseHandle" #-} tracePropagate "SubscriberHandle"
415+ , subscriberInvalidateHeight = \old -> do
416+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberCoincidenceInner" <> showNodeId subscribed
417+ invalidateCoincidenceHeight subscribed
418+ when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberCoincidenceInner" <> showNodeId subscribed <> " done"
419+ , subscriberRecalculateHeight = \new -> do
420+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberCoincidenceInner" <> showNodeId subscribed
421+ recalculateCoincidenceHeight subscribed
422+ when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberCoincidenceInner" <> showNodeId subscribed <> " done"
423+ }
424+
425+invalidateSubscriberHeight :: Height -> Subscriber x a -> IO ()
426+invalidateSubscriberHeight = flip subscriberInvalidateHeight
427+
428+recalculateSubscriberHeight :: Height -> Subscriber x a -> IO ()
429+recalculateSubscriberHeight = flip subscriberRecalculateHeight
430+
431+-- | Propagate everything at the current height
432+propagate :: a -> WeakBag (Subscriber x a) -> EventM x ()
433+propagate a subscribers = withIncreasedDepth $ do
434+ -- Note: in the following traversal, we do not visit nodes that are added to the list during our traversal; they are new events, which will necessarily have full information already, so there is no need to traverse them
435+ --TODO: Should we check if nodes already have their values before propagating? Maybe we're re-doing work
436+ WeakBag.traverse subscribers $ \s -> subscriberPropagate s a
440437
441438--------------------------------------------------------------------------------
442439-- EventSubscribed
@@ -2117,10 +2114,17 @@ instance R.MonadHold (SpiderEnv x) (SpiderPushM x) where
21172114data RootTrigger x a = forall k. GCompare k => RootTrigger (WeakBag (Subscriber x a), IORef (DMap k Identity), k a)
21182115newtype SpiderEventHandle x a = SpiderEventHandle { unSpiderEventHandle :: EventSubscription x a }
21192116
2117+emptySubscriber :: Subscriber x a
2118+emptySubscriber = Subscriber
2119+ { subscriberPropagate = \_ -> return ()
2120+ , subscriberInvalidateHeight = \_ -> return ()
2121+ , subscriberRecalculateHeight = \_ -> return ()
2122+ }
2123+
21202124instance R.MonadSubscribeEvent (SpiderEnv x) (SpiderHostFrame x) where
21212125 {-# INLINABLE subscribeEvent #-}
21222126 subscribeEvent e = SpiderHostFrame $ do
2123− subscription <- subscribe (unSpiderEvent e) SubscriberHandle --TODO: Unsubscribe eventually (manually and/or with weak ref)
2127+ subscription <- subscribe (unSpiderEvent e) emptySubscriber --TODO: Unsubscribe eventually (manually and/or with weak ref)
21242128 return $ SpiderEventHandle subscription
21252129
21262130instance R.ReflexHost (SpiderEnv x) where
@@ -2228,7 +2232,7 @@ instance R.MonadSubscribeEvent (SpiderEnv x) (SpiderHost x) where
22282232
22292233subscribeEventSpiderHost :: R.Event (SpiderEnv x) a -> SpiderHost x (R.EventHandle (SpiderEnv x) a)
22302234subscribeEventSpiderHost e = do
2231− subscription <- runFrame $ subscribe (unSpiderEvent e) SubscriberHandle --TODO: Unsubscribe eventually (manually and/or with weak ref)
2235+ subscription <- runFrame $ subscribe (unSpiderEvent e) emptySubscriber --TODO: Unsubscribe eventually (manually and/or with weak ref)
22322236 return $ SpiderEventHandle subscription
22332237
22342238newtype ReadPhase x a = ReadPhase (ResultM x a) deriving (Functor, Applicative, Monad, MonadFix)