52eee43 · patch · git.iko.soy

git.iko.soy/patch

on develop help sign in

Rename Data.{Fast,}WeakBag.traverse to Data.{Fast,}WeakBag.traverse_

52eee43Matthew Bauer7 years ago

ChangeLog.md+6

compare with develop

unifiedsplit

@@ -1,5 +1,11 @@

1# Revision history for reflex

3+## Unreleased

5+* Data.WeakBag.traverse and Data.FastWeakBag.traverse have been

6+ renamed to Data.WeakBag.traverse_ and Data.FastWeakBag.traverse_

7+ respectively.

3## 0.6.2.4

9## 0.6.2.4

5* Update to monoidal-containers 0.6

11* Update to monoidal-containers 0.6

src/Data/FastWeakBag.hs+9−4

@@ -18,6 +18,7 @@ module Data.FastWeakBag

18 , isEmpty

19 , insert

20 , traverse

21+ , traverse_

21 , remove

22 , remove

22 -- * Internal functions

23 -- * Internal functions

23 -- These will not always be available.

24 -- These will not always be available.

@@ -116,14 +117,14 @@ foreign import javascript unsafe "(function(){ for(var i = 0; i < $1.tickets.len

116isEmpty bag = {-# SCC "isEmpty" #-} IntMap.null <$> readIORef (_weakBag_children bag)

117isEmpty bag = {-# SCC "isEmpty" #-} IntMap.null <$> readIORef (_weakBag_children bag)

117#endif

118#endif

118

119

119−{-# INLINE traverse #-}

120+{-# INLINE traverse_ #-}

120-- | Visit every node in the given list. If new nodes are appended during the

121-- | Visit every node in the given list. If new nodes are appended during the

121-- traversal, they will not be visited. Every live node that was in the list

122-- traversal, they will not be visited. Every live node that was in the list

122-- when the traversal began will be visited exactly once; however, no guarantee

123-- when the traversal began will be visited exactly once; however, no guarantee

123-- is made about the order of the traversal.

124-- is made about the order of the traversal.

124−traverse :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()

125+traverse_ :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()

125#ifdef GHCJS_FAST_WEAK

126#ifdef GHCJS_FAST_WEAK

126−traverse wb f = do

127+traverse_ wb f = do

127 let go cursor = when (not $ js_isNull cursor) $ do

128 let go cursor = when (not $ js_isNull cursor) $ do

128 val <- liftIO $ js_getTicketValue cursor

129 val <- liftIO $ js_getTicketValue cursor

129 f $ unsafeFromRawJSVal val

130 f $ unsafeFromRawJSVal val

@@ -134,13 +135,17 @@ foreign import javascript unsafe "$r = $1.val;" js_getTicketValue :: JSVal -> IO

134--TODO: Fix the race condition where if a cursor is deleted (presumably using 'remove', below) while we're holding it, it can't find its way back to the correct bag

135--TODO: Fix the race condition where if a cursor is deleted (presumably using 'remove', below) while we're holding it, it can't find its way back to the correct bag

135foreign import javascript unsafe "(function(){ for(var i = $1.pos - 1; i >= 0; i--) { if($1.bag.tickets[i] !== null) { return $1.bag.tickets[i]; } }; return null; })()" js_getNext :: FastWeakBagTicket a -> IO JSVal --TODO: Clean up as we go along so this isn't O(n) every time -- Result can be null or a FastWeakBagTicket a

136foreign import javascript unsafe "(function(){ for(var i = $1.pos - 1; i >= 0; i--) { if($1.bag.tickets[i] !== null) { return $1.bag.tickets[i]; } }; return null; })()" js_getNext :: FastWeakBagTicket a -> IO JSVal --TODO: Clean up as we go along so this isn't O(n) every time -- Result can be null or a FastWeakBagTicket a

136#else

137#else

137−traverse (FastWeakBag _ children) f = {-# SCC "traverse" #-} do

138+traverse_ (FastWeakBag _ children) f = {-# SCC "traverse_" #-} do

138 cs <- liftIO $ readIORef children

139 cs <- liftIO $ readIORef children

139 forM_ cs $ \c -> do

140 forM_ cs $ \c -> do

140 ma <- liftIO $ deRefWeak c

141 ma <- liftIO $ deRefWeak c

141 mapM_ f ma

142 mapM_ f ma

142#endif

143#endif

143

144

145+{-# DEPRECATED traverse "Use 'traverse_' instead" #-}

146+traverse :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()

147+traverse = traverse_

148+

144-- | Remove an item from the 'FastWeakBag'; does nothing if invoked multiple times

149-- | Remove an item from the 'FastWeakBag'; does nothing if invoked multiple times

145-- on the same 'FastWeakBagTicket'.

150-- on the same 'FastWeakBagTicket'.

146{-# INLINE remove #-}

151{-# INLINE remove #-}

src/Data/WeakBag.hs+8−3

@@ -15,6 +15,7 @@ module Data.WeakBag

15 , singleton

16 , insert

17 , traverse

18+ , traverse_

18 , remove

19 , remove

19 -- * Internal functions

20 -- * Internal functions

20 -- These will not always be available.

21 -- These will not always be available.

@@ -99,18 +100,22 @@ singleton a wbRef finalizer = {-# SCC "singleton" #-} do

99 ticket <- insert a bag wbRef finalizer

100 ticket <- insert a bag wbRef finalizer

100 return (bag, ticket)

101 return (bag, ticket)

101

102

102−{-# INLINE traverse #-}

103+{-# INLINE traverse_ #-}

103-- | Visit every node in the given list. If new nodes are appended during the

104-- | Visit every node in the given list. If new nodes are appended during the

104-- traversal, they will not be visited. Every live node that was in the list

105-- traversal, they will not be visited. Every live node that was in the list

105-- when the traversal began will be visited exactly once; however, no guarantee

106-- when the traversal began will be visited exactly once; however, no guarantee

106-- is made about the order of the traversal.

107-- is made about the order of the traversal.

107−traverse :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()

108+traverse_ :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()

108−traverse (WeakBag _ children) f = {-# SCC "traverse" #-} do

109+traverse_ (WeakBag _ children) f = {-# SCC "traverse" #-} do

109 cs <- liftIO $ readIORef children

110 cs <- liftIO $ readIORef children

110 forM_ cs $ \c -> do

111 forM_ cs $ \c -> do

111 ma <- liftIO $ deRefWeak c

112 ma <- liftIO $ deRefWeak c

112 mapM_ f ma

113 mapM_ f ma

113

114

115+{-# DEPRECATED traverse "Use 'traverse_' instead" #-}

116+traverse :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()

117+traverse = traverse_

118+

114-- | Remove an item from the 'WeakBag'; does nothing if invoked multiple times

119-- | Remove an item from the 'WeakBag'; does nothing if invoked multiple times

115-- on the same 'WeakBagTicket'.

120-- on the same 'WeakBagTicket'.

116{-# INLINE remove #-}

121{-# INLINE remove #-}

src/Reflex/Spider/Internal.hs+16−16

@@ -332,9 +332,9 @@ cacheEvent e =

332 scheduleClear occRef

333 propagateFast a subscribers

334 , subscriberInvalidateHeight = \old -> do

335− FastWeakBag.traverse subscribers $ invalidateSubscriberHeight old

335+ FastWeakBag.traverse_ subscribers $ invalidateSubscriberHeight old

336 , subscriberRecalculateHeight = \new -> do

337− FastWeakBag.traverse subscribers $ recalculateSubscriberHeight new

337+ FastWeakBag.traverse_ subscribers $ recalculateSubscriberHeight new

338 }

339 when (isJust occ) $ do

340 liftIO $ writeIORef occRef occ -- Set the initial value of occRef; we don't need to do this if occ is Nothing

@@ -450,12 +450,12 @@ newSubscriberFan subscribed = return $ Subscriber

450 , subscriberInvalidateHeight = \old -> do

451 when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed

452 subscribers <- readIORef $ fanSubscribedSubscribers subscribed

453− forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ invalidateSubscriberHeight old

453+ forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse_ (_fanSubscribedChildren_list v) $ invalidateSubscriberHeight old

454 when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"

455 , subscriberRecalculateHeight = \new -> do

456 when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed

457 subscribers <- readIORef $ fanSubscribedSubscribers subscribed

458− forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ recalculateSubscriberHeight new

458+ forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse_ (_fanSubscribedChildren_list v) $ recalculateSubscriberHeight new

459 when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"

460 }

461

@@ -471,7 +471,7 @@ newSubscriberSwitch subscribed = return $ Subscriber

471 oldHeight <- readIORef $ switchSubscribedHeight subscribed

472 when (oldHeight /= invalidHeight) $ do

473 writeIORef (switchSubscribedHeight subscribed) $! invalidHeight

474− WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

474+ WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

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

476 , subscriberRecalculateHeight = \new -> do

477 when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed

@@ -494,8 +494,8 @@ newSubscriberCoincidenceOuter subscribed = return $ Subscriber

494 Nothing -> do

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

496 writeIORef (coincidenceSubscribedHeight subscribed) $! innerHeight

497− WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight outerHeight

497+ WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight outerHeight

498− WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight innerHeight

498+ WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight innerHeight

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

500 liftIO $ writeIORef (coincidenceSubscribedOccurrence subscribed) occ

501 scheduleClear $ coincidenceSubscribedOccurrence subscribed

@@ -542,14 +542,14 @@ propagate :: a -> WeakBag (Subscriber x a) -> EventM x ()

542propagate a subscribers = withIncreasedDepth $ do

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

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

545− WeakBag.traverse subscribers $ \s -> subscriberPropagate s a

545+ WeakBag.traverse_ subscribers $ \s -> subscriberPropagate s a

546

547-- | Propagate everything at the current height

548propagateFast :: a -> FastWeakBag (Subscriber x a) -> EventM x ()

549propagateFast a subscribers = withIncreasedDepth $ do

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

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

552− FastWeakBag.traverse subscribers $ \s -> subscriberPropagate s a

552+ FastWeakBag.traverse_ subscribers $ \s -> subscriberPropagate s a

553

554--------------------------------------------------------------------------------

555-- EventSubscribed

@@ -1527,15 +1527,15 @@ fanInt p = unsafePerformIO $ do

1527 liftIO $ writeIORef (_fanInt_occRef self) m

1528 scheduleIntClear $ _fanInt_occRef self

1529 FastMutableIntMap.forIntersectionWithImmutable_ (_fanInt_subscribers self) m $ \b v -> do --TODO: Do we need to know that no subscribers are being added as we traverse?

1530− FastWeakBag.traverse b $ \s -> do

1530+ FastWeakBag.traverse_ b $ \s -> do

1531 subscriberPropagate s v

1532 , subscriberInvalidateHeight = \old -> do

1533 FastMutableIntMap.for_ (_fanInt_subscribers self) $ \b -> do

1534− FastWeakBag.traverse b $ \s -> do

1534+ FastWeakBag.traverse_ b $ \s -> do

1535 subscriberInvalidateHeight s old

1536 , subscriberRecalculateHeight = \new -> do

1537 FastMutableIntMap.for_ (_fanInt_subscribers self) $ \b -> do

1538− FastWeakBag.traverse b $ \s -> do

1538+ FastWeakBag.traverse_ b $ \s -> do

1539 subscriberRecalculateHeight s new

1540 }

1541 liftIO $ do

@@ -2207,7 +2207,7 @@ runFrame a = SpiderHost $ do

2207 myHeight <- readIORef $ switchSubscribedHeight subscribed

2208 when (parentHeight /= myHeight) $ do

2209 writeIORef (switchSubscribedHeight subscribed) $! invalidHeight

2210− WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight myHeight

2210+ WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight myHeight

2211 mapM_ _someMergeUpdate_invalidateHeight mergeUpdates --TODO: In addition to when the patch is completely empty, we should also not run this if it has some Nothing values, but none of them have actually had any effect; potentially, we could even check for Just values with no effect (e.g. by comparing their IORefs and ignoring them if they are unchanged); actually, we could just check if the new height is different

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

2213 unsubscribe subscription

@@ -2248,7 +2248,7 @@ invalidateCoincidenceHeight subscribed = do

2248 oldHeight <- readIORef $ coincidenceSubscribedHeight subscribed

2249 when (oldHeight /= invalidHeight) $ do

2250 writeIORef (coincidenceSubscribedHeight subscribed) $! invalidHeight

2251− WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

2251+ WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight

2252

2253updateSwitchHeight :: Height -> SwitchSubscribed x a -> IO ()

2254updateSwitchHeight new subscribed = do

@@ -2256,7 +2256,7 @@ updateSwitchHeight new subscribed = do

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

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

2258 writeIORef (switchSubscribedHeight subscribed) $! new

2259− WeakBag.traverse (switchSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new

2259+ WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new

2260

2261recalculateCoincidenceHeight :: CoincidenceSubscribed x a -> IO ()

2262recalculateCoincidenceHeight subscribed = do

@@ -2265,7 +2265,7 @@ recalculateCoincidenceHeight subscribed = do

2265 height <- calculateCoincidenceHeight subscribed

2266 when (height /= invalidHeight) $ do

2267 writeIORef (coincidenceSubscribedHeight subscribed) $! height

2268− WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight height

2268+ WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight height

2269

2270calculateSwitchHeight :: SwitchSubscribed x a -> IO Height

2271calculateSwitchHeight subscribed = getEventSubscribedHeight . _eventSubscription_subscribed =<< readIORef (switchSubscribedCurrentParent subscribed)

test/hlint.hs−1

@@ -23,7 +23,6 @@ main = do

23 , "--ignore=Reduce duplication"

24 , "--cpp-define=USE_TEMPLATE_HASKELL"

25 , "--ignore=Use tuple-section"

26− , "--ignore=Use traverse_"

27 ]

26 ]

28 recurseInto = and <$> sequence

27 recurseInto = and <$> sequence

29 [ fileType ==? Directory

28 [ fileType ==? Directory