90cb9df · patch · git.iko.soy

215putCurrentHeight :: Height -> EventM x ()

216putCurrentHeight h = EventM $ do

217 heightRef <- asks eventEnvCurrentHeight

218− liftIO $ writeIORef heightRef h

218+ liftIO $ writeIORef heightRef $! h

219

220instance Defer SomeClear (EventM x) where

221 {-# INLINE getDeferralQueue #-}

288-}

289 -}

290 subscription@(EventSubscription _ subd) <- subscribe e =<< liftIO (newSubscriberHold h)

291− liftIO $ writeIORef subscriptionRef subscription

291+ liftIO $ writeIORef subscriptionRef $! subscription

292 occ <- liftIO $ readEventSubscribed subd

293 case occ of

294 Nothing -> return ()

301 v <- liftIO $ evaluate $ holdValue h

302 i <- liftIO $ evaluate $ holdInvalidators h

303 defer $ SomeAssignment v i new

304− liftIO $ writeIORef (holdParent h) $ Right subscription

304+ liftIO $ writeIORef (holdParent h) $! Right subscription

305 return subscription

306

307type BehaviorEnv = (Maybe (Weak Invalidator, IORef [SomeBehaviorSubscribed]), IORef [SomeHoldInit])

826 Just ((currentHeight, cur), future) -> do

827 tracePropagate $ "Running height " ++ show currentHeight

828 putCurrentHeight $ Height currentHeight

829− liftIO $ writeIORef delayedRef future

829+ liftIO $ writeIORef delayedRef $! future

830 forM_ cur $ \d -> case d of

831 DelayedMerge subscribed -> do

832 height <- liftIO $ readIORef $ mergeSubscribedHeight subscribed

835 GT -> scheduleMerge height subscribed -- The height has been increased (by a coincidence event; TODO: is this the only way?)

836 EQ -> do

837 m <- liftIO $ readIORef $ mergeSubscribedAccum subscribed

838− liftIO $ writeIORef (mergeSubscribedAccum subscribed) DMap.empty

838+ liftIO $ writeIORef (mergeSubscribedAccum subscribed) $! DMap.empty

839 --TODO: Assert that m is not empty

840− liftIO $ writeIORef (mergeSubscribedOccurrence subscribed) $ Just m

840+ liftIO $ writeIORef (mergeSubscribedOccurrence subscribed) $! Just m

841 scheduleClear $ mergeSubscribedOccurrence subscribed

842 propagateAndUpdateSubscribersRef (mergeSubscribedSubscribers subscribed) m

843 go

930 subscribers <- flip execStateT mempty $ ($ Some.This s0) $ fix $ \loop (Some.This s) -> do

931 h <- liftIO $ readIORef $ eventSubscribedHeightRef s

932 when (h == invalidHeight) $ do

933− when (eventSubscribedHasOwnHeightRef s) $ liftIO $ writeIORef (eventSubscribedHeightRef s) invalidHeightBeingTraversed

933+ when (eventSubscribedHasOwnHeightRef s) $ liftIO $ writeIORef (eventSubscribedHeightRef s) $! invalidHeightBeingTraversed

934 modify (Some.This s :)

935 mapM_ loop =<< liftIO (eventSubscribedGetParents s)

936− forM_ subscribers $ \(Some.This s) -> writeIORef (eventSubscribedHeightRef s) invalidHeight

936+ forM_ subscribers $ \(Some.This s) -> writeIORef (eventSubscribedHeightRef s) $! invalidHeight

937 return subscribers

938

939groupByHead :: Eq a => [NonEmpty a] -> [(a, NonEmpty [a])]

