f3ffc4e · patch · git.iko.soy

git.iko.soy/patch

on develop help sign in

Eliminate SubscriberList and SubscriberListTicket

f3ffc4eRyan Trinkle10 years ago

src/Reflex/Spider/Internal.hs+28−31

compare with develop

unifiedsplit

@@ -76,9 +76,6 @@ import qualified Reflex.Host.Class as R

76-- Note: must come last to silence warnings due to AMP on GHC < 7.10

77import Prelude hiding (any, concat, mapM, mapM_, sequence)

79−type SubscriberList x a = WeakBag (Subscriber x a)

80−type SubscriberListTicket x a = WeakBagTicket (Subscriber x a)

81−

82debugPropagate :: Bool

79debugPropagate :: Bool

84debugInvalidateHeight :: Bool

81debugInvalidateHeight :: Bool

@@ -189,7 +186,7 @@ unsafeNodeId a = unsafePerformIO $ do

189

186

190newtype Event x a = Event { subscribe :: Subscriber x a -> EventM x (EventSubscription x a) }

187newtype Event x a = Event { subscribe :: Subscriber x a -> EventM x (EventSubscription x a) }

191

188

192−wrap :: Monad m => (t -> EventSubscribed x a) -> (Subscriber x a -> m (SubscriberListTicket x a, t)) -> Subscriber x a -> m (EventSubscription x a)

189+wrap :: Monad m => (t -> EventSubscribed x a) -> (Subscriber x a -> m (WeakBagTicket (Subscriber x a), t)) -> Subscriber x a -> m (EventSubscription x a)

193wrap tag getSpecificSubscribed sub = do

190wrap tag getSpecificSubscribed sub = do

194 (sln, subd) <- getSpecificSubscribed sub

191 (sln, subd) <- getSpecificSubscribed sub

195 return $ EventSubscription (Just sln) $ tag subd

192 return $ EventSubscription (Just sln) $ tag subd

@@ -373,7 +370,7 @@ recalculateSubscriberHeight new s = case s of

373 SubscriberHandle -> return ()

370 SubscriberHandle -> return ()

374

371

375-- | Propagate everything at the current height

372-- | Propagate everything at the current height

376−propagate :: a -> SubscriberList x a -> EventM x ()

373+propagate :: a -> WeakBag (Subscriber x a) -> EventM x ()

377propagate a subscribers = withIncreasedDepth $ do

374propagate a subscribers = withIncreasedDepth $ do

378 -- 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

375 -- 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

379 --TODO: Should we check if nodes already have their values before propagating? Maybe we're re-doing work

376 --TODO: Should we check if nodes already have their values before propagating? Maybe we're re-doing work

@@ -481,7 +478,7 @@ readEventSubscribed = \case

481 EventSubscribedCoincidence cs -> readCoincidenceSubscribed cs

478 EventSubscribedCoincidence cs -> readCoincidenceSubscribed cs

482

479

