map -> fmap

Allow not only literal lists.
This for example should allow NonEmpty lists at least.

Also do not think I do this things on a whim.
I postphoned the refactors from map, (++), until I understand the underlying GHC
Haskell processes & performance better.

I did some research on: is there a reason to use map over fmap, and are the
performance reasons?
In short - there is 0 information on why some people use `map` over `fmap`, there
are no reports of performance reasons.

Well, I know that there is a possibility of a minor type class interface
compilation & runtime use cost. But I think GHC is good enough to infer zero
cost for the concrete list type for which `map` gets used.

And overall we not did thorough profiling/perfommans walkthrough so far. I am
sure that use of standard fmap for code flexibility is not a bottleneck in the
design, I've seen some performance problems design has.

And we not even did the profiling to do inlining and specialize work yet. It is
more effective to keep using `fmap`, and supply specialization, which allows to
keep the code polymorhic, portable to write for and effective in performance.

Author: Anton-Latukha

main/Repl.hs

@@ -348,7 +348,7 @@ completeFunc reversedPrev word
   -- Commands
   | reversedPrev == ":"
   = pure . listCompletion
-      $ map helpOptionName (helpOptions :: HelpOptions e t f m)
+      $ fmap helpOptionName (helpOptions :: HelpOptions e t f m)
 
   -- Files
   | any (`Data.List.isPrefixOf` word) [ "/", "./", "../", "~/" ]
@@ -364,7 +364,7 @@ completeFunc reversedPrev word
       Just binding -> do
         candidates <- lift $ algebraicComplete subFields binding
         pure
-          $ map notFinished
+          $ fmap notFinished
           $ listCompletion (Data.Text.unpack . (var <>) <$> candidates)
 
   -- Builtins, context variables
@@ -381,7 +381,7 @@ completeFunc reversedPrev word
       ++ (Data.Text.unpack <$> shortBuiltins)
 
   where
-    listCompletion = map simpleCompletion . filter (word `Data.List.isPrefixOf`)
+    listCompletion = fmap simpleCompletion . filter (word `Data.List.isPrefixOf`)
 
     notFinished x = x { isFinished = False }
 
@@ -508,7 +508,7 @@ renderSetOptions :: [HelpSetOption] -> Doc ()
 renderSetOptions so =
   Prettyprinter.indent 4
     $ Prettyprinter.vsep
-    $ flip map so
+    $ flip fmap so
     $ \h ->
              Prettyprinter.pretty (helpSetOptionName h)
          <+> helpSetOptionSyntax h

src/Nix.hs

@@ -107,7 +107,7 @@ evaluateExpression
   -> m a
 evaluateExpression mpath evaluator handler expr = do
   opts :: Options <- asks (view hasLens)
