refactor OrderedSet to use a record for better clarity and structure

Author: soulomoon

ghcide/session-loader/Development/IDE/Session.hs

@@ -56,7 +56,6 @@ import           Development.IDE.Types.HscEnvEq      (HscEnvEq)
 import           Development.IDE.Types.Location
 import           Development.IDE.Types.Options
 import qualified HIE.Bios                            as HieBios
-import qualified HIE.Bios.Cradle.Utils               as HieBios
 import           HIE.Bios.Environment                hiding (getCacheDir)
 import           HIE.Bios.Types                      hiding (Log)
 import qualified HIE.Bios.Types                      as HieBios

ghcide/session-loader/Development/IDE/Session/OrderedSet.hs

@@ -1,7 +1,6 @@
 module Development.IDE.Session.OrderedSet where
 
-import           Control.Concurrent.STM        (STM, TQueue, flushTQueue,
-                                                newTQueueIO)
+import           Control.Concurrent.STM        (STM, TQueue, newTQueueIO)
 import           Control.Concurrent.STM.TQueue (readTQueue, writeTQueue)
 import           Control.Monad                 (when)
 import           Data.Hashable                 (Hashable)
@@ -12,13 +11,16 @@ import qualified StmContainers.Set             as S
 import           StmContainers.Set             (Set)
 
 
-type OrderedSet a = (TQueue a, Set a)
+data OrderedSet a = OrderedSet
+  { insertionOrder :: TQueue a
+  , elements       :: Set a
+  }
 
 -- | Insert an element into the ordered set.
 -- If the element is not already present, it is added to both the queue and set.
 -- If the element already exists, ignore it
 insert :: Hashable a => a -> OrderedSet a -> STM ()
-insert a (que, s) = do
+insert a (OrderedSet que s) = do
     (_, inserted) <- S.focus (Focus.testingIfInserts $ Focus.insert ()) a s
     -- if already in the set
     when inserted $ writeTQueue que a
@@ -27,26 +29,26 @@ newIO :: Hashable a => IO (OrderedSet a)
 newIO = do
     que <- newTQueueIO
     s <- S.newIO
-    return (que, s)
+    return (OrderedSet que s)
 
 -- | Read the first element from the queue.
 -- If an element is not in the set, it means it has been deleted,
 -- so we retry until we find a valid element that exists in the set.
 readQueue :: Hashable a => OrderedSet a -> STM a
-readQueue rs@(que, s) = do
+readQueue rs@(OrderedSet que s) = do
                 f <- readTQueue que
                 b <- S.lookup f s
                 -- retry if no files are left in the queue
                 if b then return f else readQueue rs
 
 lookup :: Hashable a => a -> OrderedSet a -> STM Bool
-lookup a (_, s) = S.lookup a s
+lookup a (OrderedSet _ s) = S.lookup a s
 
 -- | Delete an element from the set.
 -- The queue is not modified directly; stale entries are filtered out lazily
 -- during reading operations (see 'readQueue').
 delete :: Hashable a => a -> OrderedSet a -> STM ()
-delete a (_, s) = S.delete a s
+delete a (OrderedSet _ s) = S.delete a s
 
 toHashSet :: Hashable a => OrderedSet a -> STM (Data.HashSet.HashSet a)
-toHashSet (_, s) = Data.HashSet.fromList <$> LT.toList (S.listT s)
+toHashSet (OrderedSet _ s) = Data.HashSet.fromList <$> LT.toList (S.listT s)