Merge #985: Prelude & Nix.Utils

We essentially had 2 preludes, now they are merged & allow to control what parts of `relude` are exposed.
It clean-up imports quite a bit & provides a set of frequently used functions.

`relude` is a pretty good prelude, but it still has flaws (for example it exposes a mix of `Text` & `String` functions, which is weird from the outside). If we want to use `Text` internally - that should be it, conversion can still be needed (for `base` ^ GHC reasons), but at least is would be only on the IO margins (which are `prelude` functions), not 2 conversions in the middle of data flow.

This setup helps to program with supplying `Text` type functions & support of stronger types.

Now we have both the most flexible `Prelude` setup & the `Nix.Utils` that holds custom code, nice.

Author: Anton-Latukha

.hlint.yaml

@@ -20,12 +20,12 @@
     name: Use Foldable.forM_
 - hint:
     lhs: "pure ()"
-    note: "Use 'pass'"
-    rhs: pass
+    note: "Use 'stub'"
+    rhs: stub
 - hint:
     lhs: "return ()"
-    note: "Use 'pass'"
-    rhs: pass
+    note: "Use 'stub'"
+    rhs: stub
 - hint:
     lhs: "(: [])"
     note: "Use `one`"
@@ -2667,11 +2667,32 @@
     lhs: sum xs / length xs
     note: "Use `average` from `Relude.Extra.Foldable`"
     rhs: average xs
+
 - hint:
     lhs: "\\a -> (a, a)"
-    note: "Use `dup` from `Relude.Extra.Tuple`"
+    note: "Use `dup`"
     rhs: dup
 
 - warn:
     lhs: "() <$ a"
     rhs: void a
+
+- hint:
+    lhs: "pass"
+    note: "Use 'stub'"
+    rhs: stub
+
+- hint:
+    lhs: "bool mempty a b"
+    note: "Use `whenTrue`"
+    rhs: a `whenTrue` b
+
+- hint:
+    lhs: "bool a mempty b"
+    note: "Use `whenFalse`"
+    rhs: a `whenFalse` b
+
+- hint:
+    lhs: "maybe mempty a b"
+    note: "Use `whenJust`"
+    rhs: a `whenJust` b

benchmarks/ParserBench.hs

@@ -1,6 +1,5 @@
 module ParserBench (benchmarks) where
 
-import           Nix.Utils
 import           Nix.Parser
 
 import           Criterion

hnix.cabal

@@ -341,7 +341,9 @@ flag profiling
 
 library
   exposed-modules:
+    Prelude
     Nix
+    Nix.Utils
     Nix.Atoms
     Nix.Builtins
     Nix.Cache
@@ -383,7 +385,6 @@ library
     Nix.Type.Env
     Nix.Type.Infer
     Nix.Type.Type
-    Nix.Utils
     Nix.Utils.Fix1
     Nix.Value
     Nix.Value.Equal
@@ -392,13 +393,13 @@ library
     Nix.XML
   other-modules:
     Paths_hnix
+    Nix.Unused
   autogen-modules:
     Paths_hnix
   hs-source-dirs:
     src
   mixins:
       base hiding (Prelude)
-    , relude (Relude as Prelude)
     , relude
   ghc-options:
     -Wall
@@ -477,6 +478,7 @@ library
     , DeriveLift
     , FlexibleContexts
     , FlexibleInstances
+    , ScopedTypeVariables
     , StandaloneDeriving
     , TypeApplications
     , TypeSynonymInstances
@@ -532,7 +534,6 @@ executable hnix
     , time
   mixins:
       base hiding (Prelude)
-    , relude (Relude as Prelude)
     , relude
   default-extensions:
       OverloadedStrings
@@ -544,6 +545,7 @@ executable hnix
     , DeriveLift
     , FlexibleContexts
     , FlexibleInstances
+    , ScopedTypeVariables
     , StandaloneDeriving
     , TypeApplications
     , TypeSynonymInstances
@@ -579,7 +581,6 @@ test-suite hnix-tests
     TestCommon
   mixins:
       base hiding (Prelude)
-    , relude (Relude as Prelude)
     , relude
   hs-source-dirs:
     tests
@@ -623,6 +624,7 @@ test-suite hnix-tests
     , DeriveLift
     , FlexibleContexts
     , FlexibleInstances
+    , ScopedTypeVariables
     , StandaloneDeriving
     , TypeApplications
     , TypeSynonymInstances
@@ -650,7 +652,6 @@ benchmark hnix-benchmarks
     benchmarks
   mixins:
       base hiding (Prelude)
-    , relude (Relude as Prelude)
     , relude
   ghc-options:
     -Wall
