Effects: class MonadEffects: (make -> to)AbsolutePath

Since function does not construct a path, it takes a path & checks-converts it to be
absolute path.

Author: Anton-Latukha

src/Nix/Effects.hs

@@ -61,12 +61,11 @@ class
   )
   => MonadEffects t f m where
 
-  -- | Determine the absolute path of relative path in the current context
-  makeAbsolutePath :: Path -> m Path
+  -- | Determine the absolute path in the current context.
+  toAbsolutePath :: Path -> m Path
   findEnvPath :: String -> m Path
 
-  -- | Having an explicit list of sets corresponding to the NIX_PATH
-  -- and a file path try to find an existing path
+  -- | Having an explicit list of sets corresponding to the @NIX_PATH@ and a file path try to find an existing path.
   findPath :: [NValue t f m] -> Path -> m Path
 
   importPath :: Path -> m (NValue t f m)

src/Nix/Effects/Basic.hs

@@ -34,8 +34,8 @@ import           Nix.Value.Monad
 import           GHC.DataSize
 #endif
 
-defaultMakeAbsolutePath :: MonadNix e t f m => Path -> m Path
-defaultMakeAbsolutePath origPath = do
+defaultToAbsolutePath :: MonadNix e t f m => Path -> m Path
+defaultToAbsolutePath origPath = do
   origPathExpanded <- expandHomePath origPath
   absPath          <-
     bool
@@ -102,12 +102,12 @@ findEnvPathM name = do
  where
   nixFilePath :: MonadEffects t f m => Path -> m (Maybe Path)
   nixFilePath path = do
-    absPath <- makeAbsolutePath @t @f path
+    absPath <- toAbsolutePath @t @f path
     isDir   <- doesDirectoryExist absPath
     absFile <-
       bool
         (pure absPath)
-        (makeAbsolutePath @t @f $ coerce $ (coerce absPath) </> "default.nix")
+        (toAbsolutePath @t @f $ coerce $ (coerce absPath) </> "default.nix")
         isDir
     exists <- doesFileExist absFile
     pure $
@@ -232,7 +232,7 @@ findPathM = findPathBy existingPath
   existingPath :: MonadEffects t f m => Path -> m (Maybe Path)
   existingPath path =
     do
-      apath  <- makeAbsolutePath @t @f path
+      apath  <- toAbsolutePath @t @f path
       doesExist <- doesPathExist apath
       pure $ pure apath `whenTrue` doesExist
 

src/Nix/Exec.hs

@@ -212,7 +212,7 @@ instance MonadNix e t f m => MonadEval (NValue t f m) m where
     scope <- currentScopes
     span  <- currentPos
     nvPathP (Provenance scope $ NLiteralPathAnnF span p) <$>
-      makeAbsolutePath @t @f @m p
+      toAbsolutePath @t @f @m p
 
   evalEnvPath p = do
     scope <- currentScopes
@@ -422,10 +422,10 @@ execBinaryOpForced scope span op lval rval = case op of
           (throwError $ ErrorCall "A string that refers to a store path cannot be appended to a path.") -- data/nix/src/libexpr/eval.cc:1412
           (\ rs2 ->
             nvPathP prov <$>
-              makeAbsolutePath @t @f (ls <> (coerce $ toString rs2))
+              toAbsolutePath @t @f (ls <> (coerce $ toString rs2))
           )
           (getStringNoContext rs)
-      (NVPath ls, NVPath rs) -> nvPathP prov <$> makeAbsolutePath @t @f (ls <> rs)
+      (NVPath ls, NVPath rs) -> nvPathP prov <$> toAbsolutePath @t @f (ls <> rs)
 
       (ls@NVSet{}, NVStr rs) ->
         (\ls2 -> nvStrP prov (ls2 <> rs)) <$>

src/Nix/Frames.hs

@@ -30,12 +30,12 @@ import           Nix.Utils                      ( Has(..)
                                                 )
 
 data NixLevel = Fatal | Error | Warning | Info | Debug
-    deriving (Ord, Eq, Bounded, Enum, Show)
+  deriving (Ord, Eq, Bounded, Enum, Show)
 
 data NixFrame = NixFrame
-    { frameLevel :: NixLevel
-    , frame      :: SomeException
-    }
+  { frameLevel :: NixLevel
+  , frame      :: SomeException
+  }
 
 instance Show NixFrame where
   show (NixFrame level f) =
@@ -46,7 +46,7 @@ type Frames = [NixFrame]
 type Framed e m = (MonadReader e m, Has e Frames, MonadThrow m)
 
 newtype NixException = NixException Frames
-    deriving Show
+  deriving Show
 
 instance Exception NixException
 

src/Nix/Fresh/Basic.hs

@@ -29,7 +29,7 @@ instance MonadExec m => MonadExec (StdIdT m)
 
 instance (MonadEffects t f m, MonadDataContext f m)
   => MonadEffects t f (StdIdT m) where
-  makeAbsolutePath = lift . makeAbsolutePath @t @f @m
+  toAbsolutePath = lift . toAbsolutePath @t @f @m
   findEnvPath      = lift . findEnvPath @t @f @m
   findPath vs path = do
     i <- FreshIdT ask

src/Nix/Standard.hs

@@ -106,7 +106,7 @@ instance
   , MonadValue (StdValue m) m
   )
   => MonadEffects (StdThunk m) (StdCited m) m where
-  makeAbsolutePath = defaultMakeAbsolutePath
+  toAbsolutePath   = defaultToAbsolutePath
   findEnvPath      = defaultFindEnvPath
   findPath         = defaultFindPath
   importPath       = defaultImportPath