treewide: merge Prelude with Utils

This allows to achieve Zen of Text<->String & Path<->FilePath.

Set of functions for Text & Path now can be formed & exported.

Author: Anton-Latukha

benchmarks/ParserBench.hs

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

hnix.cabal

@@ -384,7 +384,6 @@ library
     Nix.Type.Env
     Nix.Type.Infer
     Nix.Type.Type
-    Nix.Utils
     Nix.Utils.Fix1
     Nix.Value
     Nix.Value.Equal
@@ -399,7 +398,6 @@ library
     src
   mixins:
       base hiding (Prelude)
-    , relude (Relude as Prelude)
     , relude
   ghc-options:
     -Wall
@@ -534,7 +532,6 @@ executable hnix
     , time
   mixins:
       base hiding (Prelude)
-    , relude (Relude as Prelude)
     , relude
   default-extensions:
       OverloadedStrings
@@ -582,7 +579,6 @@ test-suite hnix-tests
     TestCommon
   mixins:
       base hiding (Prelude)
-    , relude (Relude as Prelude)
     , relude
   hs-source-dirs:
     tests
@@ -654,7 +650,6 @@ benchmark hnix-benchmarks
     benchmarks
   mixins:
       base hiding (Prelude)
-    , relude (Relude as Prelude)
     , relude
   ghc-options:
     -Wall

main/Main.hs

@@ -4,20 +4,16 @@
 
 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 )
@@ -55,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
@@ -96,10 +92,10 @@ 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
-          _fp -> readFile _fp
+          "-" -> Text.getContents
+          _fp -> Text.readFile _fp
         ) <$> fromFile
 
   processExpr text = handleResult Nothing     $   parseNixTextLoc text
@@ -125,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 (fromMaybe mempty $ Map.lookup @VarName @[Scheme] "it" $ coerce ty)
                 )
                 (HM.inferTop mempty [("it", stripAnnotation expr')])
 

main/Repl.hs

@@ -17,7 +17,6 @@ module Repl
 import           Prelude                 hiding ( state )
 import           Nix                     hiding ( exec )
 import           Nix.Scope
-import           Nix.Utils
 import           Nix.Value.Monad                ( demand )
 
 import qualified Data.HashMap.Lazy           as M
@@ -268,11 +267,15 @@ printValue :: (MonadNix e t f m, MonadIO m)
            -> Repl e t f m ()
 printValue val = do
   cfg <- replCfg <$> get
+  let
+    g :: MonadIO m => Doc ann0 -> m ()
+    g = liftIO . print
+
   lift $ lift $
     (if
-      | cfgStrict cfg -> liftIO . print . prettyNValue     <=< normalForm
-      | cfgValues cfg -> liftIO . print . prettyNValueProv <=< removeEffects
-      | otherwise     -> liftIO . print . prettyNValue     <=< removeEffects
+      | cfgStrict cfg -> g . prettyNValue     <=< normalForm
+      | cfgValues cfg -> g . prettyNValueProv <=< removeEffects
+      | otherwise     -> g . prettyNValue     <=< removeEffects
     ) val
 
 
@@ -297,16 +300,15 @@ browse _ =
 load
   :: (MonadNix e t f m, MonadIO m)
   -- This one does I String -> O String pretty fast, it is ugly to double marshall here.
-  => String
+  => Path
   -> Repl e t f m ()
-load args =
+load path =
   do
-    contents <- liftIO $
-      Text.readFile $
-       trim args
+    contents <- liftIO $ Prelude.readFile $
+       trim path
     void $ exec True contents
  where
-  trim = dropWhileEnd isSpace . dropWhile isSpace
+  trim = dropWhileEnd isSpace . dropWhile isSpace . coerce
 
 -- | @:type@ command
 typeof
@@ -404,14 +406,20 @@ completeFunc reversedPrev word
                     candidates
                   )
         )
-        (M.lookup (coerce var) (coerce $ replCtx state))
+        (M.lookup (coerce var) $ coerce $ replCtx state)
 
   -- Builtins, context variables
   | otherwise =
     do
       state <- get
-      let contextKeys = M.keys @VarName @(NValue t f m) (coerce $ replCtx state)
-          (Just (NVSet _ builtins)) = M.lookup "builtins" (coerce $ replCtx state)
+      let
+          scopeHashMap :: HashMap VarName (NValue t f m)
+          scopeHashMap = coerce $ replCtx state
+          contextKeys :: [VarName]
+          contextKeys = M.keys scopeHashMap
+          builtins :: AttrSet (NValue t f m)
+          (Just (NVSet _ builtins)) = M.lookup "builtins" scopeHashMap
+          shortBuiltins :: [VarName]
           shortBuiltins = M.keys builtins
 
       pure $ listCompletion $ toString <$>
@@ -468,7 +476,7 @@ helpOptions =
       "help"
       ""
       "Print help text"
-      (help helpOptions . toText)
+      (help helpOptions . fromString)
   , HelpOption
       "paste"
       ""
@@ -478,17 +486,17 @@ helpOptions =
       "load"
       "FILENAME"
       "Load .nix file into scope"
-      load
+      (load . fromString)
   , HelpOption
       "browse"
       ""
       "Browse bindings in interpreter context"
-      (browse . toText)
+      (browse . fromString)
   , HelpOption
       "type"
       "EXPRESSION"
       "Evaluate expression or binding from context and print the type of the result value"
-      (typeof . toText)
+      (typeof . fromString)
   , HelpOption
       "quit"
       ""
@@ -503,7 +511,7 @@ helpOptions =
         <> Prettyprinter.line
         <> renderSetOptions helpSetOptions
       )