@@ -676,6 +677,7 @@ benchmark hnix-benchmarks
     , DeriveLift
     , FlexibleContexts
     , FlexibleInstances
+    , ScopedTypeVariables
     , StandaloneDeriving
     , TypeApplications
     , TypeSynonymInstances

main/Main.hs

@@ -1,24 +1,19 @@
 {-# language MultiWayIf #-}
-{-# language ScopedTypeVariables #-}
 {-# language TypeFamilies #-}
 {-# language RecordWildCards #-}
 
 module Main ( main ) where
 
-import           Nix.Utils
+import           Relude                        as Prelude ( force )
 import           Control.Comonad                ( extract )
 import qualified Control.Exception             as Exception
 import           GHC.Err                        ( errorWithoutStackTrace )
 import           Control.Monad.Free
 import           Control.Monad.Ref              ( MonadRef(readRef) )
 import           Control.Monad.Catch
-import           System.IO                      ( hPutStrLn
-                                                , getContents
-                                                )
+import           System.IO                      ( hPutStrLn )
 import qualified Data.HashMap.Lazy             as M
 import qualified Data.Map                      as Map
-import           Data.Maybe                     ( fromJust )
-import qualified Data.String                   as String
 import           Data.Time
 import qualified Data.Text.IO                  as Text
 import           Text.Show.Pretty               ( ppShow )
@@ -56,14 +51,14 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
   execContentsFilesOrRepl :: StandardT (StdIdT IO) ()
   execContentsFilesOrRepl =
     fromMaybe
-      loadFromCLIFilePathList
+      loadFromCliFilePathList
       ( loadBinaryCacheFile <|>
         loadLiteralExpression <|>
         loadExpressionFromFile
       )
    where
     -- | The base case: read expressions from the last CLI directive (@[FILE]@) listed on the command line.
-    loadFromCLIFilePathList =
+    loadFromCliFilePathList =
       case filePaths of
         []     -> runRepl
         ["-"]  -> readExpressionFromStdin
@@ -83,10 +78,10 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
 
     -- |  The `--read` option: load expression from a serialized file.
     loadBinaryCacheFile =
-      (\binaryCacheFile ->
+      (\ (binaryCacheFile :: Path) ->
         do
-          let file = replaceExtension binaryCacheFile "nixc"
-          processCLIOptions (Just $ coerce file) =<< liftIO (readCache $ coerce binaryCacheFile)
+          let file = coerce $ (replaceExtension . coerce) binaryCacheFile "nixc"
+          processCLIOptions (Just file) =<< liftIO (readCache binaryCacheFile)
       ) <$> readFrom
 
     -- | The `--expr` option: read expression from the argument string
@@ -97,9 +92,9 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
       -- We can start use Text as in the base case, requires changing Path -> Text
       -- But that is a gradual process:
       -- https://github.com/haskell-nix/hnix/issues/912
-      (processSeveralFiles . (coerce <$>) . String.lines <=< liftIO) .
+      (processSeveralFiles . (coerce . toString <$>) . lines <=< liftIO) .
         (\case
-          "-" -> getContents
+          "-" -> Text.getContents
           _fp -> readFile _fp
         ) <$> fromFile
 
@@ -126,7 +121,7 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
               either
                 (\ err -> errorWithoutStackTrace $ "Type error: " <> ppShow err)
                 (\ ty  -> liftIO $ putStrLn $ "Type of expression: " <>
-                  ppShow (fromJust $ Map.lookup @VarName @[Scheme] "it" (coerce ty))
+                  ppShow (maybeToMonoid $ Map.lookup @VarName @[Scheme] "it" $ coerce ty)
                 )
                 (HM.inferTop mempty [("it", stripAnnotation expr')])
 
@@ -159,7 +154,7 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
     | evaluate =
       if
         | tracing                       -> evaluateExprWithEvaluator nixTracingEvalExprLoc expr
-        | Just path <- reduce           -> evaluateExprWithEvaluator (reduction (coerce path) . coerce) expr
+        | Just path <- reduce           -> evaluateExprWithEvaluator (reduction path . coerce) expr
         | null arg || null argstr       -> evaluateExprWithEvaluator nixEvalExprLoc expr
         | otherwise                     -> processResult printer <=< nixEvalExprLoc (coerce mpath) $ expr
     | xml                        = fail "Rendering expression trees to XML is not yet implemented"
@@ -245,10 +240,10 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
                       liftIO $ Text.putStrLn path
                       when descend $
                         maybe
-                          pass
+                          stub
                           (\case
                             NVSet _ s' -> go (path <> ".") s'
-                            _          -> pass
+                            _          -> stub
                           )
                           mv
               )