treewide: (Set.union->(<>))

Author: Anton-Latukha

src/Nix/Effects/Derivation.hs

@@ -71,7 +71,7 @@ parsePath p = case Store.parsePath "/nix/store" (encodeUtf8 p) of
 writeDerivation :: (Framed e m, MonadStore m) => Derivation -> m Store.StorePath
 writeDerivation drv@Derivation{inputs, name} = do
   let (inputSrcs, inputDrvs) = inputs
-  references <- Set.fromList <$> traverse parsePath (Set.toList $ Set.union inputSrcs $ Set.fromList $ Map.keys inputDrvs)
+  references <- Set.fromList <$> traverse parsePath (Set.toList $ inputSrcs <> Set.fromList (Map.keys inputDrvs))
   path <- addTextToStore (Text.append name ".drv") (unparseDrv drv) (S.fromList $ Set.toList references) False
   parsePath $ toText $ unStorePath path
 

src/Nix/TH.hs

@@ -48,39 +48,35 @@ freeVars e = case unFix e of
   (NLiteralPath _               ) -> mempty
   (NEnvPath     _               ) -> mempty
   (NUnary       _    expr       ) -> freeVars expr
-  (NBinary      _    left right ) -> Set.union (freeVars left) (freeVars right)
+  (NBinary      _    left right ) -> ((<>) `on` freeVars) left right
   (NSelect      expr path orExpr) ->
     Set.unions
       [ freeVars expr
       , pathFree path
       , maybe mempty freeVars orExpr
       ]
-  (NHasAttr expr            path) -> Set.union (freeVars expr) (pathFree path)
+  (NHasAttr expr            path) -> freeVars expr <> pathFree path
   (NAbs     (Param varname) expr) -> Set.delete varname (freeVars expr)
   (NAbs (ParamSet set _ varname) expr) ->
-    Set.union
-      -- Include all free variables from the expression and the default arguments
-      (freeVars expr)
-      -- But remove the argument name if existing, and all arguments in the parameter set
+    -- Include all free variables from the expression and the default arguments
+    freeVars expr <>
+    -- But remove the argument name if existing, and all arguments in the parameter set
+    Set.difference
+      (Set.unions $ freeVars <$> mapMaybe snd set)
       (Set.difference
-        (Set.unions $ freeVars <$> mapMaybe snd set)
-        (Set.difference
-          (maybe mempty one varname)
-          (Set.fromList $ fmap fst set)
-        )
+        (maybe mempty one varname)
+        (Set.fromList $ fmap fst set)
       )
   (NLet         bindings expr   ) ->
-    Set.union
-      (freeVars expr)
-      (Set.difference
-        (bindFreeVars bindings)
-        (bindDefs  bindings)
-      )
+    freeVars expr <>
+    Set.difference
+      (bindFreeVars bindings)
+      (bindDefs  bindings)
   (NIf          cond th   el    ) -> Set.unions $ freeVars <$> [cond, th, el]
   -- Evaluation is needed to find out whether x is a "real" free variable in `with y; x`, we just include it
   -- This also makes sense because its value can be overridden by `x: with y; x`
-  (NWith        set  expr       ) -> Set.union (freeVars set      ) (freeVars expr)
-  (NAssert      assertion expr  ) -> Set.union (freeVars assertion) (freeVars expr)
+  (NWith        set  expr       ) -> ((<>) `on` freeVars) set expr
+  (NAssert      assertion expr  ) -> ((<>) `on` freeVars) assertion expr
   (NSynHole     _               ) -> mempty
 
  where
@@ -100,7 +96,7 @@ freeVars e = case unFix e of
     bind1Free :: Binding NExpr -> Set VarName
     bind1Free (Inherit  Nothing     keys _) = Set.fromList $ mapMaybe staticKey keys
     bind1Free (Inherit (Just scope) _    _) = freeVars scope
-    bind1Free (NamedVar path        expr _) = Set.union (pathFree path) (freeVars expr)
+    bind1Free (NamedVar path        expr _) = pathFree path <> freeVars expr
 
   staticKey :: NKeyName r -> Maybe VarName
   staticKey (StaticKey  varname) = pure varname

src/Nix/Type/Infer.hs

@@ -610,7 +610,7 @@ instance FreeTypeVars Type where
   ftv (TVar a   ) = one a
   ftv (TSet _ a ) = Set.unions $ ftv <$> M.elems a
   ftv (TList a  ) = Set.unions $ ftv <$> a
-  ftv (t1 :~> t2) = ftv t1 `Set.union` ftv t2
+  ftv (t1 :~> t2) = ftv t1 <> ftv t2
   ftv (TMany ts ) = Set.unions $ ftv <$> ts
 
 instance FreeTypeVars TVar where
@@ -620,10 +620,10 @@ instance FreeTypeVars Scheme where
   ftv (Forall as t) = ftv t `Set.difference` Set.fromList as
 
 instance FreeTypeVars a => FreeTypeVars [a] where
-  ftv = foldr (Set.union . ftv) mempty
+  ftv = foldr ((<>) . ftv) mempty
 
 instance (Ord a, FreeTypeVars a) => FreeTypeVars (Set.Set a) where
-  ftv = foldr (Set.union . ftv) mempty
+  ftv = foldr ((<>) . ftv) mempty
 
 -- * class @ActiveTypeVars@
 
@@ -633,12 +633,12 @@ class ActiveTypeVars a where
 -- ** Instances
 
 instance ActiveTypeVars Constraint where
-  atv (EqConst      t1 t2   ) = ftv t1 `Set.union` ftv t2
-  atv (ImpInstConst t1 ms t2) = ftv t1 `Set.union` (ftv ms `Set.intersection` ftv t2)
-  atv (ExpInstConst t  s    ) = ftv t  `Set.union` ftv s
+  atv (EqConst      t1 t2   ) = ftv t1 <> ftv t2
+  atv (ImpInstConst t1 ms t2) = ftv t1 <> (ftv ms `Set.intersection` ftv t2)
+  atv (ExpInstConst t  s    ) = ftv t  <> ftv s
 
 instance ActiveTypeVars a => ActiveTypeVars [a] where
-  atv = foldr (Set.union . atv) mempty
+  atv = foldr ((<>) . atv) mempty
 
 -- * Other