Merge #979: Path type boundary, improving Annotated

After `String` got prunned, what is left is `FilePath` everywhere.

This PR approaches this (#912) with the first step - differentiating between path information & `String`, which this is doing.

The outside layer & optpatse stuff `{Nix, Nix.Options, Shorthands}` externally use `FilePath` to not scare the most non-involved users of library with `Path` type, thou all it requires is coerce.

Maybe it would've been a good Haskell practive for libraries to use newtype wrappers & coerce for type boundaries, in that way ecosystem architecture would've be much more flexible & already solving the data types situations, but I digress.

Further allowign to use something like `path` package & migrating more processing to `Text`.

Further what should be looked into is returning pretty paths.


Module Annotated got a big refactor, rework, clean-up.

Author: Anton-Latukha

benchmarks/ParserBench.hs

@@ -1,11 +1,12 @@
 module ParserBench (benchmarks) where
 
+import           Nix.Utils
 import           Nix.Parser
 
 import           Criterion
 
-benchFile :: FilePath -> Benchmark
-benchFile = bench <*> whnfIO . parseNixFile . ("data/" <>)
+benchFile :: Path -> Benchmark
+benchFile = bench . coerce <*> whnfIO . parseNixFile . ("data/" <>)
 
 benchmarks :: Benchmark
 benchmarks = bgroup

hnix.cabal

@@ -485,6 +485,7 @@ library
     , TupleSections
     , LambdaCase
     , BangPatterns
+    , ViewPatterns
   if flag(optimize)
     default-extensions:
       ApplicativeDo
@@ -551,6 +552,7 @@ executable hnix
     , TupleSections
     , LambdaCase
     , BangPatterns
+    , ViewPatterns
   if flag(optimize)
     default-extensions:
       ApplicativeDo
@@ -629,6 +631,7 @@ test-suite hnix-tests
     , TupleSections
     , LambdaCase
     , BangPatterns
+    , ViewPatterns
   if flag(optimize)
     default-extensions:
       ApplicativeDo
@@ -681,6 +684,7 @@ benchmark hnix-benchmarks
     , TupleSections
     , LambdaCase
     , BangPatterns
+    , ViewPatterns
   if flag(optimize)
     default-extensions:
       ApplicativeDo

main/Main.hs

@@ -1,8 +1,7 @@
-{-# LANGUAGE MultiWayIf #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE ViewPatterns #-}
-{-# LANGUAGE RecordWildCards #-}
+{-# language MultiWayIf #-}
+{-# language ScopedTypeVariables #-}
+{-# language TypeFamilies #-}
+{-# language RecordWildCards #-}
 
 module Main ( main ) where
 
@@ -68,7 +67,7 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
       case filePaths of
         []     -> runRepl
         ["-"]  -> readExpressionFromStdin
-        _paths -> processSeveralFiles _paths
+        _paths -> processSeveralFiles (coerce _paths)
      where
       -- | Fall back to running the REPL
       runRepl = withEmptyNixContext Repl.main
@@ -87,18 +86,18 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
       (\binaryCacheFile ->
         do
           let file = replaceExtension binaryCacheFile "nixc"
-          processCLIOptions (Just file) =<< liftIO (readCache binaryCacheFile)
+          processCLIOptions (Just $ coerce file) =<< liftIO (readCache $ coerce $ binaryCacheFile)
       ) <$> readFrom
 
     -- | The `--expr` option: read expression from the argument string
     loadLiteralExpression = processExpr <$> expression
 
     -- | The `--file` argument: read expressions from the files listed in the argument file
     loadExpressionFromFile =
-      -- We can start use Text as in the base case, requires changing FilePath -> Text
+      -- 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 . String.lines <=< liftIO) .
+      (processSeveralFiles . (coerce <$>) . String.lines <=< liftIO) .
         (\case
           "-" -> getContents
           _fp -> readFile _fp
@@ -148,25 +147,25 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
               bool
                 Repl.main
                 (do
-                  val <- nixEvalExprLoc mpath expr
+                  val <- nixEvalExprLoc (coerce mpath) expr
                   Repl.main' $ pure val
                 )
                 evaluate
       )
 
   --  2021-07-15: NOTE: Logic of CLI Option processing is scattered over several functions, needs to be consolicated.
-  processCLIOptions :: Maybe FilePath -> NExprLoc -> StandardT (StdIdT IO) ()
+  processCLIOptions :: Maybe Path -> NExprLoc -> StandardT (StdIdT IO) ()
   processCLIOptions mpath expr
     | evaluate =
       if
         | tracing                       -> evaluateExprWithEvaluator nixTracingEvalExprLoc expr
-        | Just path <- reduce           -> evaluateExprWithEvaluator (reduction path) expr
+        | Just path <- reduce           -> evaluateExprWithEvaluator (reduction (coerce path) . coerce) expr
         | null arg || null argstr       -> evaluateExprWithEvaluator nixEvalExprLoc expr
-        | otherwise                     -> processResult printer <=< nixEvalExprLoc mpath $ expr
+        | otherwise                     -> processResult printer <=< nixEvalExprLoc (coerce mpath) $ expr
     | xml                        = fail "Rendering expression trees to XML is not yet implemented"
     | json                       = fail "Rendering expression trees to JSON is not implemented"
     | verbose >= DebugInfo       =  liftIO . putStr . ppShow . stripAnnotation $ expr
-    | cache , Just path <- mpath =  liftIO . writeCache (replaceExtension path "nixc") $ expr
+    | cache , Just path <- mpath =  liftIO . writeCache (coerce $ replaceExtension (coerce path) "nixc") $ expr
     | parseOnly                  =  void . liftIO . Exception.evaluate . force $ expr
     | otherwise                  =
       liftIO .
@@ -177,7 +176,7 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
           . stripAnnotation
           $ expr
    where
-    evaluateExprWithEvaluator evaluator = evaluateExpression mpath evaluator printer
+    evaluateExprWithEvaluator evaluator = evaluateExpression (coerce mpath) evaluator printer
 
     printer
       | finder    = findAttrs <=< fromValue @(AttrSet (StdValue (StandardT (StdIdT IO))))
@@ -307,10 +306,10 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
 
   handleReduced
     :: (MonadThrow m, MonadIO m)
-    => FilePath
+    => Path
     -> (NExprLoc, Either SomeException (NValue t f m))
     -> m (NValue t f m)
-  handleReduced path (expr', eres) =
+  handleReduced (coerce -> path) (expr', eres) =
     do
       liftIO $
         do

main/Repl.hs

@@ -7,9 +7,8 @@
    directory for more details.
 -}
 
-{-# LANGUAGE MultiWayIf #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE ViewPatterns #-}
+{-# language MultiWayIf #-}
+{-# language ScopedTypeVariables #-}
 
 module Repl
   ( main

src/Nix.hs

@@ -1,10 +1,11 @@
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE ViewPatterns #-}
+{-# language ScopedTypeVariables #-}
 
 module Nix
   ( module Nix.Cache
   , module Nix.Exec
-  , module Nix.Expr
+  , module Nix.Expr.Types
+  , module Nix.Expr.Shorthands
+  , module Nix.Expr.Types.Annotated
   , module Nix.Frames
   , module Nix.Render.Frame
   , module Nix.Normal
@@ -35,7 +36,9 @@ import           Nix.Builtins
 import           Nix.Cache
 import qualified Nix.Eval                      as Eval
 import           Nix.Exec
-import           Nix.Expr
+import           Nix.Expr.Types
+import           Nix.Expr.Shorthands
+import           Nix.Expr.Types.Annotated
 import           Nix.Frames
 import           Nix.String
 import           Nix.Normal
@@ -60,7 +63,7 @@ nixEval
   -> Maybe FilePath
   -> Fix g
   -> m a
-nixEval transform alg mpath = withNixContext mpath . adi transform alg
+nixEval transform alg mpath = withNixContext (coerce mpath) . adi transform alg
 
 -- | Evaluate a nix expression in the default context
 nixEvalExpr
@@ -92,7 +95,7 @@ nixTracingEvalExprLoc
   => Maybe FilePath
   -> NExprLoc
   -> m (NValue t f m)
-nixTracingEvalExprLoc mpath = withNixContext mpath . evalExprLoc
+nixTracingEvalExprLoc mpath = withNixContext (coerce mpath) . evalExprLoc
 
 evaluateExpression
   :: (MonadNix e t f m, Has e Options)

src/Nix/Atoms.hs

@@ -1,5 +1,5 @@
-{-# LANGUAGE CPP            #-}
-{-# LANGUAGE DeriveAnyClass #-}
+{-# language CPP            #-}
+{-# language DeriveAnyClass #-}
 
 module Nix.Atoms where