1000 SubscriberHoldIdentity h -> {-# SCC "traverseHoldIdentity" #-} propagateSubscriberHold h a

1001 SubscriberSwitch subscribed -> {-# SCC "traverseSwitch" #-} do

1002 tracePropagate $ "SubscriberSwitch" <> showNodeId subscribed

1003− liftIO $ writeIORef (switchSubscribedOccurrence subscribed) $ Just a

1003+ liftIO $ writeIORef (switchSubscribedOccurrence subscribed) $! Just a

1004 scheduleClear $ switchSubscribedOccurrence subscribed

1005 propagate a $ switchSubscribedSubscribers subscribed

1006 SubscriberCoincidenceOuter subscribed -> {-# SCC "traverseCoincidenceOuter" #-} do

1010 (occ, innerHeight, innerSubd) <- subscribeCoincidenceInner a outerHeight subscribed

1011 tracePropagate $ " isJust occ = " <> show (isJust occ)

1012 tracePropagate $ " innerHeight = " <> show innerHeight

1013− liftIO $ writeIORef (coincidenceSubscribedInnerParent subscribed) $ Just innerSubd

1013+ liftIO $ writeIORef (coincidenceSubscribedInnerParent subscribed) $! Just innerSubd

1014 scheduleClear $ coincidenceSubscribedInnerParent subscribed

1015 case occ of

1016 Nothing -> do

1017 when (innerHeight > outerHeight) $ liftIO $ do -- If the event fires, it will fire at a later height

1018− writeIORef (coincidenceSubscribedHeight subscribed) innerHeight

1018+ writeIORef (coincidenceSubscribedHeight subscribed) $! innerHeight

1019 WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight outerHeight

1020 WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight innerHeight

1021 Just o -> do -- Since it's already firing, no need to adjust height

1028 case occ of

1029 Just _ -> return () -- SubscriberCoincidenceOuter must have already propagated this event

1030 Nothing -> do

1031− liftIO $ writeIORef (coincidenceSubscribedOccurrence subscribed) $ Just a

1031+ liftIO $ writeIORef (coincidenceSubscribedOccurrence subscribed) $! Just a

1032 scheduleClear $ coincidenceSubscribedOccurrence subscribed

1033 propagate a $ coincidenceSubscribedSubscribers subscribed

1034 SubscriberHandle -> {-# SCC "traverseHandle" #-} tracePropagate "SubscriberHandle"

1107 , pullSubscribedOwnInvalidator = i

1108 , pullSubscribedParents = parents

1109 }

1110− liftIO $ writeIORef (pullValue p) $ Just subscribed

1110+ liftIO $ writeIORef (pullValue p) $! Just subscribed

1111 askParentsRef >>= mapM_ (\r -> liftIO $ modifyIORef' r (SomeBehaviorSubscribed (BehaviorSubscribedPull subscribed) :))

1112 return a

1113 BehaviorDyn d -> readHoldTracked =<< getDynHold d

1131 holdInits <- getDeferralQueue

1132 v0 <- liftIO $ runBehaviorM readV0 Nothing holdInits

1133 h <- hold v0 v'

1134− liftIO $ writeIORef (unDyn d) $ Right h

1134+ liftIO $ writeIORef (unDyn d) $! Right h

1135 return h

1136

1137{-

1328 (subs, sln) <- WeakBag.singleton sub weakSelf cleanupRootSubscribed

1329 when debugPropagate $ putStrLn $ "getRootSubscribed: calling rootInit"

1330 uninit <- rootInit r k $ RootTrigger (subs, rootOccurrence r, k)

1331− writeIORef uninitRef uninit

1331+ writeIORef uninitRef $! uninit

1332 let subscribed = RootSubscribed

1333 { rootSubscribedKey = k

1334 , rootSubscribedCachedSubscribed = cached

1340 , rootSubscribedNodeId = unsafeNodeId (k, r, subs)

1341#endif

1342 }

1343− writeIORef weakSelf =<< mkWeakPtrWithDebug subscribed "RootSubscribed"

1343+ writeIORef weakSelf =<< evaluate =<< mkWeakPtrWithDebug subscribed "RootSubscribed"

1344 modifyIORef' (rootSubscribed r) $ DMap.insertWith (error $ "getRootSubscribed: duplicate key inserted into Root") k subscribed --TODO: I think we can just write back mSubscribed rather than re-reading it

1345 return (sln, subscribed)

1346

1386 , pushSubscribedNodeId = unsafeNodeId p

1387#endif

1388 }

1389− liftIO $ writeIORef weakSelf =<< mkWeakPtrWithDebug subscribed "PushSubscribed"

1389+ liftIO $ writeIORef weakSelf =<< evaluate =<< mkWeakPtrWithDebug subscribed "PushSubscribed"

1390− liftIO $ writeIORef subscribedRef subscribed

1390+ liftIO $ writeIORef subscribedRef $! subscribed

1391− liftIO $ writeIORef (pushSubscribed p) $ Just subscribed

1391+ liftIO $ writeIORef (pushSubscribed p) $! Just subscribed

1392 return (sln, subscribed)

1393

1394cleanupPushSubscribed :: PushSubscribed a b -> IO ()

1395cleanupPushSubscribed self = do

1396 unsubscribe $ pushSubscribedParent self

1397− writeIORef (pushSubscribedCachedSubscribed self) Nothing

1397+ writeIORef (pushSubscribedCachedSubscribed self) $! Nothing

1398

1399{-# INLINE subscribePushSubscribed #-}

1400subscribePushSubscribed :: PushSubscribed a b -> Subscriber b -> IO (SubscriberListTicket b)

1454#endif

1455 }

1456 defer $ SomeMergeInit subscribed $ updated $ mergeParents m

1457− liftIO $ writeIORef subscribedRef subscribed

1457+ liftIO $ writeIORef subscribedRef $! subscribed

1458− liftIO $ writeIORef weakSelf =<< mkWeakPtrWithDebug subscribed "MergeSubscribed"

1458+ liftIO $ writeIORef weakSelf =<< evaluate =<< mkWeakPtrWithDebug subscribed "MergeSubscribed"

1459− liftIO $ writeIORef (mergeSubscribed m) $ Just subscribed

1459+ liftIO $ writeIORef (mergeSubscribed m) $! Just subscribed

1460 return (sln, subscribed)

1461

1462cleanupMergeSubscribed :: MergeSubscribed k -> IO ()

1464 parents <- readIORef $ mergeSubscribedParents subscribed

1465 forM_ (DMap.toList parents) $ \(_ :=> msp) -> unsubscribe $ mergeSubscribedParentSubscription msp

1466 -- Not necessary, because this whole MergeSubscribed is dead: writeIORef (mergeSubscribedParents subscribed) DMap.empty

1467− writeIORef (mergeSubscribedCachedSubscribed subscribed) Nothing -- Get rid of the cached subscribed

1467+ writeIORef (mergeSubscribedCachedSubscribed subscribed) $! Nothing -- Get rid of the cached subscribed

1468

1469{-# INLINE subscribeMergeSubscribed #-}

1470subscribeMergeSubscribed :: MergeSubscribed k -> Subscriber (DMap k Identity) -> IO (SubscriberListTicket (DMap k Identity))

1494 , fanSubscribedNodeId = unsafeNodeId f

1495#endif

1496 }

1497− liftIO $ writeIORef weakSelf =<< mkWeakPtrWithDebug (k, subscribed) "FanSubscribed"

1497+ liftIO $ writeIORef weakSelf =<< evaluate =<< mkWeakPtrWithDebug (k, subscribed) "FanSubscribed"

1498− liftIO $ writeIORef subscribedRef subscribed

1498+ liftIO $ writeIORef subscribedRef $! subscribed

1499− liftIO $ writeIORef (fanSubscribed f) $ Just subscribed

1499+ liftIO $ writeIORef (fanSubscribed f) $! Just subscribed

1500 return (slnForSub, subscribed)

1501

1502cleanupFanSubscribed :: GCompare k => (k a, FanSubscribed k) -> IO ()

1507 then do

1508 unsubscribe $ fanSubscribedParent subscribed

1509 -- Not necessary in this case, because this whole FanSubscribed is dead: writeIORef (fanSubscribedSubscribers subscribed) reducedSubscribers

1510− writeIORef (fanSubscribedCachedSubscribed subscribed) Nothing

1510+ writeIORef (fanSubscribedCachedSubscribed subscribed) $! Nothing

1511− else writeIORef (fanSubscribedSubscribers subscribed) reducedSubscribers

1511+ else writeIORef (fanSubscribedSubscribers subscribed) $! reducedSubscribers

1512

1513{-# INLINE subscribeFanSubscribed #-}

1514subscribeFanSubscribed :: GCompare k => k a -> FanSubscribed k -> Subscriber a -> IO (SubscriberListTicket a)

1563 , switchSubscribedNodeId = unsafeNodeId s

1564#endif

1565 }

1566− liftIO $ writeIORef weakSelf =<< mkWeakPtrWithDebug subscribed "switchSubscribedWeakSelf"

1566+ liftIO $ writeIORef weakSelf =<< evaluate =<< mkWeakPtrWithDebug subscribed "switchSubscribedWeakSelf"

1567− liftIO $ writeIORef subscribedRef subscribed

1567+ liftIO $ writeIORef subscribedRef $! subscribed

1568− liftIO $ writeIORef (switchSubscribed s) $ Just subscribed

1568+ liftIO $ writeIORef (switchSubscribed s) $! Just subscribed

1569 return (slnForSub, subscribed)

1570

1571cleanupSwitchSubscribed :: SwitchSubscribed a -> IO ()

1572cleanupSwitchSubscribed subscribed = do

1573 unsubscribe =<< readIORef (switchSubscribedCurrentParent subscribed)

1574 finalize =<< readIORef (switchSubscribedOwnWeakInvalidator subscribed) -- We don't need to get invalidated if we're dead

1575− writeIORef (switchSubscribedCachedSubscribed subscribed) Nothing

1575+ writeIORef (switchSubscribedCachedSubscribed subscribed) $! Nothing

1576

1577{-# INLINE subscribeSwitchSubscribed #-}

1578subscribeSwitchSubscribed :: SwitchSubscribed a -> Subscriber a -> IO (SubscriberListTicket a)

1618 , coincidenceSubscribedNodeId = unsafeNodeId c

1619#endif

1620 }

1621− liftIO $ writeIORef weakSelf =<< mkWeakPtrWithDebug subscribed "CoincidenceSubscribed"

1621+ liftIO $ writeIORef weakSelf =<< evaluate =<< mkWeakPtrWithDebug subscribed "CoincidenceSubscribed"

1622− liftIO $ writeIORef subscribedRef subscribed

1622+ liftIO $ writeIORef subscribedRef $! subscribed

1623− liftIO $ writeIORef (coincidenceSubscribed c) $ Just subscribed

1623+ liftIO $ writeIORef (coincidenceSubscribed c) $! Just subscribed

1624 return (slnForSub, subscribed)

1625

1626cleanupCoincidenceSubscribed :: CoincidenceSubscribed a -> IO ()

1627cleanupCoincidenceSubscribed subscribed = do

1628 unsubscribe $ coincidenceSubscribedOuterParent subscribed

1629− writeIORef (coincidenceSubscribedCachedSubscribed subscribed) Nothing

1629+ writeIORef (coincidenceSubscribedCachedSubscribed subscribed) $! Nothing

1630

1631{-# INLINE subscribeCoincidenceSubscribed #-}

1632subscribeCoincidenceSubscribed :: CoincidenceSubscribed a -> Subscriber a -> IO (SubscriberListTicket a)

1656 holdInits <- liftIO $ readIORef holdInitRef

1657 mergeInits <- liftIO $ readIORef mergeInitRef

1658 if null holdInits && null mergeInits then return () else do

1659− liftIO $ writeIORef holdInitRef []

1659+ liftIO $ writeIORef holdInitRef $! []

1660− liftIO $ writeIORef mergeInitRef []

1660+ liftIO $ writeIORef mergeInitRef $! []

1661 mapM_ initHold holdInits

1662 mapM_ initMerge mergeInits

1663 runHoldInits holdInitRef mergeInitRef

1675 EventSubscription _ changeSubd <- subscribe changed changeSub

1676 change <- liftIO $ readEventSubscribed changeSubd

1677 forM_ change $ \c -> defer $ SomeMergeUpdate c subscribed

1678− liftIO $ writeIORef (mergeSubscribedChange subscribed) (changeSub, changeSubd)

1678+ liftIO $ writeIORef (mergeSubscribedChange subscribed) $! (changeSub, changeSubd)

1679

1680-- | Run an event action outside of a frame

1681runFrame :: EventM x a -> SpiderHost x a --TODO: This function also needs to hold the mutex

1699 return result

1700 result <- runEventM go env

1701 toClear <- readIORef toClearRef

1702− forM_ toClear $ \(SomeClear ref) -> {-# SCC "clear" #-} writeIORef ref Nothing

1702+ forM_ toClear $ \(SomeClear ref) -> {-# SCC "clear" #-} writeIORef ref $! Nothing

1703 toClearRoot <- readIORef toClearRootRef

1704− forM_ toClearRoot $ \(SomeRootClear ref) -> {-# SCC "rootClear" #-} writeIORef ref DMap.empty

1704+ forM_ toClearRoot $ \(SomeRootClear ref) -> {-# SCC "rootClear" #-} writeIORef ref $! DMap.empty

1705 toAssign <- readIORef toAssignRef

1706 toReconnectRef <- newIORef []

1707 coincidenceInfos <- readIORef coincidenceInfosRef

1708 forM_ toAssign $ \(SomeAssignment vRef iRef v) -> {-# SCC "assignment" #-} do

1709 writeIORef vRef v

1710 when debugInvalidate $ putStrLn $ "Invalidating Hold"

1711− writeIORef iRef =<< invalidate toReconnectRef =<< readIORef iRef

1711+ writeIORef iRef =<< evaluate =<< invalidate toReconnectRef =<< readIORef iRef

1712 mergeUpdates <- readIORef mergeUpdateRef

1713− writeIORef mergeUpdateRef []

1713+ writeIORef mergeUpdateRef $! []

1714 let updateMerge :: SomeMergeUpdate -> IO [SomeEventSubscription]

1715 updateMerge (SomeMergeUpdate (R.PatchDMap p :: R.PatchDMap (DMap k Event)) m) = do

1716 oldParents <- readIORef $ mergeSubscribedParents m

1741 finalize wi

1742 i <- evaluate $ switchSubscribedOwnInvalidator subscribed

1743 wi' <- mkWeakPtrWithDebug i "wi'"

1744− writeIORef (switchSubscribedOwnWeakInvalidator subscribed) wi'

1744+ writeIORef (switchSubscribedOwnWeakInvalidator subscribed) $! wi'

1745− writeIORef (switchSubscribedBehaviorParents subscribed) []

1745+ writeIORef (switchSubscribedBehaviorParents subscribed) $! []

1746− writeIORef holdInitRef [] --TODO: Should we reuse this?

1746+ writeIORef holdInitRef $! [] --TODO: Should we reuse this?

1747 e <- runBehaviorM (readBehaviorTracked (switchSubscribedParent subscribed)) (Just (wi', switchSubscribedBehaviorParents subscribed)) holdInitRef

1748 runEventM (runHoldInits holdInitRef mergeInitRef) env --TODO: Is this actually OK? It seems like it should be, since we know that no events are firing at this point, but it still seems inelegant

1749 --TODO: Make sure we touch the pieces of the SwitchSubscribed at the appropriate times

1756 EventNever -> "EventNever"

1757 _ -> "something else"

1758 -}

1759− writeIORef (switchSubscribedCurrentParent subscribed) subscription

1759+ writeIORef (switchSubscribedCurrentParent subscribed) $! subscription

1760 parentHeight <- readIORef $ eventSubscribedHeightRef subd'

1761 myHeight <- readIORef $ switchSubscribedHeight subscribed

1762 when (parentHeight /= myHeight) $ do

1763− writeIORef (switchSubscribedHeight subscribed) invalidHeight

1763+ writeIORef (switchSubscribedHeight subscribed) $! invalidHeight

1764 WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight myHeight

1765 return $ SomeEventSubscription oldSubscription

1766 forM_ coincidenceInfos $ \(SomeResetCoincidence subscription mcs) -> do

1820 when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed

1821 oldHeight <- readIORef $ switchSubscribedHeight subscribed

1822 when (oldHeight /= invalidHeight) $ do

1823− writeIORef (switchSubscribedHeight subscribed) invalidHeight

1823+ writeIORef (switchSubscribedHeight subscribed) $! invalidHeight

1824 WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

1825 when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed <> " done"

1826 SubscriberCoincidenceOuter subscribed -> do

1838 oldHeights <- readIORef $ mergeSubscribedHeightBag subscribed

1839 let newHeights = heightBagRemove oldParentHeight oldHeights

1840 putStrLn $ "removeMergeHeight " <> showNodeId subscribed <> ": " <> show oldHeights <> " => " <> show newHeights

1841− writeIORef (mergeSubscribedHeightBag subscribed) newHeights

1841+ writeIORef (mergeSubscribedHeightBag subscribed) $! newHeights

1842

1843invalidateMergeHeight :: MergeSubscribed k -> IO ()

1844invalidateMergeHeight subscribed = do

1845 oldHeight <- readIORef $ mergeSubscribedHeight subscribed

1846 -- If the height used to be valid, it must be invalid now; we should never have *more* heights than we have parents

1847 when (oldHeight /= invalidHeight) $ do

1848− writeIORef (mergeSubscribedHeight subscribed) invalidHeight

1848+ writeIORef (mergeSubscribedHeight subscribed) $! invalidHeight

1849 WeakBag.traverse (mergeSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

1850

1851addMergeHeight :: Height -> MergeSubscribed k -> IO ()

1853 oldHeights <- readIORef $ mergeSubscribedHeightBag subscribed

1854 let newHeights = heightBagAdd newParentHeight oldHeights

1855 putStrLn $ "addMergeHeight " <> showNodeId subscribed <> ": " <> show oldHeights <> " => " <> show newHeights

1856− writeIORef (mergeSubscribedHeightBag subscribed) newHeights

1856+ writeIORef (mergeSubscribedHeightBag subscribed) $! newHeights

1857

1858revalidateMergeHeight :: MergeSubscribed k -> IO ()

1859revalidateMergeHeight subscribed = do

1864 when (heightBagSize heights == DMap.size parents) $ do

1865 let height = succHeight $ heightBagMax heights

1866 when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: height: " <> show height

1867− writeIORef (mergeSubscribedHeight subscribed) height

1867+ writeIORef (mergeSubscribedHeight subscribed) $! height

1868 WeakBag.traverse (mergeSubscribedSubscribers subscribed) $ recalculateSubscriberHeight height

1869

1870invalidateCoincidenceHeight :: CoincidenceSubscribed a -> IO ()

1871invalidateCoincidenceHeight subscribed = do

1872 oldHeight <- readIORef $ coincidenceSubscribedHeight subscribed

1873 when (oldHeight /= invalidHeight) $ do

1874− writeIORef (coincidenceSubscribedHeight subscribed) invalidHeight

1874+ writeIORef (coincidenceSubscribedHeight subscribed) $! invalidHeight

1875 WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

1876

1877recalculateSubscriberHeight :: Height -> Subscriber a -> IO ()

1912 oldHeight <- readIORef $ switchSubscribedHeight subscribed

1913 when (oldHeight == invalidHeight) $ do --TODO: This 'when' should probably be an assertion

1914 when (new /= invalidHeight) $ do --TODO: This 'when' should probably be an assertion

1915− writeIORef (switchSubscribedHeight subscribed) new

1915+ writeIORef (switchSubscribedHeight subscribed) $! new

1916 WeakBag.traverse (switchSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new

1917

1918recalculateCoincidenceHeight :: CoincidenceSubscribed a -> IO ()

1921 when (oldHeight == invalidHeight) $ do --TODO: This 'when' should probably be an assertion

1922 height <- calculateCoincidenceHeight subscribed

1923 when (height /= invalidHeight) $ do

1924− writeIORef (coincidenceSubscribedHeight subscribed) height

1924+ writeIORef (coincidenceSubscribedHeight subscribed) $! height

1925 WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight height

1926

1927getEventSubscribedHeight :: EventSubscribed a -> IO Height

1953 traceInvalidate $ "invalidate: Pull" <> showNodeId p

1954 mVal <- readIORef $ pullValue p

1955 forM_ mVal $ \val -> do

1956− writeIORef (pullValue p) Nothing

1956+ writeIORef (pullValue p) $! Nothing

1957− writeIORef (pullSubscribedInvalidators val) =<< invalidate toReconnectRef =<< readIORef (pullSubscribedInvalidators val)

1957+ writeIORef (pullSubscribedInvalidators val) =<< evaluate =<< invalidate toReconnectRef =<< readIORef (pullSubscribedInvalidators val)

1958 InvalidatorSwitch subscribed -> do

1959 traceInvalidate $ "invalidate: Switch" <> showNodeId subscribed

1960 modifyIORef' toReconnectRef (SomeSwitchSubscribed subscribed :)