additional map -> fmap

Author: Anton-Latukha

src/Nix/Builtins.hs

@@ -636,7 +636,7 @@ split_ pat str = fromValue pat >>= fromStringNoContext >>= \p ->
     let re       = makeRegex (encodeUtf8 p) :: Regex
         haystack = encodeUtf8 s
     pure $ nvList $ splitMatches 0
-                                   (map elems $ matchAllText re haystack)
+                                   (fmap elems $ matchAllText re haystack)
                                    haystack
 
 splitMatches
@@ -656,7 +656,7 @@ splitMatches numDropped (((_, (start, len)) : captures) : mts) haystack =
  where
   relStart       = max 0 start - numDropped
   (before, rest) = B.splitAt relStart haystack
-  caps           = nvList (map f captures)
+  caps           = nvList (fmap f captures)
   f (a, (s, _)) = if s < 0 then nvConstant NNull else thunkStr a
 
 thunkStr :: Applicative f => ByteString -> NValue t f m
@@ -718,7 +718,7 @@ mapAttrs_ f xs = fromValue @(AttrSet (NValue t f m)) xs >>= \aset -> do
       $   withFrame Debug (ErrorCall "While applying f in mapAttrs:\n")
       $   callFunc ?? value
       =<< callFunc f (nvStr (makeNixStringWithoutContext key))
-  toValue . M.fromList . zip (map fst pairs) $ values
+  toValue . M.fromList . zip (fmap fst pairs) $ values
 
 filter_
   :: forall e t f m
@@ -1393,7 +1393,7 @@ exec_ xs = do
   -- TODO Still need to do something with the context here
   -- See prim_exec in nix/src/libexpr/primops.cc
   -- Requires the implementation of EvalState::realiseContext
-  exec (map (Text.unpack . stringIgnoreContext) xs)
+  exec (fmap (Text.unpack . stringIgnoreContext) xs)
 
 fetchurl
   :: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)

src/Nix/Effects/Derivation.hs

@@ -141,7 +141,7 @@ unparseDrv (Derivation {..}) = Text.append "Derive" $ parens
       list $ flip fmap (Map.toList $ snd inputs) (\(path, outs) ->
         parens [s path, list $ fmap s $ sort outs])
     , -- inputSrcs
-      list (map s $ Set.toList $ fst inputs)
+      list (fmap s $ Set.toList $ fst inputs)
     , s platform
     , s builder
     , -- run script args

src/Nix/Exec.hs

@@ -173,13 +173,13 @@ instance MonadNix e t f m => MonadEval (NValue t f m) m where
     evalError @(NValue t f m)
       $  ErrorCall
       $  "Inheriting unknown attribute: "
-      <> intercalate "." (map Text.unpack (NE.toList ks))
+      <> intercalate "." (fmap Text.unpack (NE.toList ks))
 
   attrMissing ks (Just s) =
     evalError @(NValue t f m)
       $  ErrorCall
       $  "Could not look up attribute "
-      <> intercalate "." (map Text.unpack (NE.toList ks))
+      <> intercalate "." (fmap Text.unpack (NE.toList ks))
       <> " in "
       <> show (prettyNValue s)
 

src/Nix/Expr/Shorthands.hs

