(Nothing -> mempty)

Anton-Latukha · Anton-Latukha · commit 81528741ad71 · 2021-02-10T14:11:27.000+02:00
Replaced only where the `(Semigroup a =&gt; Maybe a)` is already present,
so does not change the signatures.
diff --git a/main/Main.hs b/main/Main.hs
@@ -53,15 +53,15 @@ main = do
       let file = addExtension (dropExtension path) "nixc"
       process opts (pure file) =<< liftIO (readCache path)
     Nothing -> case expression opts of
-      Just s  -> handleResult opts Nothing (parseNixTextLoc s)
+      Just s  -> handleResult opts mempty (parseNixTextLoc s)
       Nothing -> case fromFile opts of
         Just "-" -> mapM_ (processFile opts) . lines =<< liftIO getContents
         Just path ->
           mapM_ (processFile opts) . lines =<< liftIO (readFile path)
         Nothing -> case filePaths opts of
-          [] -> withNixContext Nothing Repl.main
+          [] -> withNixContext mempty Repl.main
           ["-"] ->
-            handleResult opts Nothing
+            handleResult opts mempty
               .   parseNixTextLoc
               =<< liftIO Text.getContents
           paths -> mapM_ (processFile opts) paths
@@ -102,8 +102,8 @@ main = do
         if evaluate opts
           then do
             val <- Nix.nixEvalExprLoc mpath expr
