([] -> mempty)

There are some `(:|)` use. I looked carefully, but there still can be something,
expecially in Repl or test parts of the code.

The `mempty` of the left hand side should not be present.

Also specially checked the shadowing case with: {-# OPTIONS_GHC
-fno-warn-name-shadowing #-}, where were none.

Author: Anton-Latukha

main/Repl.hs

@@ -360,7 +360,7 @@ completeFunc reversedPrev word
   = do
     s <- get
     case Data.HashMap.Lazy.lookup var (replCtx s) of
-      Nothing -> pure []
+      Nothing -> pure mempty
       Just binding -> do
         candidates <- lift $ algebraicComplete subFields binding
         pure $ notFinished <$> listCompletion (Data.Text.unpack . (var <>) <$> candidates)
@@ -396,14 +396,14 @@ completeFunc reversedPrev word
               [_] -> pure $ keys m
               f:fs ->
                 case Data.HashMap.Lazy.lookup f m of
-                  Nothing -> pure []
+                  Nothing -> pure mempty
                   Just e ->
                     demand e
                       (\e' -> (fmap . fmap) (("." <> f) <>) $ algebraicComplete fs e')
 
       in case val of
         NVSet xs _ -> withMap xs
-        _          -> pure []
+        _          -> pure mempty
 
 -- HelpOption inspired by Dhall Repl
 -- with `Doc` instead of String for syntax and doc

src/Nix/Builtins.hs

@@ -316,15 +316,15 @@ foldNixPath
 foldNixPath f z = do
   mres <- lookupVar "__includes"
   dirs <- case mres of
-    Nothing -> pure []
+    Nothing -> pure mempty
     Just v  -> demand v $ fromValue . Deeper
   mPath <- getEnvVar "NIX_PATH"
   mDataDir <- getEnvVar "NIX_DATA_DIR"
   dataDir <- maybe getDataDir pure mDataDir
   foldrM go z
     $  fmap (fromInclude . stringIgnoreContext) dirs
     <> case mPath of
-         Nothing  -> []
+         Nothing  -> mempty
          Just str -> uriAwareSplit (Text.pack str)
     <> [ fromInclude $ Text.pack $ "nix=" <> dataDir <> "/nix/corepkgs" ]
  where
@@ -336,7 +336,7 @@ foldNixPath f z = do
     _ -> throwError $ ErrorCall $ "Unexpected entry in NIX_PATH: " <> show x
 
 nixPath :: MonadNix e t f m => m (NValue t f m)
-nixPath = fmap nvList $ flip foldNixPath [] $ \p mn ty rest ->
+nixPath = fmap nvList $ flip foldNixPath mempty $ \p mn ty rest ->
   pure
     $ flip nvSet mempty ( M.fromList
         [ case ty of
@@ -512,7 +512,7 @@ versionComponentSeparators = ".-"
 
 splitVersion :: Text -> [VersionComponent]
 splitVersion s = case Text.uncons s of
-  Nothing -> []
+  Nothing -> mempty
   Just (h, t)
     | h `elem` versionComponentSeparators
     -> splitVersion t
@@ -575,7 +575,7 @@ splitDrvName s =
     breakAfterFirstItem :: (a -> Bool) -> [a] -> ([a], [a])
     breakAfterFirstItem f = \case
       h : t -> let (a, b) = break f t in (h : a, b)
-      []    -> ([], [])
+      []    -> (mempty, mempty)
     (namePieces, versionPieces) =
       breakAfterFirstItem isFirstVersionPiece pieces
   in
@@ -910,7 +910,7 @@ genericClosure = fromValue @(AttrSet (NValue t f m)) >=> \s ->
     -> [NValue t f m]
     -> Set (WValue t f m)
     -> m (Set (WValue t f m), [NValue t f m])
-  go _  []       ks = pure (ks, [])
+  go _  []       ks = pure (ks, mempty)
   go op (t : ts) ks = demand t $ \v -> fromValue @(AttrSet (NValue t f m)) v >>= \s -> do
     k <- attrsetGet "key" s
     demand k $ \k' -> do
@@ -1480,7 +1480,7 @@ appendContext x y = demand x $ \x' -> demand y $ \y' -> case (x', y') of
         allOutputs <- maybe (pure False) (demand ?? fromValue)
           $ M.lookup "allOutputs" attrs
         outputs <- case M.lookup "outputs" attrs of
-          Nothing -> pure []
+          Nothing -> pure mempty
           Just os -> demand os $ \case
             NVList vs ->
               forM vs $ fmap stringIgnoreContext . fromValue

src/Nix/Cited.hs

@@ -38,7 +38,7 @@ data NCited m v a = NCited
     deriving (Generic, Typeable, Functor, Foldable, Traversable, Show)
 
 instance Applicative (NCited m v) where
-  pure = NCited []
+  pure = NCited mempty
   NCited xs f <*> NCited ys x = NCited (xs <> ys) (f x)
 
 instance Comonad (NCited m v) where

src/Nix/Cited/Basic.hs

@@ -66,11 +66,11 @@ instance ( Has e Options
                              (Fix (Compose (Ann s e))))) =
                 let e' = Compose (Ann s (Nothing <$ e))
                 in [Provenance scope e']
-            go _ = []
+            go _ = mempty
             ps = concatMap (go . frame) frames
 
         fmap (Cited . NCited ps) . thunk $ mv
-      else fmap (Cited . NCited []) . thunk $ mv
+      else fmap (Cited . NCited mempty) . thunk $ mv
 
   thunkId (Cited (NCited _ t)) = thunkId @_ @m t
 

src/Nix/Context.hs

@@ -32,4 +32,4 @@ instance Has (Context m t) Options where
   hasLens f a = (\x -> a { options = x }) <$> f (options a)
 
 newContext :: Options -> Context m t
-newContext = Context emptyScopes nullSpan []
+newContext = Context emptyScopes nullSpan mempty

src/Nix/Effects/Basic.hs

@@ -73,7 +73,7 @@ expandHomePath p          = pure p
 --   parent may be a different directory from @a@. See the discussion at
 --   https://hackage.haskell.org/package/directory-1.3.1.5/docs/System-Directory.html#v:canonicalizePath
 removeDotDotIndirections :: FilePath -> FilePath
-removeDotDotIndirections = intercalate "/" . go [] . splitOn "/"
+removeDotDotIndirections = intercalate "/" . go mempty . splitOn "/"
  where
   go s       []            = reverse s
   go (_ : s) (".." : rest) = go s rest

src/Nix/Effects/Derivation.hs

@@ -73,7 +73,7 @@ defaultDerivation = Derivation
   , inputs      = (Set.empty, Map.empty)
   , platform    = undefined
   , builder     = undefined
-  , args        = []
+  , args        = mempty
   , env         = Map.empty
   , mFixed      = Nothing
   , hashMode    = Flat
@@ -297,7 +297,7 @@ buildDerivationWithContext drvAttrs = do
       useJson     <- getAttrOr "__structuredAttrs" False   $ pure
       ignoreNulls <- getAttrOr "__ignoreNulls"     False   $ pure
 
-      args        <- getAttrOr "args"              []      $ mapM (fromValue' >=> extractNixString)
+      args        <- getAttrOr "args"              mempty  $ mapM (fromValue' >=> extractNixString)
       builder     <- getAttr   "builder"                   $ extractNixString
       platform    <- getAttr   "system"                    $ extractNoCtx >=> assertNonNull
       mHash       <- getAttrOr "outputHash"        Nothing $ extractNoCtx >=> (pure . pure)

src/Nix/Eval.hs

@@ -267,7 +267,7 @@ evalBinds recursive binds = do
           h :| t -> evalSetterKeyName h >>= \case
             Nothing ->
               pure
-                ( []
+                ( mempty
                 , nullPos
                 , toValue @(AttrSet v, AttrSet SourcePos) (mempty, mempty)
                 )
@@ -279,7 +279,7 @@ evalBinds recursive binds = do
     go pathExpr <&> \case
         -- When there are no path segments, e.g. `${null} = 5;`, we don't
         -- bind anything
-      ([], _, _) -> []
+      ([], _, _) -> mempty
       result     -> [result]
 
   go scope (Inherit ms names pos) =

src/Nix/Expr/Shorthands.hs

@@ -32,13 +32,13 @@ mkFloatF = NConstant . NFloat
 -- | Make a regular (double-quoted) string.
 mkStr :: Text -> NExpr
 mkStr = Fix . NStr . DoubleQuoted . \case
-  "" -> []
+  "" -> mempty
   x  -> [Plain x]
 
 -- | Make an indented string.
 mkIndentedStr :: Int -> Text -> NExpr
 mkIndentedStr w = Fix . NStr . Indented w . \case
-  "" -> []
+  "" -> mempty
   x  -> [Plain x]
 
 -- | Make a path. Use 'True' if the path should be read from the
@@ -78,7 +78,7 @@ mkSynHoleF :: Text -> NExprF a
 mkSynHoleF = NSynHole
 
 mkSelector :: Text -> NAttrPath NExpr
-mkSelector = (:| []) . StaticKey
+mkSelector = (:| mempty) . StaticKey
 
 mkBool :: Bool -> NExpr
 mkBool = Fix . mkBoolF
@@ -231,5 +231,5 @@ infixl 1 @@
 infixr 1 ==>
 
 (@.) :: NExpr -> Text -> NExpr
-obj @. name = Fix (NSelect obj (StaticKey name :| []) Nothing)
+obj @. name = Fix (NSelect obj (StaticKey name :| mempty) Nothing)
 infixl 2 @.

src/Nix/Expr/Strings.hs

@@ -15,7 +15,7 @@ import           Nix.Expr
 
 -- | Merge adjacent 'Plain' values with 'mappend'.
 mergePlain :: [Antiquoted Text r] -> [Antiquoted Text r]
-mergePlain [] = []
+mergePlain [] = mempty
 mergePlain (Plain a : EscapedNewline : Plain b : xs) =
   mergePlain (Plain (a <> "\n" <> b) : xs)
 mergePlain (Plain a : Plain b : xs) = mergePlain (Plain (a <> b) : xs)
@@ -45,10 +45,10 @@ splitLines :: [Antiquoted Text r] -> [[Antiquoted Text r]]
 splitLines = uncurry (flip (:)) . go where
   go (Plain t : xs) = (Plain l :) <$> foldr f (go xs) ls   where
     (l : ls) = T.split (== '\n') t
-    f prefix (finished, current) = ((Plain prefix : current) : finished, [])
+    f prefix (finished, current) = ((Plain prefix : current) : finished, mempty)
   go (Antiquoted a   : xs) = (Antiquoted a :) <$> go xs
   go (EscapedNewline : xs) = (EscapedNewline :) <$> go xs
-  go []                    = ([], [])
+  go []                    = (mempty, mempty)
 
 -- | Join a stream of strings containing antiquotes again. This is the inverse
 -- of 'splitLines'.
@@ -57,7 +57,7 @@ unsplitLines = intercalate [Plain "\n"]
 
 -- | Form an indented string by stripping spaces equal to the minimal indent.
 stripIndent :: [Antiquoted Text r] -> NString r
-stripIndent [] = Indented 0 []
+stripIndent [] = Indented 0 mempty
 stripIndent xs =
   Indented minIndent
     . removePlainEmpty