483{-# INLINE subscribeEventSubscribed #-}

480{-# INLINE subscribeEventSubscribed #-}

484−subscribeEventSubscribed :: EventSubscribed x a -> Subscriber x a -> IO (Maybe (SubscriberListTicket x a))

481+subscribeEventSubscribed :: EventSubscribed x a -> Subscriber x a -> IO (Maybe (WeakBagTicket (Subscriber x a)))

485subscribeEventSubscribed es sub = case es of

482subscribeEventSubscribed es sub = case es of

486 EventSubscribedRoot r -> do

483 EventSubscribedRoot r -> do

487 traceSubscribe $ "subscribeEventSubscribed Root"

484 traceSubscribe $ "subscribeEventSubscribed Root"

@@ -582,7 +579,7 @@ subscribeHoldEvent h sub = do

582--------------------------------------------------------------------------------

579--------------------------------------------------------------------------------

583

580

584data EventSubscription x a = EventSubscription

581data EventSubscription x a = EventSubscription

585− { _eventSubscription_ticket :: !(Maybe (SubscriberListTicket x a))

582+ { _eventSubscription_ticket :: !(Maybe (WeakBagTicket (Subscriber x a)))

586 , _eventSubscription_subscribed :: !(EventSubscribed x a)

583 , _eventSubscription_subscribed :: !(EventSubscribed x a)

587 }

584 }

588

585

@@ -796,7 +793,7 @@ data Invalidator x

796data RootSubscribed x a = forall k. GCompare k => RootSubscribed

793data RootSubscribed x a = forall k. GCompare k => RootSubscribed

797 { rootSubscribedKey :: !(k a)

794 { rootSubscribedKey :: !(k a)

798 , rootSubscribedCachedSubscribed :: !(IORef (DMap k (RootSubscribed x))) -- From the original Root

795 , rootSubscribedCachedSubscribed :: !(IORef (DMap k (RootSubscribed x))) -- From the original Root

799− , rootSubscribedSubscribers :: !(SubscriberList x a)

796+ , rootSubscribedSubscribers :: !(WeakBag (Subscriber x a))

800 , rootSubscribedOccurrence :: !(IO (Maybe a)) -- Lookup from rootOccurrence

797 , rootSubscribedOccurrence :: !(IO (Maybe a)) -- Lookup from rootOccurrence

801 , rootSubscribedUninit :: IO ()

798 , rootSubscribedUninit :: IO ()

802 , rootSubscribedWeakSelf :: !(IORef (Weak (RootSubscribed x a))) --TODO: Can we make this a lazy non-IORef and then force it manually to avoid an indirection each time we use it?

799 , rootSubscribedWeakSelf :: !(IORef (Weak (RootSubscribed x a))) --TODO: Can we make this a lazy non-IORef and then force it manually to avoid an indirection each time we use it?

@@ -826,7 +823,7 @@ data PushSubscribed x a b

826 = PushSubscribed { pushSubscribedCachedSubscribed :: !(IORef (Maybe (PushSubscribed x a b)))

823 = PushSubscribed { pushSubscribedCachedSubscribed :: !(IORef (Maybe (PushSubscribed x a b)))

827 , pushSubscribedOccurrence :: !(IORef (Maybe b)) -- If the current height is less than our height, this should always be Nothing; during our height, this will get filled in at some point, always before our children are notified; after our height, this will be filled in with the correct value (Nothing if we are not firing, Just if we are)

824 , pushSubscribedOccurrence :: !(IORef (Maybe b)) -- If the current height is less than our height, this should always be Nothing; during our height, this will get filled in at some point, always before our children are notified; after our height, this will be filled in with the correct value (Nothing if we are not firing, Just if we are)

828 , pushSubscribedHeight :: !(IORef Height)

825 , pushSubscribedHeight :: !(IORef Height)

829− , pushSubscribedSubscribers :: !(SubscriberList x b)

826+ , pushSubscribedSubscribers :: !(WeakBag (Subscriber x b))

830 , pushSubscribedSelf :: !(Subscriber x a) -- Hold this in memory to ensure our WeakReferences don't die --TODO: Probably unneeded now

827 , pushSubscribedSelf :: !(Subscriber x a) -- Hold this in memory to ensure our WeakReferences don't die --TODO: Probably unneeded now

831 , pushSubscribedWeakSelf :: !(IORef (Weak (PushSubscribed x a b)))

828 , pushSubscribedWeakSelf :: !(IORef (Weak (PushSubscribed x a b)))

832 , pushSubscribedParent :: !(EventSubscription x a)

829 , pushSubscribedParent :: !(EventSubscription x a)

@@ -903,7 +900,7 @@ data MergeSubscribed x k

903 , mergeSubscribedAccum :: !(IORef (DMap k Identity)) -- This will accumulate occurrences until our height is reached, at which point it will be transferred to mergeSubscribedOccurrence

900 , mergeSubscribedAccum :: !(IORef (DMap k Identity)) -- This will accumulate occurrences until our height is reached, at which point it will be transferred to mergeSubscribedOccurrence

904 , mergeSubscribedHeight :: !(IORef Height)

901 , mergeSubscribedHeight :: !(IORef Height)

905 , mergeSubscribedHeightBag :: !(IORef HeightBag)

902 , mergeSubscribedHeightBag :: !(IORef HeightBag)

906− , mergeSubscribedSubscribers :: !(SubscriberList x (DMap k Identity))

903+ , mergeSubscribedSubscribers :: !(WeakBag (Subscriber x (DMap k Identity)))

907 , mergeSubscribedChange :: !(IORef (Subscriber x (R.PatchDMap (DMap k (Event x))), EventSubscribed x (R.PatchDMap (DMap k (Event x)))))

904 , mergeSubscribedChange :: !(IORef (Subscriber x (R.PatchDMap (DMap k (Event x))), EventSubscribed x (R.PatchDMap (DMap k (Event x)))))

908 , mergeSubscribedParents :: !(IORef (DMap k (MergeSubscribedParent x k)))

905 , mergeSubscribedParents :: !(IORef (DMap k (MergeSubscribedParent x k)))

909 , mergeSubscribedWeakSelf :: !(IORef (Weak (MergeSubscribed x k)))

906 , mergeSubscribedWeakSelf :: !(IORef (Weak (MergeSubscribed x k)))

@@ -919,7 +916,7 @@ data Merge x k

919 }

916 }

920

917

921data FanSubscribedChildren (x :: *) k a = FanSubscribedChildren

918data FanSubscribedChildren (x :: *) k a = FanSubscribedChildren

922− { _fanSubscribedChildren_list :: !(SubscriberList x a)

919+ { _fanSubscribedChildren_list :: !(WeakBag (Subscriber x a))

923 , _fanSubscribedChildren_self :: {-# NOUNPACK #-} !(k a, FanSubscribed x k)

920 , _fanSubscribedChildren_self :: {-# NOUNPACK #-} !(k a, FanSubscribed x k)

924 , _fanSubscribedChildren_weakSelf :: !(IORef (Weak (k a, FanSubscribed x k)))

921 , _fanSubscribedChildren_weakSelf :: !(IORef (Weak (k a, FanSubscribed x k)))

925 }

922 }

@@ -942,7 +939,7 @@ data SwitchSubscribed x a

942 = SwitchSubscribed { switchSubscribedCachedSubscribed :: !(IORef (Maybe (SwitchSubscribed x a)))

939 = SwitchSubscribed { switchSubscribedCachedSubscribed :: !(IORef (Maybe (SwitchSubscribed x a)))

943 , switchSubscribedOccurrence :: !(IORef (Maybe a))

940 , switchSubscribedOccurrence :: !(IORef (Maybe a))

944 , switchSubscribedHeight :: !(IORef Height)

941 , switchSubscribedHeight :: !(IORef Height)

945− , switchSubscribedSubscribers :: !(SubscriberList x a)

942+ , switchSubscribedSubscribers :: !(WeakBag (Subscriber x a))

946 , switchSubscribedOwnInvalidator :: {-# NOUNPACK #-} !(Invalidator x)

943 , switchSubscribedOwnInvalidator :: {-# NOUNPACK #-} !(Invalidator x)

947 , switchSubscribedOwnWeakInvalidator :: !(IORef (Weak (Invalidator x)))

944 , switchSubscribedOwnWeakInvalidator :: !(IORef (Weak (Invalidator x)))

948 , switchSubscribedBehaviorParents :: !(IORef [SomeBehaviorSubscribed x])

945 , switchSubscribedBehaviorParents :: !(IORef [SomeBehaviorSubscribed x])

@@ -963,7 +960,7 @@ data Switch x a

963data CoincidenceSubscribed x a

960data CoincidenceSubscribed x a

964 = CoincidenceSubscribed { coincidenceSubscribedCachedSubscribed :: !(IORef (Maybe (CoincidenceSubscribed x a)))

961 = CoincidenceSubscribed { coincidenceSubscribedCachedSubscribed :: !(IORef (Maybe (CoincidenceSubscribed x a)))

965 , coincidenceSubscribedOccurrence :: !(IORef (Maybe a))

962 , coincidenceSubscribedOccurrence :: !(IORef (Maybe a))

966− , coincidenceSubscribedSubscribers :: !(SubscriberList x a)

963+ , coincidenceSubscribedSubscribers :: !(WeakBag (Subscriber x a))

967 , coincidenceSubscribedHeight :: !(IORef Height)

964 , coincidenceSubscribedHeight :: !(IORef Height)

968 , coincidenceSubscribedOuter :: {-# NOUNPACK #-} (Subscriber x (Event x a))

965 , coincidenceSubscribedOuter :: {-# NOUNPACK #-} (Subscriber x (Event x a))

969 , coincidenceSubscribedOuterParent :: !(EventSubscription x (Event x a))

966 , coincidenceSubscribedOuterParent :: !(EventSubscription x (Event x a))

@@ -1405,7 +1402,7 @@ type CanSubscribe x m =

1405 , m ~ EventM x

1402 , m ~ EventM x

1406 )

1403 )

1407

1404

1408−getRootSubscribed :: GCompare k => k a -> Root x k -> Subscriber x a -> IO (SubscriberListTicket x a, RootSubscribed x a)

1405+getRootSubscribed :: GCompare k => k a -> Root x k -> Subscriber x a -> IO (WeakBagTicket (Subscriber x a), RootSubscribed x a)

1409getRootSubscribed k r sub = do

1406getRootSubscribed k r sub = do

1410 mSubscribed <- readIORef $ rootSubscribed r

1407 mSubscribed <- readIORef $ rootSubscribed r

1411 case DMap.lookup k mSubscribed of

1408 case DMap.lookup k mSubscribed of

@@ -1442,12 +1439,12 @@ cleanupRootSubscribed self@(RootSubscribed { rootSubscribedKey = k, rootSubscrib

1442 modifyIORef' cached $ DMap.delete k

1439 modifyIORef' cached $ DMap.delete k

1443

1440

1444{-# INLINE subscribeRootSubscribed #-}

1441{-# INLINE subscribeRootSubscribed #-}

1445−subscribeRootSubscribed :: RootSubscribed x a -> Subscriber x a -> IO (SubscriberListTicket x a)

1442+subscribeRootSubscribed :: RootSubscribed x a -> Subscriber x a -> IO (WeakBagTicket (Subscriber x a))

1446subscribeRootSubscribed subscribed sub = WeakBag.insert sub (rootSubscribedSubscribers subscribed) (rootSubscribedWeakSelf subscribed) cleanupRootSubscribed

1443subscribeRootSubscribed subscribed sub = WeakBag.insert sub (rootSubscribedSubscribers subscribed) (rootSubscribedWeakSelf subscribed) cleanupRootSubscribed

1447

1444

1448-- When getPushSubscribed returns, the PushSubscribed returned will have a fully filled-in

1445-- When getPushSubscribed returns, the PushSubscribed returned will have a fully filled-in

1449−{-# SPECIALIZE getPushSubscribed :: Push x a b -> Subscriber x b -> EventM x (SubscriberListTicket x b, PushSubscribed x a b) #-}

1446+{-# SPECIALIZE getPushSubscribed :: Push x a b -> Subscriber x b -> EventM x (WeakBagTicket (Subscriber x b), PushSubscribed x a b) #-}

1450−getPushSubscribed :: CanSubscribe x m => Push x a b -> Subscriber x b -> m (SubscriberListTicket x b, PushSubscribed x a b)

1447+getPushSubscribed :: CanSubscribe x m => Push x a b -> Subscriber x b -> m (WeakBagTicket (Subscriber x b), PushSubscribed x a b)

1451getPushSubscribed p sub = do

1448getPushSubscribed p sub = do

1452 mSubscribed <- liftIO $ readIORef $ pushSubscribed p

1449 mSubscribed <- liftIO $ readIORef $ pushSubscribed p

1453 case mSubscribed of

1450 case mSubscribed of

@@ -1489,11 +1486,11 @@ cleanupPushSubscribed self = do

1489 writeIORef (pushSubscribedCachedSubscribed self) $ Nothing

1486 writeIORef (pushSubscribedCachedSubscribed self) $ Nothing

1490

1487

1491{-# INLINE subscribePushSubscribed #-}

1488{-# INLINE subscribePushSubscribed #-}

1492−subscribePushSubscribed :: PushSubscribed x a b -> Subscriber x b -> IO (SubscriberListTicket x b)

1489+subscribePushSubscribed :: PushSubscribed x a b -> Subscriber x b -> IO (WeakBagTicket (Subscriber x b))

1493subscribePushSubscribed subscribed sub = WeakBag.insert sub (pushSubscribedSubscribers subscribed) (pushSubscribedWeakSelf subscribed) cleanupPushSubscribed

1490subscribePushSubscribed subscribed sub = WeakBag.insert sub (pushSubscribedSubscribers subscribed) (pushSubscribedWeakSelf subscribed) cleanupPushSubscribed

1494

1491

1495−{-# SPECIALIZE getMergeSubscribed :: GCompare k => Merge x k -> Subscriber x (DMap k Identity) -> EventM x (SubscriberListTicket x (DMap k Identity), MergeSubscribed x k) #-}

1492+{-# SPECIALIZE getMergeSubscribed :: GCompare k => Merge x k -> Subscriber x (DMap k Identity) -> EventM x (WeakBagTicket (Subscriber x (DMap k Identity)), MergeSubscribed x k) #-}

1496−getMergeSubscribed :: forall x k m. (CanSubscribe x m, GCompare k) => Merge x k -> Subscriber x (DMap k Identity) -> m (SubscriberListTicket x (DMap k Identity), MergeSubscribed x k)

1493+getMergeSubscribed :: forall x k m. (CanSubscribe x m, GCompare k) => Merge x k -> Subscriber x (DMap k Identity) -> m (WeakBagTicket (Subscriber x (DMap k Identity)), MergeSubscribed x k)

1497getMergeSubscribed m sub = do

1494getMergeSubscribed m sub = do

1498 mSubscribed <- liftIO $ readIORef $ mergeSubscribed m

1495 mSubscribed <- liftIO $ readIORef $ mergeSubscribed m

1499 case mSubscribed of

1496 case mSubscribed of

@@ -1559,11 +1556,11 @@ cleanupMergeSubscribed subscribed = do

1559 writeIORef (mergeSubscribedCachedSubscribed subscribed) $ Nothing -- Get rid of the cached subscribed

1556 writeIORef (mergeSubscribedCachedSubscribed subscribed) $ Nothing -- Get rid of the cached subscribed

1560

1557

1561{-# INLINE subscribeMergeSubscribed #-}

1558{-# INLINE subscribeMergeSubscribed #-}

1562−subscribeMergeSubscribed :: MergeSubscribed x k -> Subscriber x (DMap k Identity) -> IO (SubscriberListTicket x (DMap k Identity))

1559+subscribeMergeSubscribed :: MergeSubscribed x k -> Subscriber x (DMap k Identity) -> IO (WeakBagTicket (Subscriber x (DMap k Identity)))

1563subscribeMergeSubscribed subscribed sub = WeakBag.insert sub (mergeSubscribedSubscribers subscribed) (mergeSubscribedWeakSelf subscribed) cleanupMergeSubscribed

1560subscribeMergeSubscribed subscribed sub = WeakBag.insert sub (mergeSubscribedSubscribers subscribed) (mergeSubscribedWeakSelf subscribed) cleanupMergeSubscribed

1564

1561

1565−{-# SPECIALIZE getFanSubscribed :: GCompare k => k a -> Fan x k -> Subscriber x a -> EventM x (SubscriberListTicket x a, FanSubscribed x k) #-}

1562+{-# SPECIALIZE getFanSubscribed :: GCompare k => k a -> Fan x k -> Subscriber x a -> EventM x (WeakBagTicket (Subscriber x a), FanSubscribed x k) #-}

1566−getFanSubscribed :: (Defer (SomeAssignment x) m, Defer (SomeHoldInit x) m, Defer (SomeMergeInit x) m, Defer SomeClear m, HasCurrentHeight x m, Defer (SomeResetCoincidence x) m, HasSpiderEnv x m, m ~ EventM x, GCompare k) => k a -> Fan x k -> Subscriber x a -> m (SubscriberListTicket x a, FanSubscribed x k)

1563+getFanSubscribed :: (Defer (SomeAssignment x) m, Defer (SomeHoldInit x) m, Defer (SomeMergeInit x) m, Defer SomeClear m, HasCurrentHeight x m, Defer (SomeResetCoincidence x) m, HasSpiderEnv x m, m ~ EventM x, GCompare k) => k a -> Fan x k -> Subscriber x a -> m (WeakBagTicket (Subscriber x a), FanSubscribed x k)

1567getFanSubscribed k f sub = do

1564getFanSubscribed k f sub = do

1568 mSubscribed <- liftIO $ readIORef $ fanSubscribed f

1565 mSubscribed <- liftIO $ readIORef $ fanSubscribed f

1569 case mSubscribed of

1566 case mSubscribed of

@@ -1605,7 +1602,7 @@ cleanupFanSubscribed (k, subscribed) = do

1605 else writeIORef (fanSubscribedSubscribers subscribed) $! reducedSubscribers

1602 else writeIORef (fanSubscribedSubscribers subscribed) $! reducedSubscribers

1606

1603

1607{-# INLINE subscribeFanSubscribed #-}

1604{-# INLINE subscribeFanSubscribed #-}

1608−subscribeFanSubscribed :: GCompare k => k a -> FanSubscribed x k -> Subscriber x a -> IO (SubscriberListTicket x a)

1605+subscribeFanSubscribed :: GCompare k => k a -> FanSubscribed x k -> Subscriber x a -> IO (WeakBagTicket (Subscriber x a))

1609subscribeFanSubscribed k subscribed sub = do

1606subscribeFanSubscribed k subscribed sub = do

1610 subscribers <- readIORef $ fanSubscribedSubscribers subscribed

1607 subscribers <- readIORef $ fanSubscribedSubscribers subscribed

1611 case DMap.lookup k subscribers of

1608 case DMap.lookup k subscribers of

@@ -1617,8 +1614,8 @@ subscribeFanSubscribed k subscribed sub = do

1617 return sln

1614 return sln

1618 Just (FanSubscribedChildren list _ weakSelf) -> {-# SCC "hitSubscribeFanSubscribed" #-} WeakBag.insert sub list weakSelf cleanupFanSubscribed

1615 Just (FanSubscribedChildren list _ weakSelf) -> {-# SCC "hitSubscribeFanSubscribed" #-} WeakBag.insert sub list weakSelf cleanupFanSubscribed

1619

1616

1620−{-# SPECIALIZE getSwitchSubscribed :: Switch x a -> Subscriber x a -> EventM x (SubscriberListTicket x a, SwitchSubscribed x a) #-}

1617+{-# SPECIALIZE getSwitchSubscribed :: Switch x a -> Subscriber x a -> EventM x (WeakBagTicket (Subscriber x a), SwitchSubscribed x a) #-}

1621−getSwitchSubscribed :: (Defer (SomeHoldInit x) m, Defer (SomeAssignment x) m, Defer (SomeMergeInit x) m, Defer SomeClear m, Defer (SomeResetCoincidence x) m, HasCurrentHeight x m, HasSpiderEnv x m, m ~ EventM x) => Switch x a -> Subscriber x a -> m (SubscriberListTicket x a, SwitchSubscribed x a)

1618+getSwitchSubscribed :: (Defer (SomeHoldInit x) m, Defer (SomeAssignment x) m, Defer (SomeMergeInit x) m, Defer SomeClear m, Defer (SomeResetCoincidence x) m, HasCurrentHeight x m, HasSpiderEnv x m, m ~ EventM x) => Switch x a -> Subscriber x a -> m (WeakBagTicket (Subscriber x a), SwitchSubscribed x a)

1622getSwitchSubscribed s sub = do

1619getSwitchSubscribed s sub = do

1623 mSubscribed <- liftIO $ readIORef $ switchSubscribed s

1620 mSubscribed <- liftIO $ readIORef $ switchSubscribed s

1624 case mSubscribed of

1621 case mSubscribed of

@@ -1670,11 +1667,11 @@ cleanupSwitchSubscribed subscribed = do

1670 writeIORef (switchSubscribedCachedSubscribed subscribed) Nothing

1667 writeIORef (switchSubscribedCachedSubscribed subscribed) Nothing

1671

1668

1672{-# INLINE subscribeSwitchSubscribed #-}

1669{-# INLINE subscribeSwitchSubscribed #-}

1673−subscribeSwitchSubscribed :: SwitchSubscribed x a -> Subscriber x a -> IO (SubscriberListTicket x a)

1670+subscribeSwitchSubscribed :: SwitchSubscribed x a -> Subscriber x a -> IO (WeakBagTicket (Subscriber x a))

1674subscribeSwitchSubscribed subscribed sub = WeakBag.insert sub (switchSubscribedSubscribers subscribed) (switchSubscribedWeakSelf subscribed) cleanupSwitchSubscribed

1671subscribeSwitchSubscribed subscribed sub = WeakBag.insert sub (switchSubscribedSubscribers subscribed) (switchSubscribedWeakSelf subscribed) cleanupSwitchSubscribed

1675

1672

1676−{-# SPECIALIZE getCoincidenceSubscribed :: Coincidence x a -> Subscriber x a -> EventM x (SubscriberListTicket x a, CoincidenceSubscribed x a) #-}

1673+{-# SPECIALIZE getCoincidenceSubscribed :: Coincidence x a -> Subscriber x a -> EventM x (WeakBagTicket (Subscriber x a), CoincidenceSubscribed x a) #-}

1677−getCoincidenceSubscribed :: forall x a m. (Defer (SomeAssignment x) m, Defer (SomeHoldInit x) m, Defer (SomeMergeInit x) m, Defer SomeClear m, HasCurrentHeight x m, Defer (SomeResetCoincidence x) m, HasSpiderEnv x m, m ~ EventM x) => Coincidence x a -> Subscriber x a -> m (SubscriberListTicket x a, CoincidenceSubscribed x a)

1674+getCoincidenceSubscribed :: forall x a m. (Defer (SomeAssignment x) m, Defer (SomeHoldInit x) m, Defer (SomeMergeInit x) m, Defer SomeClear m, HasCurrentHeight x m, Defer (SomeResetCoincidence x) m, HasSpiderEnv x m, m ~ EventM x) => Coincidence x a -> Subscriber x a -> m (WeakBagTicket (Subscriber x a), CoincidenceSubscribed x a)

1678getCoincidenceSubscribed c sub = do

1675getCoincidenceSubscribed c sub = do

1679 mSubscribed <- liftIO $ readIORef $ coincidenceSubscribed c

1676 mSubscribed <- liftIO $ readIORef $ coincidenceSubscribed c

1680 case mSubscribed of

1677 case mSubscribed of

@@ -1724,7 +1721,7 @@ cleanupCoincidenceSubscribed subscribed = do

1724 writeIORef (coincidenceSubscribedCachedSubscribed subscribed) Nothing

1721 writeIORef (coincidenceSubscribedCachedSubscribed subscribed) Nothing

1725

1722

1726{-# INLINE subscribeCoincidenceSubscribed #-}

1723{-# INLINE subscribeCoincidenceSubscribed #-}

1727−subscribeCoincidenceSubscribed :: CoincidenceSubscribed x a -> Subscriber x a -> IO (SubscriberListTicket x a)

1724+subscribeCoincidenceSubscribed :: CoincidenceSubscribed x a -> Subscriber x a -> IO (WeakBagTicket (Subscriber x a))

1728subscribeCoincidenceSubscribed subscribed sub = WeakBag.insert sub (coincidenceSubscribedSubscribers subscribed) (coincidenceSubscribedWeakSelf subscribed) cleanupCoincidenceSubscribed

1725subscribeCoincidenceSubscribed subscribed sub = WeakBag.insert sub (coincidenceSubscribedSubscribers subscribed) (coincidenceSubscribedWeakSelf subscribed) cleanupCoincidenceSubscribed

1729

1726

1730{-# INLINE merge #-}

1727{-# INLINE merge #-}

@@ -2133,7 +2130,7 @@ instance R.MonadHold (SpiderEnv x) (SpiderPushM x) where

2133 {-# INLINABLE holdIncremental #-}

2130 {-# INLINABLE holdIncremental #-}

2134 holdIncremental v0 (SpiderEvent e) = SpiderPushM $ SpiderIncremental . DynamicHold <$> hold v0 e

2131 holdIncremental v0 (SpiderEvent e) = SpiderPushM $ SpiderIncremental . DynamicHold <$> hold v0 e

2135

2132

2136−data RootTrigger x a = forall k. GCompare k => RootTrigger (SubscriberList x a, IORef (DMap k Identity), k a)

2133+data RootTrigger x a = forall k. GCompare k => RootTrigger (WeakBag (Subscriber x a), IORef (DMap k Identity), k a)

2137newtype SpiderEventHandle x a = SpiderEventHandle { unSpiderEventHandle :: EventSubscription x a }

2134newtype SpiderEventHandle x a = SpiderEventHandle { unSpiderEventHandle :: EventSubscription x a }

2138

2135

2139instance R.MonadSubscribeEvent (SpiderEnv x) (SpiderHostFrame x) where

2136instance R.MonadSubscribeEvent (SpiderEnv x) (SpiderHostFrame x) where