-            withNixContext Nothing (Repl.main' $ pure val)
-          else withNixContext Nothing Repl.main
+            withNixContext mempty (Repl.main' $ pure val)
+          else withNixContext mempty Repl.main
 
   process opts mpath expr
     | evaluate opts
diff --git a/src/Nix/Builtins.hs b/src/Nix/Builtins.hs
@@ -331,7 +331,7 @@ foldNixPath f z = do
   fromInclude x | "://" `Text.isInfixOf` x = (x, PathEntryURI)
                 | otherwise                = (x, PathEntryPath)
   go (x, ty) rest = case Text.splitOn "=" x of
-    [p] -> f (Text.unpack p) Nothing ty rest
+    [p] -> f (Text.unpack p) mempty ty rest
     [n, p] -> f (Text.unpack p) (pure (Text.unpack n)) ty rest
     _ -> throwError $ ErrorCall $ "Unexpected entry in NIX_PATH: " <> show x
 
diff --git a/src/Nix/Convert.hs b/src/Nix/Convert.hs
@@ -99,7 +99,7 @@ instance Convertible e t f m
   => FromValue () m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
     NVConstant' NNull -> pure $ pure ()
-    _                 -> pure Nothing
+    _                 -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m TNull (Free v)
@@ -155,9 +155,9 @@ instance ( Convertible e t f m
         .   unStorePath
         <$> addPath p
     NVSet' s _ -> case M.lookup "outPath" s of
-      Nothing -> pure Nothing
+      Nothing -> pure mempty
       Just p  -> fromValueMay p
-    _ -> pure Nothing
+    _ -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m (TString NoContext) (Free v)
@@ -166,7 +166,7 @@ instance Convertible e t f m
   => FromValue ByteString m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
     NVStr' ns -> pure $ encodeUtf8 <$> getStringNoContext  ns
-    _         -> pure Nothing
+    _         -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m (TString NoContext) (Free v)
@@ -193,7 +193,7 @@ instance Convertible e t f m
   => FromValue [NValue t f m] m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
     NVList' l -> pure $ pure l
-    _         -> pure Nothing
+    _         -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m TList (Free v)
@@ -204,7 +204,7 @@ instance ( Convertible e t f m
   => FromValue [a] m (Deeper (NValue' t f m (NValue t f m))) where
   fromValueMay = \case
     Deeper (NVList' l) -> sequence <$> traverse fromValueMay l
-    _                  -> pure Nothing
+    _                  -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m TList (Free (getDeeper v))
@@ -213,7 +213,7 @@ instance Convertible e t f m
   => FromValue (AttrSet (NValue t f m)) m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
     NVSet' s _ -> pure $ pure s
-    _          -> pure Nothing
+    _          -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m TSet (Free v)
@@ -224,7 +224,7 @@ instance ( Convertible e t f m
   => FromValue (AttrSet a) m (Deeper (NValue' t f m (NValue t f m))) where
   fromValueMay = \case
     Deeper (NVSet' s _) -> sequence <$> traverse fromValueMay s
-    _                   -> pure Nothing
+    _                   -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m TSet (Free (getDeeper v))
@@ -234,7 +234,7 @@ instance Convertible e t f m
               (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
     NVSet' s p -> pure $ pure (s, p)
-    _          -> pure Nothing
+    _          -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m TSet (Free v)
@@ -246,7 +246,7 @@ instance ( Convertible e t f m
               (Deeper (NValue' t f m (NValue t f m))) where
   fromValueMay = \case
     Deeper (NVSet' s p) -> fmap (, p) . sequence <$> traverse fromValueMay s
-    _                   -> pure Nothing
+    _                   -> pure mempty
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
     _      -> throwError $ Expectation @t @f @m TSet (Free (getDeeper v))
diff --git a/src/Nix/Effects/Basic.hs b/src/Nix/Effects/Basic.hs
@@ -107,7 +107,7 @@ findEnvPathM name = do
       then makeAbsolutePath @t @f $ absPath </> "default.nix"
       else pure absPath
     exists <- doesFileExist absFile
-    pure $ if exists then pure absFile else Nothing
+    pure $ if exists then pure absFile else mempty
 
 findPathBy
   :: forall e t f m
@@ -117,7 +117,7 @@ findPathBy
   -> FilePath
   -> m FilePath
 findPathBy finder ls name = do
-  mpath <- foldM go Nothing ls
+  mpath <- foldM go mempty ls
   case mpath of
     Nothing ->
       throwError
@@ -134,14 +134,14 @@ findPathBy finder ls name = do
     demand l $ fromValue >=> \(s :: HashMap Text (NValue t f m)) -> do
       p <- resolvePath s
       demand p $ fromValue >=> \(Path path) -> case M.lookup "prefix" s of
-        Nothing -> tryPath path Nothing
+        Nothing -> tryPath path mempty
         Just pf -> demand pf $ fromValueMay >=> \case
           Just (nsPfx :: NixString) ->
             let pfx = stringIgnoreContext nsPfx
             in  if not (Text.null pfx)
                   then tryPath path (pure (Text.unpack pfx))
-                  else tryPath path Nothing
-          _ -> tryPath path Nothing
+                  else tryPath path mempty
+          _ -> tryPath path mempty
 
   tryPath p (Just n) | n' : ns <- splitDirectories name, n == n' =
     finder $ p <///> joinPath ns
@@ -222,7 +222,7 @@ findPathM = findPathBy existingPath
   existingPath path = do
     apath  <- makeAbsolutePath @t @f path
     exists <- doesPathExist apath
-    pure $ if exists then pure apath else Nothing
+    pure $ if exists then pure apath else mempty
 
 defaultImportPath
   :: (MonadNix e t f m, MonadState (HashMap FilePath NExprLoc, b) m)
diff --git a/src/Nix/Effects/Derivation.hs b/src/Nix/Effects/Derivation.hs
@@ -300,7 +300,7 @@ buildDerivationWithContext drvAttrs = do
       args        <- getAttrOr "args"              mempty  $ mapM (fromValue' >=> extractNixString)
       builder     <- getAttr   "builder"                   $ extractNixString
       platform    <- getAttr   "system"                    $ extractNoCtx >=> assertNonNull
-      mHash       <- getAttrOr "outputHash"        Nothing $ extractNoCtx >=> (pure . pure)
+      mHash       <- getAttrOr "outputHash"        mempty  $ extractNoCtx >=> (pure . pure)
       hashMode    <- getAttrOr "outputHashMode"    Flat    $ extractNoCtx >=> parseHashMode
       outputs     <- getAttrOr "outputs"           ["out"] $ mapM (fromValue' >=> extractNoCtx)
 
diff --git a/src/Nix/Eval.hs b/src/Nix/Eval.hs
@@ -358,7 +358,7 @@ evalSetterKeyName = \case
   DynamicKey k ->
     runAntiquoted "\n" assembleString (>>= fromValueMay) k <&> \case
       Just ns -> Just (stringIgnoreContext ns)
-      _       -> Nothing
+      _       -> mempty
 
 assembleString
   :: forall v m
diff --git a/src/Nix/Expr/Shorthands.hs b/src/Nix/Expr/Shorthands.hs
@@ -99,7 +99,7 @@ mkOper2 :: NBinaryOp -> NExpr -> NExpr -> NExpr
 mkOper2 op a = Fix . NBinary op a
 
 mkParamset :: [(Text, Maybe NExpr)] -> Bool -> Params NExpr
-mkParamset params variadic = ParamSet params variadic Nothing
+mkParamset params variadic = ParamSet params variadic mempty
 
 mkRecSet :: [Binding NExpr] -> NExpr
 mkRecSet = Fix . NSet NRecursive
diff --git a/src/Nix/Lint.hs b/src/Nix/Lint.hs
@@ -372,7 +372,7 @@ lintBinaryOp op lsym rarg = do
     NMult   -> check lsym rsym [TConstant [TInt]]
     NDiv    -> check lsym rsym [TConstant [TInt]]
 
-    NUpdate -> check lsym rsym [TSet Nothing]
+    NUpdate -> check lsym rsym [TSet mempty]
 
     NConcat -> check lsym rsym [TList y]
  where
diff --git a/src/Nix/Options.hs b/src/Nix/Options.hs
@@ -43,28 +43,28 @@ defaultOptions current = Options { verbose      = ErrorsOnly
                                  , thunks       = False
                                  , values       = False
                                  , showScopes   = False
-                                 , reduce       = Nothing
+                                 , reduce       = mempty
                                  , reduceSets   = False
                                  , reduceLists  = False
                                  , parse        = False
                                  , parseOnly    = False
                                  , finder       = False
-                                 , findFile     = Nothing
+                                 , findFile     = mempty
                                  , strict       = False
                                  , evaluate     = False
                                  , json         = False
                                  , xml          = False
-                                 , attr         = Nothing
+                                 , attr         = mempty
                                  , include      = mempty
                                  , check        = False
-                                 , readFrom     = Nothing
+                                 , readFrom     = mempty
                                  , cache        = False
                                  , repl         = False
                                  , ignoreErrors = False
-                                 , expression   = Nothing
+                                 , expression   = mempty
                                  , arg          = mempty
                                  , argstr       = mempty
-                                 , fromFile     = Nothing
+                                 , fromFile     = mempty
                                  , currentTime  = current
                                  , filePaths    = mempty
                                  }
diff --git a/src/Nix/Parser.hs b/src/Nix/Parser.hs
@@ -492,7 +492,7 @@ identifier = lexeme $ try $ do
   ident <-
     cons
     <$> satisfy (\x -> isAlpha x || x == '_')
-    <*> takeWhileP Nothing identLetter
+    <*> takeWhileP mempty identLetter
   guard (not (ident `HashSet.member` reservedNames))
   pure ident
  where
diff --git a/src/Nix/Scope.hs b/src/Nix/Scope.hs
@@ -28,7 +28,9 @@ newScope = Scope
 
 scopeLookup :: Text -> [Scope a] -> Maybe a
 scopeLookup key = foldr go Nothing
-  where go (Scope m) rest = M.lookup key m <|> rest
+ where
+  go :: Scope a -> Maybe a -> Maybe a
+  go (Scope m) rest = M.lookup key m <|> rest
 
 data Scopes m a = Scopes
     { lexicalScopes :: [Scope a]
diff --git a/src/Nix/String.hs b/src/Nix/String.hs
@@ -147,7 +147,7 @@ fromNixLikeContext =
 -- | Extract the string contents from a NixString that has no context
 getStringNoContext :: NixString -> Maybe Text
 getStringNoContext (NixString s c) | null c    = pure s
-                                             | otherwise = Nothing
+                                             | otherwise = mempty
 
 -- | Extract the string contents from a NixString even if the NixString has an associated context
 stringIgnoreContext :: NixString -> Text
diff --git a/src/Nix/TH.hs b/src/Nix/TH.hs
@@ -83,7 +83,7 @@ freeVars e = case unFix e of
 
   staticKey :: NKeyName r -> Maybe VarName
   staticKey (StaticKey  varname) = pure varname
-  staticKey (DynamicKey _      ) = Nothing
+  staticKey (DynamicKey _      ) = mempty
 
   bindDefs :: Binding r -> Set VarName
   bindDefs (Inherit  Nothing                   _    _) = Set.empty
diff --git a/src/Nix/Thunk.hs b/src/Nix/Thunk.hs
@@ -45,7 +45,7 @@ class MonadThunkId m => MonadThunk t m a | t -> m, t -> a where
 
   -- | Return an identifier for the thunk unless it is a pure value (i.e.,
   --   strictly an encapsulation of some 'a' without any additional
-  --   structure). For pure values represented as thunks, returns Nothing.
+  --   structure). For pure values represented as thunks, returns mempty.
   thunkId :: t -> ThunkId m
 
   queryM :: t -> m r -> (a -> m r) -> m r
diff --git a/src/Nix/Type/Infer.hs b/src/Nix/Type/Infer.hs
@@ -526,7 +526,7 @@ data Judgment s = Judgment
     deriving Show
 
 instance Monad m => FromValue NixString (InferT s m) (Judgment s) where
-  fromValueMay _ = pure Nothing
+  fromValueMay _ = pure mempty
   fromValue _ = error "Unused"
 
 instance MonadInfer m
@@ -535,7 +535,7 @@ instance MonadInfer m
   fromValueMay (Judgment _ _ (TSet _ xs)) = do
     let sing _ = Judgment As.empty mempty
     pure $ pure (M.mapWithKey sing xs, M.empty)
-  fromValueMay _ = pure Nothing
+  fromValueMay _ = pure mempty
   fromValue = fromValueMay >=> \case
     Just v  -> pure v
     Nothing -> pure (M.empty, M.empty)
diff --git a/src/Nix/Value/Equal.hs b/src/Nix/Value/Equal.hs
@@ -157,10 +157,10 @@ valueEqM (Free (NValue (extract -> x))) (Free (NValue (extract -> y))) =
  where
   f (Pure t) = force t $ \case
     NVStr s -> pure $ pure s
-    _       -> pure Nothing
+    _       -> pure mempty
   f (Free v) = case v of
     NVStr' s -> pure $ pure s
-    _        -> pure Nothing
+    _        -> pure mempty
 
 thunkEqM :: (MonadThunk t m (NValue t f m), Comonad f) => t -> t -> m Bool
 thunkEqM lt rt = force lt $ \lv -> force rt $ \rv ->
diff --git a/tests/EvalTests.hs b/tests/EvalTests.hs
@@ -455,8 +455,8 @@ constantEqual expected actual = do
     let opts = defaultOptions time
     -- putStrLn =<< lint (stripAnnotation a)
     (eq, expectedNF, actualNF) <- runWithBasicEffectsIO opts $ do
-        expectedNF <- normalForm =<< nixEvalExprLoc Nothing expected
-        actualNF <- normalForm =<< nixEvalExprLoc Nothing actual
+        expectedNF <- normalForm =<< nixEvalExprLoc mempty expected
+        actualNF <- normalForm =<< nixEvalExprLoc mempty actual
         eq <- valueEqM expectedNF actualNF
         pure (eq, expectedNF, actualNF)
     let message =
@@ -485,7 +485,7 @@ assertNixEvalThrows a = do
   let opts = defaultOptions time
   errored <- catch
       (False <$ runWithBasicEffectsIO opts
-         (normalForm =<< nixEvalExprLoc Nothing a'))
+         (normalForm =<< nixEvalExprLoc mempty a'))
       (\(_ :: NixException) -> pure True)
   unless errored $
     assertFailure "Did not catch nix exception"
diff --git a/tests/Main.hs b/tests/Main.hs
@@ -58,7 +58,7 @@ ensureNixpkgsCanParse =
         NVStr ns <- do
           time <- getCurrentTime
           runWithBasicEffectsIO (defaultOptions time) $
-            Nix.nixEvalExprLoc Nothing expr
+            Nix.nixEvalExprLoc mempty expr
         let dir = stringIgnoreContext ns
         exists <- fileExist (unpack dir)
         unless exists $
diff --git a/tests/ParserTests.hs b/tests/ParserTests.hs
@@ -150,17 +150,17 @@ case_lambda_or_uri = do
 
 case_lambda_pattern = do
   assertParseText "{b, c ? 1}: b" $
-    Fix $ NAbs (fixed args Nothing) (mkSym "b")
+    Fix $ NAbs (fixed args mempty) (mkSym "b")
   assertParseText "{ b ? x: x  }: b" $
-    Fix $ NAbs (fixed args2 Nothing) (mkSym "b")
+    Fix $ NAbs (fixed args2 mempty) (mkSym "b")
   assertParseText "a@{b,c ? 1}: b" $
     Fix $ NAbs (fixed args (pure "a")) (mkSym "b")
   assertParseText "{b,c?1}@a: c" $
     Fix $ NAbs (fixed args (pure "a")) (mkSym "c")
   assertParseText "{b,c?1,...}@a: c" $
     Fix $ NAbs (variadic vargs (pure "a")) (mkSym "c")
   assertParseText "{...}: 1" $
-    Fix $ NAbs (variadic mempty Nothing) (mkInt 1)
+    Fix $ NAbs (variadic mempty mempty) (mkInt 1)
   assertParseFail "a@b: a"
   assertParseFail "{a}@{b}: a"
  where
diff --git a/tests/PrettyParseTests.hs b/tests/PrettyParseTests.hs
@@ -78,7 +78,7 @@ genParams = Gen.choice
   , ParamSet
   <$> Gen.list (Range.linear 0 10) ((,) <$> asciiText <*> Gen.maybe genExpr)
   <*> Gen.bool
-  <*> Gen.choice [pure Nothing, pure <$> asciiText]
+  <*> Gen.choice [pure mempty, pure <$> asciiText]
   ]
 
 genAtom :: Gen NAtom
@@ -177,7 +177,7 @@ normalize = foldFix $ \case
   normAntiquotedText (Plain "''\n") = EscapedNewline
   normAntiquotedText r              = r
 
-  normParams (ParamSet binds var (Just "")) = ParamSet binds var Nothing
+  normParams (ParamSet binds var (Just "")) = ParamSet binds var mempty
   normParams r                              = r
 
 -- | Test that parse . pretty == id up to attribute position information.
diff --git a/tests/ReduceExprTests.hs b/tests/ReduceExprTests.hs
diff --git a/tests/TestCommon.hs b/tests/TestCommon.hs
