Convert: Deeper: reduce singleton accessor in favour of the coerce

coerse works & reads intuitively.

Currently because of the size & a lot of type imports to modules, and maybe
because of recursivity of data types - GHC needs type signature help. But in the
future it should improve & it makes code more understandable to the reader.

Author: Anton-Latukha

src/Nix/Builtins.hs

@@ -730,7 +730,7 @@ substringNix start len str =
 attrNamesNix
   :: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
 attrNamesNix =
-  (fmap getDeeper . toValue . fmap makeNixStringWithoutContext . sort . M.keys)
+  (fmap (coerce :: CoerceDeeperToNValue t f m) . toValue . fmap makeNixStringWithoutContext . sort . M.keys)
   <=< fromValue @(AttrSet (NValue t f m))
 
 attrValuesNix
@@ -1441,7 +1441,7 @@ readDirNix nvpath =
         detectFileTypes
         items
 
-    getDeeper <$> toValue (M.fromList itemsWithTypes)
+    (coerce :: CoerceDeeperToNValue t f m) <$> toValue (M.fromList itemsWithTypes)
 
 fromJSONNix
   :: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)

src/Nix/Convert.hs

@@ -27,12 +27,15 @@ import           Nix.Frames
 import           Nix.String
 import           Nix.Value
 import           Nix.Value.Monad
-import           Nix.Thunk
+import           Nix.Thunk                      ( MonadThunk(force) )
 import           Nix.Utils
 
-newtype Deeper a = Deeper { getDeeper :: a }
+newtype Deeper a = Deeper a
   deriving (Typeable, Functor, Foldable, Traversable)
 
+type CoerceDeeperToNValue t f m = Deeper (NValue t f m) -> NValue t f m
+type CoerceDeeperToNValue' t f m = Deeper (NValue' t f m (NValue t f m)) -> NValue' t f m (NValue t f m)
+
 {-
 
 IMPORTANT NOTE
@@ -83,7 +86,7 @@ fromMayToDeeperValue t v =
   do
     v' <- fromValueMay v
     maybe
-      (throwError $ Expectation @t @f @m t $ Free $ getDeeper v)
+      (throwError $ Expectation @t @f @m t $ Free $ (coerce :: CoerceDeeperToNValue' t f m) v)
       pure
       v'
 
@@ -313,8 +316,8 @@ instance ( Convertible e t f m
          , FromValue a m (NValue' t f m (NValue t f m))
          )
   => FromValue a m (Deeper (NValue' t f m (NValue t f m))) where
-  fromValueMay = fromValueMay . getDeeper
-  fromValue    = fromValue . getDeeper
+  fromValueMay = fromValueMay . (coerce :: CoerceDeeperToNValue' t f m)
+  fromValue    = fromValue . (coerce :: CoerceDeeperToNValue' t f m)
 
 
 -- * ToValue