-      (setConfig . toText)
+      (setConfig . fromString)
   ]
 
 -- | Options for :set

src/Nix.hs

@@ -47,7 +47,6 @@ import           Nix.Pretty
 import           Nix.Reduce
 import           Nix.Render.Frame
 import           Nix.Thunk
-import           Nix.Utils
 import           Nix.Value
 import           Nix.Value.Monad
 import           Nix.XML

src/Nix/Builtins.hs

@@ -21,9 +21,7 @@ module Nix.Builtins
 where
 
 
-import           Prelude                 hiding ( traceM )
 import           GHC.Exception                  ( ErrorCall(ErrorCall) )
-import           Nix.Utils
 import           Control.Comonad                ( Comonad )
 import           Control.Monad                  ( foldM )
 import           Control.Monad.Catch            ( MonadCatch(catch) )

src/Nix/Cache.hs

@@ -4,7 +4,6 @@
 module Nix.Cache where
 
 import qualified Data.ByteString.Lazy          as BSL
-import           Nix.Utils
 import           Nix.Expr.Types.Annotated
 
 #if defined (__linux__)

src/Nix/Cited/Basic.hs

@@ -4,7 +4,6 @@
 
 module Nix.Cited.Basic where
 
-import           Prelude                 hiding ( force )
 import           Control.Comonad                ( Comonad )
 import           Control.Comonad.Env            ( ComonadEnv )
 import           Control.Monad.Catch     hiding ( catchJust )
@@ -16,7 +15,6 @@ import           Nix.Expr.Types.Annotated
 import           Nix.Frames
 import           Nix.Options
 import           Nix.Thunk
-import           Nix.Utils
 import           Nix.Value
 
 

src/Nix/Context.hs

@@ -7,7 +7,6 @@ import           Nix.Frames                     ( Frames )
 import           Nix.Expr.Types.Annotated       ( SrcSpan
                                                 , nullSpan
                                                 )
-import           Nix.Utils                      ( Has(..) )
 
 --  2021-07-18: NOTE: It should be Options -> Scopes -> Frames -> Source(span)
 data Context m t = Context

src/Nix/Convert.hs

@@ -15,7 +15,6 @@
 
 module Nix.Convert where
 
-import           Prelude                 hiding ( force )
 import           Control.Monad.Free
 import qualified Data.HashMap.Lazy             as M
 import           Nix.Atoms
@@ -27,7 +26,6 @@ import           Nix.String
 import           Nix.Value
 import           Nix.Value.Monad
 import           Nix.Thunk                      ( MonadThunk(force) )
-import           Nix.Utils
 
 newtype Deeper a = Deeper a
   deriving (Typeable, Functor, Foldable, Traversable)
@@ -233,6 +231,17 @@ instance Convertible e t f m
 
   fromValue = fromMayToValue $ TString mempty
 
+instance Convertible e t f m
+  => FromValue Text m (NValue' t f m (NValue t f m)) where
+
+  fromValueMay =
+    pure .
+      \case
+        NVStr' ns -> getStringNoContext ns
+        _         -> mempty
+
+  fromValue = fromMayToValue $ TString mempty
+
 instance ( Convertible e t f m
          , MonadValue (NValue t f m) m
          )
@@ -374,6 +383,10 @@ instance Convertible e t f m
   => ToValue ByteString m (NValue' t f m (NValue t f m)) where
   toValue = pure . nvStr' . mkNixStringWithoutContext . decodeUtf8
 
+instance Convertible e t f m
+  => ToValue Text m (NValue' t f m (NValue t f m)) where
+  toValue = pure . nvStr' . mkNixStringWithoutContext
+
 instance Convertible e t f m
   => ToValue Path m (NValue' t f m (NValue t f m)) where
   toValue = pure . nvPath' . coerce