Drop StorePathSet type alias

Author: sorki

hnix-store-core/src/System/Nix/Internal/StorePath.hs

@@ -13,7 +13,6 @@ module System.Nix.Internal.StorePath
     StoreDir(..)
   , StorePath(..)
   , StorePathName(..)
-  , StorePathSet
   , StorePathHashPart(..)
   , mkStorePathHashPart
   , ContentAddressableAddress(..)
@@ -97,9 +96,6 @@ mkStorePathHashPart
   -> StorePathHashPart
 mkStorePathHashPart = coerce . mkStorePathHash @hashAlgo
 
--- | A set of 'StorePath's.
-type StorePathSet = HashSet StorePath
-
 -- | An address for a content-addressable store path, i.e. one whose
 -- store path hash is purely a function of its contents (as opposed to
 -- paths that are derivation outputs, whose hashes are a function of

hnix-store-core/src/System/Nix/ReadonlyStore.hs

@@ -42,7 +42,7 @@ makeStorePath storeDir ty h nm = StorePath storeHash nm
         ]
 
 makeTextPath
-  :: StoreDir -> StorePathName -> Digest SHA256 -> StorePathSet -> StorePath
+  :: StoreDir -> StorePathName -> Digest SHA256 -> HashSet StorePath -> StorePath
 makeTextPath storeDir nm h refs = makeStorePath storeDir ty h nm
  where
   ty =
@@ -70,7 +70,7 @@ makeFixedOutputPath storeDir recursive h =
       <> ":"
 
 computeStorePathForText
-  :: StoreDir -> StorePathName -> ByteString -> (StorePathSet -> StorePath)
+  :: StoreDir -> StorePathName -> ByteString -> (HashSet StorePath -> StorePath)
 computeStorePathForText storeDir nm = makeTextPath storeDir nm . hash
 
 computeStorePathForPath

hnix-store-core/src/System/Nix/StorePath.hs

@@ -6,7 +6,6 @@ module System.Nix.StorePath
     StoreDir(..)
   , StorePath(..)
   , StorePathName
-  , StorePathSet
   , StorePathHashPart
   , mkStorePathHashPart
   , unStorePathHashPart

hnix-store-core/src/System/Nix/StorePathMetadata.hs

@@ -4,7 +4,6 @@ Description : Metadata about Nix store paths.
 module System.Nix.StorePathMetadata where
 
 import           System.Nix.StorePath           ( StorePath
-                                                , StorePathSet
                                                 , ContentAddressableAddress
                                                 )
 import           System.Nix.Hash                ( SomeNamedDigest )
@@ -22,7 +21,7 @@ data StorePathMetadata = StorePathMetadata
     -- | The hash of the nar serialization of the path.
     narHash :: !SomeNamedDigest
   , -- | The paths that this path directly references
-    references :: !StorePathSet
+    references :: !(HashSet StorePath)
   , -- | When was this path registered valid in the store?
     registrationTime :: !UTCTime
   , -- | The size of the nar serialization of the path, in bytes.

hnix-store-remote/src/System/Nix/Store/Remote.hs