@@ -136,7 +136,7 @@ mkDots (Fix (NSelect e keys' x)) keys =
   -- Special case: if the expression in the first argument is already
   -- a dotted expression, just extend it.
   Fix (NSelect e (keys' <> fmap (StaticKey ?? Nothing) keys) x)
-mkDots e keys = Fix $ NSelect e (map (StaticKey ?? Nothing) keys) Nothing
+mkDots e keys = Fix $ NSelect e (fmap (StaticKey ?? Nothing) keys) Nothing
 -}
 
 -- | An `inherit` clause without an expression to pull from.
@@ -174,19 +174,19 @@ modifyFunctionBody f (Fix e) = case e of
 
 -- | A let statement with multiple assignments.
 letsE :: [(Text, NExpr)] -> NExpr -> NExpr
-letsE pairs = Fix . NLet (map (uncurry bindTo) pairs)
+letsE pairs = Fix . NLet (fmap (uncurry bindTo) pairs)
 
 -- | Wrapper for a single-variable @let@.
 letE :: Text -> NExpr -> NExpr -> NExpr
 letE varName varExpr = letsE [(varName, varExpr)]
 
 -- | Make an attribute set (non-recursive).
 attrsE :: [(Text, NExpr)] -> NExpr
-attrsE pairs = Fix $ NSet NNonRecursive (map (uncurry bindTo) pairs)
+attrsE pairs = Fix $ NSet NNonRecursive (fmap (uncurry bindTo) pairs)
 
 -- | Make an attribute set (recursive).
 recAttrsE :: [(Text, NExpr)] -> NExpr
-recAttrsE pairs = Fix $ NSet NRecursive (map (uncurry bindTo) pairs)
+recAttrsE pairs = Fix $ NSet NRecursive (fmap (uncurry bindTo) pairs)
 
 -- | Logical negation.
 mkNot :: NExpr -> NExpr

src/Nix/Expr/Types.hs

@@ -609,8 +609,8 @@ ekey _ _ f e = fromMaybe e <$> f Nothing
 stripPositionInfo :: NExpr -> NExpr
 stripPositionInfo = transport phi
  where
-  phi (NSet recur binds) = NSet recur (map go binds)
-  phi (NLet binds body) = NLet (map go binds) body
+  phi (NSet recur binds) = NSet recur (fmap go binds)
+  phi (NLet binds body) = NLet (fmap go binds) body
   phi x                 = x
 
   go (NamedVar path r     _pos) = NamedVar path r nullPos

src/Nix/Lint.hs

@@ -276,13 +276,13 @@ instance MonadLint e m => MonadEval (Symbolic m) m where
     evalError @(Symbolic m)
       $  ErrorCall
       $  "Inheriting unknown attribute: "
-      <> intercalate "." (map Text.unpack (NE.toList ks))
+      <> intercalate "." (fmap Text.unpack (NE.toList ks))
 
   attrMissing ks (Just s) =
     evalError @(Symbolic m)
       $  ErrorCall
       $  "Could not look up attribute "
-      <> intercalate "." (map Text.unpack (NE.toList ks))
+      <> intercalate "." (fmap Text.unpack (NE.toList ks))
       <> " in "
       <> show s
 

src/Nix/Pretty.hs

@@ -149,7 +149,7 @@ prettyParamSet args var = encloseSep
   (lbrace <> space)
   (align (space <> rbrace))
   sep
-  (map prettySetArg args <> prettyVariadic)
+  (fmap prettySetArg args <> prettyVariadic)
  where
   prettySetArg (n, maybeDef) = case maybeDef of
     Nothing -> pretty (unpack n)
@@ -161,7 +161,7 @@ prettyBind :: Binding (NixDoc ann) -> Doc ann
 prettyBind (NamedVar n v _p) =
   prettySelector n <+> equals <+> withoutParens v <> semi
 prettyBind (Inherit s ns _p) =
-  "inherit" <+> scope <> align (fillSep (map prettyKeyName ns)) <> semi
+  "inherit" <+> scope <> align (fillSep (fmap prettyKeyName ns)) <> semi
   where scope = maybe mempty ((<> space) . parens . withoutParens) s
 
 prettyKeyName :: NKeyName (NixDoc ann) -> Doc ann
@@ -289,7 +289,7 @@ exprFNixDoc = \case
       $ group
       $ vsep
       $ [ "let"
-        , indent 2 (vsep (map prettyBind binds))
+        , indent 2 (vsep (fmap prettyBind binds))
         , "in" <+> withoutParens body
         ]
   NIf cond trueBody falseBody ->

src/Nix/Reduce.hs

@@ -313,10 +313,10 @@ pruneTree opts = foldFixM $ \(FlaggedF (b, Compose x)) -> do
     NAbs params (Just body) -> Just $ NAbs (pruneParams params) body
 
     NList l | reduceLists opts -> Just $ NList (catMaybes l)
-            | otherwise        -> Just $ NList (map (fromMaybe nNull) l)
+            | otherwise        -> Just $ NList (fmap (fromMaybe nNull) l)
     NSet recur binds
       | reduceSets opts -> Just $ NSet recur (mapMaybe sequence binds)
-      | otherwise -> Just $ NSet recur (map (fmap (fromMaybe nNull)) binds)
+      | otherwise -> Just $ NSet recur (fmap (fmap (fromMaybe nNull)) binds)
 
     NLet binds (Just body@(Fix (Compose (Ann _ x)))) ->
       Just $ case mapMaybe pruneBinding binds of
@@ -386,10 +386,10 @@ pruneTree opts = foldFixM $ \(FlaggedF (b, Compose x)) -> do
   pruneParams (Param n) = Param n
   pruneParams (ParamSet xs b n)
     | reduceSets opts = ParamSet
-      (map (second (maybe (Just nNull) (Just . fromMaybe nNull))) xs)
+      (fmap (second (maybe (Just nNull) (Just . fromMaybe nNull))) xs)
       b
       n
-    | otherwise = ParamSet (map (second (fmap (fromMaybe nNull))) xs) b n
+    | otherwise = ParamSet (fmap (second (fmap (fromMaybe nNull))) xs) b n
 
   pruneBinding :: Binding (Maybe NExprLoc) -> Maybe (Binding NExprLoc)
   pruneBinding (NamedVar _ Nothing _) = Nothing
@@ -398,7 +398,7 @@ pruneTree opts = foldFixM $ \(FlaggedF (b, Compose x)) -> do
   pruneBinding (Inherit _                 [] _) = Nothing
   pruneBinding (Inherit (join -> Nothing) _  _) = Nothing
   pruneBinding (Inherit (join -> m) xs pos) =
-    Just (Inherit m (map pruneKeyName xs) pos)
+    Just (Inherit m (fmap pruneKeyName xs) pos)
 
 reducingEvalExpr
   :: (Framed e m, Has e Options, Exception r, MonadCatch m, MonadIO m)

src/Nix/Render.hs

@@ -127,6 +127,6 @@ sourceContext path (unPos -> begLine) (unPos -> _begCol) (unPos -> endLine) (unP
       pad n | read n == begLine = "==> " <> n
             | otherwise         = "    " <> n
       ls' = zipWith (<+>)
-                    (map (pretty . pad) nums')
-                    (map ("| " <+>) ls)
+                    (fmap (pretty . pad) nums')
+                    (fmap ("| " <+>) ls)
     pure $ vsep $ ls' <> [msg]

src/Nix/String.hs

@@ -221,6 +221,6 @@ intercalateNixString _   []   = mempty
 intercalateNixString _   [ns] = ns
 intercalateNixString sep nss  = NixString contents ctx
  where
-  contents = Text.intercalate (nsContents sep) (map nsContents nss)
+  contents = Text.intercalate (nsContents sep) (fmap nsContents nss)
   ctx      = S.unions (nsContext sep : fmap nsContext nss)