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

Renamed Data.FastWeakBag.traverse and Data.WeakBag.traverse to
Data.FastWeakBag.traverse_ and Data.WeakBag.traverse_ respectively.
This is a more accurate naming for the function as it has no resulting
value in the same way Data.Foldable.traverse_, and unlike
Data.Traverseable.traverse which has a resulting value. In addition,
we do not have to ignore any hlint warnings any more.

Author: matthewbauer

ChangeLog.md

@@ -1,5 +1,11 @@
 # Revision history for reflex
 
+## Unreleased
+
+* Data.WeakBag.traverse and Data.FastWeakBag.traverse have been
+  renamed to Data.WeakBag.traverse_ and Data.FastWeakBag.traverse_
+  respectively.
+
 ## 0.6.2.4
 
 * Update to monoidal-containers 0.6

src/Data/FastWeakBag.hs

@@ -18,6 +18,7 @@ module Data.FastWeakBag
   , isEmpty
   , insert
   , traverse
+  , traverse_
   , remove
   -- * Internal functions
   -- These will not always be available.
@@ -116,14 +117,14 @@ foreign import javascript unsafe "(function(){ for(var i = 0; i < $1.tickets.len
 isEmpty bag = {-# SCC "isEmpty" #-} IntMap.null <$> readIORef (_weakBag_children bag)
 #endif
 
-{-# INLINE traverse #-}
+{-# INLINE traverse_ #-}
 -- | Visit every node in the given list.  If new nodes are appended during the
 -- traversal, they will not be visited.  Every live node that was in the list
 -- when the traversal began will be visited exactly once; however, no guarantee
 -- is made about the order of the traversal.
-traverse :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()
+traverse_ :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()
 #ifdef GHCJS_FAST_WEAK
-traverse wb f = do
+traverse_ wb f = do
   let go cursor = when (not $ js_isNull cursor) $ do
         val <- liftIO $ js_getTicketValue cursor
         f $ unsafeFromRawJSVal val
@@ -134,13 +135,17 @@ foreign import javascript unsafe "$r = $1.val;" js_getTicketValue :: JSVal -> IO
 --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
 foreign 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
 #else
-traverse (FastWeakBag _ children) f = {-# SCC "traverse" #-} do
+traverse_ (FastWeakBag _ children) f = {-# SCC "traverse_" #-} do
   cs <- liftIO $ readIORef children
   forM_ cs $ \c -> do
     ma <- liftIO $ deRefWeak c
     mapM_ f ma
 #endif
 
+{-# DEPRECATED traverse "Use 'traverse_' instead" #-}
+traverse :: forall a m. MonadIO m => FastWeakBag a -> (a -> m ()) -> m ()
+traverse = traverse_
+
 -- | Remove an item from the 'FastWeakBag'; does nothing if invoked multiple times
 -- on the same 'FastWeakBagTicket'.
 {-# INLINE remove #-}

src/Data/WeakBag.hs

@@ -15,6 +15,7 @@ module Data.WeakBag
   , singleton
   , insert
   , traverse
+  , traverse_
   , remove
   -- * Internal functions
   -- These will not always be available.
@@ -99,18 +100,22 @@ singleton a wbRef finalizer = {-# SCC "singleton" #-} do
   ticket <- insert a bag wbRef finalizer
   return (bag, ticket)
 
-{-# INLINE traverse #-}
+{-# INLINE traverse_ #-}
 -- | Visit every node in the given list.  If new nodes are appended during the
 -- traversal, they will not be visited.  Every live node that was in the list
 -- when the traversal began will be visited exactly once; however, no guarantee
 -- is made about the order of the traversal.
-traverse :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()
-traverse (WeakBag _ children) f = {-# SCC "traverse" #-} do
+traverse_ :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()
+traverse_ (WeakBag _ children) f = {-# SCC "traverse" #-} do
   cs <- liftIO $ readIORef children
   forM_ cs $ \c -> do
     ma <- liftIO $ deRefWeak c
     mapM_ f ma
 
+{-# DEPRECATED traverse "Use 'traverse_' instead" #-}
+traverse :: MonadIO m => WeakBag a -> (a -> m ()) -> m ()
+traverse = traverse_
+
 -- | Remove an item from the 'WeakBag'; does nothing if invoked multiple times
 -- on the same 'WeakBagTicket'.
 {-# INLINE remove #-}

src/Reflex/Spider/Internal.hs

@@ -332,9 +332,9 @@ cacheEvent e =
                     scheduleClear occRef
                     propagateFast a subscribers
                 , subscriberInvalidateHeight = \old -> do
-                    FastWeakBag.traverse subscribers $ invalidateSubscriberHeight old
+                    FastWeakBag.traverse_ subscribers $ invalidateSubscriberHeight old
                 , subscriberRecalculateHeight = \new -> do
-                    FastWeakBag.traverse subscribers $ recalculateSubscriberHeight new
+                    FastWeakBag.traverse_ subscribers $ recalculateSubscriberHeight new
                 }
               when (isJust occ) $ do
                 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
   , subscriberInvalidateHeight = \old -> do
       when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed
       subscribers <- readIORef $ fanSubscribedSubscribers subscribed
-      forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ invalidateSubscriberHeight old
+      forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse_ (_fanSubscribedChildren_list v) $ invalidateSubscriberHeight old
       when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"
   , subscriberRecalculateHeight = \new -> do
       when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed
       subscribers <- readIORef $ fanSubscribedSubscribers subscribed
-      forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse (_fanSubscribedChildren_list v) $ recalculateSubscriberHeight new
+      forM_ (DMap.toList subscribers) $ \(_ :=> v) -> WeakBag.traverse_ (_fanSubscribedChildren_list v) $ recalculateSubscriberHeight new
       when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberFan" <> showNodeId subscribed <> " done"
   }
 
@@ -471,7 +471,7 @@ newSubscriberSwitch subscribed = return $ Subscriber
       oldHeight <- readIORef $ switchSubscribedHeight subscribed
       when (oldHeight /= invalidHeight) $ do
         writeIORef (switchSubscribedHeight subscribed) $! invalidHeight
-        WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight
+        WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight
       when debugInvalidateHeight $ putStrLn $ "invalidateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed <> " done"
   , subscriberRecalculateHeight = \new -> do
       when debugInvalidateHeight $ putStrLn $ "recalculateSubscriberHeight: SubscriberSwitch" <> showNodeId subscribed
@@ -494,8 +494,8 @@ newSubscriberCoincidenceOuter subscribed = return $ Subscriber
         Nothing -> do
           when (innerHeight > outerHeight) $ liftIO $ do -- If the event fires, it will fire at a later height
             writeIORef (coincidenceSubscribedHeight subscribed) $! innerHeight
-            WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight outerHeight
-            WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight innerHeight
+            WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight outerHeight
+            WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight innerHeight
         Just o -> do -- Since it's already firing, no need to adjust height
           liftIO $ writeIORef (coincidenceSubscribedOccurrence subscribed) occ
           scheduleClear $ coincidenceSubscribedOccurrence subscribed
@@ -542,14 +542,14 @@ propagate :: a -> WeakBag (Subscriber x a) -> EventM x ()
 propagate a subscribers = withIncreasedDepth $ do
   -- 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
   --TODO: Should we check if nodes already have their values before propagating?  Maybe we're re-doing work
-  WeakBag.traverse subscribers $ \s -> subscriberPropagate s a
+  WeakBag.traverse_ subscribers $ \s -> subscriberPropagate s a
 
 -- | Propagate everything at the current height
 propagateFast :: a -> FastWeakBag (Subscriber x a) -> EventM x ()
 propagateFast a subscribers = withIncreasedDepth $ do
   -- 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
   --TODO: Should we check if nodes already have their values before propagating?  Maybe we're re-doing work
-  FastWeakBag.traverse subscribers $ \s -> subscriberPropagate s a
+  FastWeakBag.traverse_ subscribers $ \s -> subscriberPropagate s a
 
 --------------------------------------------------------------------------------
 -- EventSubscribed
@@ -1527,15 +1527,15 @@ fanInt p = unsafePerformIO $ do
             liftIO $ writeIORef (_fanInt_occRef self) m
             scheduleIntClear $ _fanInt_occRef self
             FastMutableIntMap.forIntersectionWithImmutable_ (_fanInt_subscribers self) m $ \b v -> do --TODO: Do we need to know that no subscribers are being added as we traverse?
-              FastWeakBag.traverse b $ \s -> do
+              FastWeakBag.traverse_ b $ \s -> do
                 subscriberPropagate s v
         , subscriberInvalidateHeight = \old -> do
             FastMutableIntMap.for_ (_fanInt_subscribers self) $ \b -> do
-              FastWeakBag.traverse b $ \s -> do
+              FastWeakBag.traverse_ b $ \s -> do
                 subscriberInvalidateHeight s old
         , subscriberRecalculateHeight = \new -> do
             FastMutableIntMap.for_ (_fanInt_subscribers self) $ \b -> do
-              FastWeakBag.traverse b $ \s -> do
+              FastWeakBag.traverse_ b $ \s -> do
                 subscriberRecalculateHeight s new
         }
       liftIO $ do
@@ -2207,7 +2207,7 @@ runFrame a = SpiderHost $ do
     myHeight <- readIORef $ switchSubscribedHeight subscribed
     when (parentHeight /= myHeight) $ do
       writeIORef (switchSubscribedHeight subscribed) $! invalidHeight
-      WeakBag.traverse (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight myHeight
+      WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ invalidateSubscriberHeight myHeight
   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
   forM_ coincidenceInfos $ \(SomeResetCoincidence subscription mcs) -> do
     unsubscribe subscription
@@ -2248,15 +2248,15 @@ invalidateCoincidenceHeight subscribed = do
   oldHeight <- readIORef $ coincidenceSubscribedHeight subscribed
   when (oldHeight /= invalidHeight) $ do
     writeIORef (coincidenceSubscribedHeight subscribed) $! invalidHeight
-    WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight
+    WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ invalidateSubscriberHeight oldHeight
 
 updateSwitchHeight :: Height -> SwitchSubscribed x a -> IO ()
 updateSwitchHeight new subscribed = do
   oldHeight <- readIORef $ switchSubscribedHeight subscribed
   when (oldHeight == invalidHeight) $ do --TODO: This 'when' should probably be an assertion
     when (new /= invalidHeight) $ do --TODO: This 'when' should probably be an assertion
       writeIORef (switchSubscribedHeight subscribed) $! new
-      WeakBag.traverse (switchSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new
+      WeakBag.traverse_ (switchSubscribedSubscribers subscribed) $ recalculateSubscriberHeight new
 
 recalculateCoincidenceHeight :: CoincidenceSubscribed x a -> IO ()
 recalculateCoincidenceHeight subscribed = do
@@ -2265,7 +2265,7 @@ recalculateCoincidenceHeight subscribed = do
     height <- calculateCoincidenceHeight subscribed
     when (height /= invalidHeight) $ do
       writeIORef (coincidenceSubscribedHeight subscribed) $! height
-      WeakBag.traverse (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight height
+      WeakBag.traverse_ (coincidenceSubscribedSubscribers subscribed) $ recalculateSubscriberHeight height
 
 calculateSwitchHeight :: SwitchSubscribed x a -> IO Height
 calculateSwitchHeight subscribed = getEventSubscribedHeight . _eventSubscription_subscribed =<< readIORef (switchSubscribedCurrentParent subscribed)

test/hlint.hs

@@ -23,7 +23,6 @@ main = do
         , "--ignore=Reduce duplication"
         , "--cpp-define=USE_TEMPLATE_HASKELL"
         , "--ignore=Use tuple-section"
-        , "--ignore=Use traverse_"
         ]
       recurseInto = and <$> sequence
         [ fileType ==? Directory