@@ -49,7 +49,6 @@ import           System.Nix.Hash                ( NamedAlgo(..)
                                                 )
 import           System.Nix.StorePath           ( StorePath
                                                 , StorePathName
-                                                , StorePathSet
                                                 , StorePathHashPart
                                                 )
 import           System.Nix.StorePathMetadata   ( StorePathMetadata(..)
@@ -99,10 +98,10 @@ addToStore name source recursive repair = do
 -- Reference accepts repair but only uses it
 -- to throw error in case of remote talking to nix-daemon.
 addTextToStore
-  :: Text         -- ^ Name of the text
-  -> Text         -- ^ Actual text to add
-  -> StorePathSet -- ^ Set of `StorePath`s that the added text references
-  -> RepairFlag   -- ^ Repair flag, must be `False` in case of remote backend
+  :: Text              -- ^ Name of the text
+  -> Text              -- ^ Actual text to add
+  -> HashSet StorePath -- ^ Set of `StorePath`s that the added text references
+  -> RepairFlag        -- ^ Repair flag, must be `False` in case of remote backend
   -> MonadStore StorePath
 addTextToStore name text references' repair = do
   when (unRepairFlag repair)
@@ -138,7 +137,7 @@ addTempRoot pn = do
 -- | Build paths if they are an actual derivations.
 --
 -- If derivation output paths are already valid, do nothing.
-buildPaths :: StorePathSet -> BuildMode -> MonadStore ()
+buildPaths :: HashSet StorePath -> BuildMode -> MonadStore ()
 buildPaths ps bm = do
   storeDir <- getStoreDir
   void $ simpleOpArgs BuildPaths $ do
@@ -198,22 +197,22 @@ isValidPathUncached p = do
 
 -- | Query valid paths from set, optionally try to use substitutes.
 queryValidPaths
-  :: StorePathSet   -- ^ Set of `StorePath`s to query
+  :: HashSet StorePath   -- ^ Set of `StorePath`s to query
   -> SubstituteFlag -- ^ Try substituting missing paths when `True`
-  -> MonadStore StorePathSet
+  -> MonadStore (HashSet StorePath)
 queryValidPaths ps substitute = do
   storeDir <- getStoreDir
   runOpArgs QueryValidPaths $ do
     putPaths storeDir ps
     putBool (unSubstituteFlag substitute)
   sockGetPaths
 
-queryAllValidPaths :: MonadStore StorePathSet
+queryAllValidPaths :: MonadStore (HashSet StorePath)
 queryAllValidPaths = do
   runOp QueryAllValidPaths
   sockGetPaths
 
-querySubstitutablePaths :: StorePathSet -> MonadStore StorePathSet
+querySubstitutablePaths :: HashSet StorePath -> MonadStore (HashSet StorePath)
 querySubstitutablePaths ps = do
   storeDir <- getStoreDir
   runOpArgs QuerySubstitutablePaths $ putPaths storeDir ps
@@ -262,25 +261,25 @@ queryPathInfoUncached path = do
 
   pure $ StorePathMetadata{..}
 
-queryReferrers :: StorePath -> MonadStore StorePathSet
+queryReferrers :: StorePath -> MonadStore (HashSet StorePath)
 queryReferrers p = do
   storeDir <- getStoreDir
   runOpArgs QueryReferrers $ putPath storeDir p
   sockGetPaths
 
-queryValidDerivers :: StorePath -> MonadStore StorePathSet
+queryValidDerivers :: StorePath -> MonadStore (HashSet StorePath)
 queryValidDerivers p = do
   storeDir <- getStoreDir
   runOpArgs QueryValidDerivers $ putPath storeDir p
   sockGetPaths
 
-queryDerivationOutputs :: StorePath -> MonadStore StorePathSet
+queryDerivationOutputs :: StorePath -> MonadStore (HashSet StorePath)
 queryDerivationOutputs p = do
   storeDir <- getStoreDir
   runOpArgs QueryDerivationOutputs $ putPath storeDir p
   sockGetPaths
 
-queryDerivationOutputNames :: StorePath -> MonadStore StorePathSet
+queryDerivationOutputNames :: StorePath -> MonadStore (HashSet StorePath)
 queryDerivationOutputNames p = do
   storeDir <- getStoreDir
   runOpArgs QueryDerivationOutputNames $ putPath storeDir p
@@ -297,13 +296,13 @@ queryPathFromHashPart storePathHash = do
   sockGetPath
 
 queryMissing
-  :: StorePathSet
+  :: (HashSet StorePath)
   -> MonadStore
-      ( StorePathSet-- Paths that will be built
-      , StorePathSet -- Paths that have substitutes
-      , StorePathSet -- Unknown paths
-      , Integer            -- Download size
-      , Integer            -- Nar size?
+      ( HashSet StorePath -- Paths that will be built
+      , HashSet StorePath -- Paths that have substitutes
+      , HashSet StorePath -- Unknown paths
+      , Integer           -- Download size
+      , Integer           -- Nar size?
       )
 queryMissing ps = do
   storeDir <- getStoreDir

hnix-store-remote/src/System/Nix/Store/Remote/Util.hs

@@ -83,7 +83,7 @@ sockGetPathMay = do
       Just
       pth
 
-sockGetPaths :: MonadStore StorePathSet
+sockGetPaths :: MonadStore (HashSet StorePath)
 sockGetPaths = do
   sd <- getStoreDir
   getSocketIncremental (getPaths sd)
@@ -109,14 +109,14 @@ putTexts = putByteStrings . fmap textToBSL
 getPath :: StoreDir -> Get (Either String StorePath)
 getPath sd = parsePath sd <$> getByteStringLen
 
-getPaths :: StoreDir -> Get StorePathSet
+getPaths :: StoreDir -> Get (HashSet StorePath)
 getPaths sd =
   Data.HashSet.fromList . rights . fmap (parsePath sd) <$> getByteStrings
 
 putPath :: StoreDir -> StorePath -> Put
 putPath storeDir = putByteStringLen . fromStrict . storePathToRawFilePath storeDir
 
-putPaths :: StoreDir -> StorePathSet -> Put
+putPaths :: StoreDir -> HashSet StorePath -> Put
 putPaths storeDir = putByteStrings . Data.HashSet.toList . Data.HashSet.map
   (fromStrict . storePathToRawFilePath storeDir)