-  args <- traverse (traverse eval') $ map (second parseArg) (arg opts) ++ map
+  args <- traverse (traverse eval') $ fmap (second parseArg) (arg opts) ++ fmap
     (second mkStr)
     (argstr opts)
   evaluator mpath expr >>= \f -> demand f $ \f' ->

src/Nix/Builtins.hs

@@ -102,7 +102,7 @@ withNixContext
 withNixContext mpath action = do
   base            <- builtins
   opts :: Options <- asks (view hasLens)
-  let i = nvList $ map
+  let i = nvList $ fmap
         ( nvStr
         . makeNixStringWithoutContext
         . Text.pack
@@ -122,10 +122,10 @@ builtins = do
   lst <- ([("builtins", ref)] ++) <$> topLevelBuiltins
   pushScope (M.fromList lst) currentScopes
  where
-  buildMap         = M.fromList . map mapping <$> builtinsList
-  topLevelBuiltins = map mapping <$> fullBuiltinsList
+  buildMap         = M.fromList . fmap mapping <$> builtinsList
+  topLevelBuiltins = fmap mapping <$> fullBuiltinsList
 
-  fullBuiltinsList = map go <$> builtinsList
+  fullBuiltinsList = fmap go <$> builtinsList
    where
     go b@(Builtin TopLevel _) = b
     go (Builtin Normal (name, builtin)) =
@@ -322,7 +322,7 @@ foldNixPath f z = do
   mDataDir <- getEnvVar "NIX_DATA_DIR"
   dataDir <- maybe getDataDir pure mDataDir
   foldrM go z
-    $  map (fromInclude . stringIgnoreContext) dirs
+    $  fmap (fromInclude . stringIgnoreContext) dirs
     ++ case mPath of
          Nothing  -> []
          Just str -> uriAwareSplit (Text.pack str)
@@ -538,7 +538,7 @@ splitVersion_ :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
 splitVersion_ = fromValue >=> fromStringNoContext >=> \s ->
   pure
     $ nvList
-    $ flip map (splitVersion s)
+    $ flip fmap (splitVersion s)
     $ nvStr
     . makeNixStringWithoutContext
     . versionComponentToString
@@ -615,7 +615,7 @@ match_ pat str = fromValue pat >>= fromStringNoContext >>= \p ->
             otherwise   = toValue $ makeNixStringWithoutContext t
     case matchOnceText re (encodeUtf8 s) of
       Just ("", sarr, "") -> do
-        let s = map fst (elems sarr)
+        let s = fmap fst (elems sarr)
         nvList <$> traverse (mkMatch . decodeUtf8)
                             (if length s > 1 then tail s else s)
       _ -> pure $ nvConstant NNull
@@ -677,7 +677,7 @@ attrNames =
   fromValue @(AttrSet (NValue t f m))
     >=> fmap getDeeper
     .   toValue
-    .   map makeNixStringWithoutContext
+    .   fmap makeNixStringWithoutContext
     .   sort
     .   M.keys
 
@@ -932,7 +932,7 @@ replaceStrings
 replaceStrings tfrom tto ts = fromValue (Deeper tfrom) >>= \(nsFrom :: [NixString]) ->
   fromValue (Deeper tto) >>= \(nsTo :: [NixString]) ->
     fromValue ts >>= \(ns :: NixString) -> do
-      let from = map stringIgnoreContext nsFrom
+      let from = fmap stringIgnoreContext nsFrom
       when (length nsFrom /= length nsTo)
         $  throwError
         $  ErrorCall
@@ -1432,7 +1432,7 @@ partition_ f = fromValue @[NValue t f m] >=> \l -> do
   let match t = f `callFunc` t >>= fmap (, t) . fromValue
   selection <- traverse match l
   let (right, wrong) = partition fst selection
-  let makeSide       = nvList . map snd
+  let makeSide       = nvList . fmap snd
   toValue @(AttrSet (NValue t f m))
     $ M.fromList [("right", makeSide right), ("wrong", makeSide wrong)]
 

src/Nix/Effects/Derivation.hs

@@ -130,24 +130,24 @@ hashDerivationModulo drv@(Derivation {inputs = (inputSrcs, inputDrvs)}) = do
 unparseDrv :: Derivation -> Text
 unparseDrv (Derivation {..}) = Text.append "Derive" $ parens
     [ -- outputs: [("out", "/nix/store/.....-out", "", ""), ...]
-      list $ flip map (Map.toList outputs) (\(outputName, outputPath) ->
+      list $ flip fmap (Map.toList outputs) (\(outputName, outputPath) ->
         let prefix = if hashMode == Recursive then "r:" else "" in
         case mFixed of
           Nothing -> parens [s outputName, s outputPath, s "", s ""]
           Just (Store.SomeDigest (digest :: Store.Digest hashType)) ->
             parens [s outputName, s outputPath, s $ prefix <> Store.algoName @hashType, s $ Store.encodeInBase Store.Base16 digest]
         )
     , -- inputDrvs
-      list $ flip map (Map.toList $ snd inputs) (\(path, outs) ->
-        parens [s path, list $ map s $ sort outs])
+      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)
     , s platform
     , s builder
     , -- run script args
-      list $ map s args
+      list $ fmap s args
     , -- env (key value pairs)
-      list $ flip map (Map.toList env) (\(k, v) ->
+      list $ flip fmap (Map.toList env) (\(k, v) ->
         parens [s k, s v])
     ]
   where
@@ -192,7 +192,7 @@ derivationParser = do
   _ <- ")"
   eof
 
-  let outputs = Map.fromList $ map (\(a, b, _, _) -> (a, b)) fullOutputs
+  let outputs = Map.fromList $ fmap (\(a, b, _, _) -> (a, b)) fullOutputs
   let (mFixed, hashMode) = parseFixed fullOutputs
   let name = "" -- FIXME (extract from file path ?)
   let useJson = ["__json"] == Map.keys env
@@ -332,7 +332,7 @@ buildDerivationWithContext drvAttrs = do
 
       return $ defaultDerivation { platform, builder, args, env,  hashMode, useJson
         , name = drvName
-        , outputs = Map.fromList $ map (\o -> (o, "")) outputs
+        , outputs = Map.fromList $ fmap (\o -> (o, "")) outputs
         , mFixed = mFixedOutput
         }
   where

src/Nix/Eval.hs

@@ -257,7 +257,7 @@ evalBinds recursive binds = do
   go _ (NamedVar (StaticKey "__overrides" :| []) finalValue pos) =
     finalValue >>= fromValue >>= \(o', p') ->
           -- jww (2018-05-09): What to do with the key position here?
-                                              pure $ map
+                                              pure $ fmap
       (\(k, v) -> ([k], fromMaybe pos (M.lookup k p'), demand v pure))
       (M.toList o')
 

src/Nix/Expr/Shorthands.hs

@@ -135,7 +135,7 @@ mkDots e [] = e
 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' <> map (StaticKey ?? Nothing) keys) x)
+  Fix (NSelect e (keys' <> fmap (StaticKey ?? Nothing) keys) x)
 mkDots e keys = Fix $ NSelect e (map (StaticKey ?? Nothing) keys) Nothing
 -}
 

src/Nix/Expr/Strings.hs

@@ -62,7 +62,7 @@ stripIndent xs =
   Indented minIndent
     . removePlainEmpty
     . mergePlain
-    . map snd
+    . fmap snd
     . dropWhileEnd cleanup
     . (\ys -> zip
         (map
@@ -78,11 +78,11 @@ stripIndent xs =
     $ ls'
  where
   ls        = stripEmptyOpening $ splitLines xs
-  ls'       = map (dropSpaces minIndent) ls
+  ls'       = fmap (dropSpaces minIndent) ls
 
   minIndent = case stripEmptyLines ls of
     []         -> 0
-    nonEmptyLs -> minimum $ map (countSpaces . mergePlain) nonEmptyLs
+    nonEmptyLs -> minimum $ fmap (countSpaces . mergePlain) nonEmptyLs
 
   stripEmptyLines = filter $ \case
     [Plain t] -> not $ T.null $ T.strip t
@@ -109,7 +109,7 @@ escapeCodes =
   [('\n', 'n'), ('\r', 'r'), ('\t', 't'), ('\\', '\\'), ('$', '$'), ('"', '"')]
 
 fromEscapeCode :: Char -> Maybe Char
-fromEscapeCode = (`lookup` map swap escapeCodes)
+fromEscapeCode = (`lookup` fmap swap escapeCodes)
 
 toEscapeCode :: Char -> Maybe Char
 toEscapeCode = (`lookup` escapeCodes)

src/Nix/Fresh/Basic.hs

@@ -36,7 +36,7 @@ instance (MonadEffects t f m, MonadDataContext f m)
   findEnvPath      = lift . findEnvPath @t @f @m
   findPath vs path = do
     i <- FreshIdT ask
-    let vs' = map (unliftNValue (runFreshIdT i)) vs
+    let vs' = fmap (unliftNValue (runFreshIdT i)) vs
     lift $ findPath @t @f @m vs' path
   importPath path = do
     i <- FreshIdT ask

src/Nix/Parser.hs

@@ -67,8 +67,7 @@ import qualified Data.HashSet                  as HashSet
 import           Data.List.NonEmpty             ( NonEmpty(..) )
 import qualified Data.List.NonEmpty            as NE
 import qualified Data.Map                      as Map
-import           Data.Text               hiding ( map
-                                                , foldr1
+import           Data.Text               hiding ( foldr1
                                                 , concat
                                                 , concatMap
                                                 , zipWith
@@ -94,7 +93,7 @@ infixl 3 <+>
 ---------------------------------------------------------------------------------
 
 nixExpr :: Parser NExprLoc
-nixExpr = makeExprParser nixTerm $ map (map snd) (nixOperators nixSelector)
+nixExpr = makeExprParser nixTerm $ fmap (fmap snd) (nixOperators nixSelector)
 
 antiStart :: Parser Text
 antiStart = symbol "${" <?> show ("${" :: String)

src/Nix/Pretty.hs

@@ -116,7 +116,7 @@ wrapPath op sub = if wasPath sub
   else wrapParens op sub
 
 prettyString :: NString (NixDoc ann) -> Doc ann
-prettyString (DoubleQuoted parts) = dquotes . hcat . map prettyPart $ parts
+prettyString (DoubleQuoted parts) = dquotes . hcat . fmap prettyPart $ parts
  where
   prettyPart (Plain t)      = pretty . concatMap escape . unpack $ t
   prettyPart EscapedNewline = "''\\n"
@@ -127,11 +127,11 @@ prettyString (Indented _ parts) = group $ nest 2 $ vcat
   [dsquote, content, dsquote]
  where
   dsquote = squote <> squote
-  content = vsep . map prettyLine . stripLastIfEmpty . splitLines $ parts
+  content = vsep . fmap prettyLine . stripLastIfEmpty . splitLines $ parts
   stripLastIfEmpty = reverse . f . reverse   where
     f ([Plain t] : xs) | Text.null (strip t) = xs
     f xs = xs
-  prettyLine = hcat . map prettyPart
+  prettyLine = hcat . fmap prettyPart
   prettyPart (Plain t) =
     pretty . unpack . replace "${" "''${" . replace "''" "'''" $ t
   prettyPart EscapedNewline = "\\n"
@@ -176,7 +176,7 @@ prettyKeyName (DynamicKey key) = runAntiquoted
   key
 
 prettySelector :: NAttrPath (NixDoc ann) -> Doc ann
-prettySelector = hcat . punctuate dot . map prettyKeyName . NE.toList
+prettySelector = hcat . punctuate dot . fmap prettyKeyName . NE.toList
 
 prettyAtom :: NAtom -> NixDoc ann
 prettyAtom atom = simpleExpr $ pretty $ unpack $ atomText atom
@@ -225,23 +225,23 @@ exprFNixDoc = \case
       $ nest 2
       $ vsep
       $ concat
-      $ [[lbracket], map (wrapParens appOpNonAssoc) xs, [rbracket]]
+      $ [[lbracket], fmap (wrapParens appOpNonAssoc) xs, [rbracket]]
   NSet NNonRecursive [] -> simpleExpr $ lbrace <> rbrace
   NSet NNonRecursive xs ->
     simpleExpr
       $ group
       $ nest 2
       $ vsep
       $ concat
-      $ [[lbrace], map prettyBind xs, [rbrace]]
+      $ [[lbrace], fmap prettyBind xs, [rbrace]]
   NSet NRecursive [] -> simpleExpr $ recPrefix <> lbrace <> rbrace
   NSet NRecursive xs ->
     simpleExpr
       $ group
       $ nest 2
       $ vsep
       $ concat
-      $ [[recPrefix <> lbrace], map prettyBind xs, [rbrace]]
+      $ [[recPrefix <> lbrace], fmap prettyBind xs, [rbrace]]
   NAbs args body ->
     leastPrecedence
       $ nest 2
@@ -357,7 +357,7 @@ prettyNValueProv v = do
         $ parens
         $ mconcat
         $ "from: "
-        : map (prettyOriginExpr . _originExpr) ps
+        : fmap (prettyOriginExpr . _originExpr) ps
         ]
 
 prettyNThunk
@@ -379,7 +379,7 @@ prettyNThunk t = do
       $ parens
       $ mconcat
       $ "thunk from: "
-      : map (prettyOriginExpr . _originExpr) ps
+      : fmap (prettyOriginExpr . _originExpr) ps
       ]
 
 -- | This function is used only by the testing code.