Type.Env: drop singleton accessor, add&use mergeRight for <> (infixr)

As long as type as newtype - singleton accessor is an antipattern.

It is stongly seen in this example, black magic with accessors, accessor
constructrs
& accesor set overrides was reduced.

Author: Anton-Latukha

main/Main.hs

@@ -28,7 +28,8 @@ import           Nix.Json
 import           Nix.Options.Parser
 import           Nix.Standard
 import           Nix.Thunk.Basic
-import qualified Nix.Type.Env                  as Env
+import           Nix.Type.Env                   ( Env(..) )
+import           Nix.Type.Type                  ( Scheme )
 import qualified Nix.Type.Infer                as HM
 import           Nix.Value.Monad
 import           Options.Applicative     hiding ( ParserResult(..) )
@@ -103,7 +104,7 @@ main =
               either
                 (\ err -> errorWithoutStackTrace $ "Type error: " <> PS.ppShow err)
                 (\ ty  -> liftIO $ putStrLn $ "Type of expression: " <> PS.ppShow
-                  (fromJust $ Map.lookup "it" $ Env.types ty)
+                  (fromJust $ Map.lookup "it" (coerce ty :: Map Text [Scheme]))
                 )
                 (HM.inferTop mempty [("it", stripAnnotation expr')])
 

src/Nix/Type/Env.hs

@@ -27,11 +27,13 @@ import qualified Data.Map                      as Map
 
 -- * Typing Environment
 
-newtype Env = TypeEnv { types :: Map.Map Name [Scheme] }
+newtype Env = TypeEnv (Map.Map Name [Scheme])
   deriving (Eq, Show)
 
 instance Semigroup Env where
-  (<>) = merge
+  -- | Right-biased merge (override). Analogous to @//@ in @Nix@
+  -- Since nature of environment is to update & grow.
+  (<>) = mergeRight
 
 instance Monoid Env where
   mempty = empty
@@ -44,20 +46,23 @@ empty :: Env
 empty = TypeEnv mempty
 
 extend :: Env -> (Name, [Scheme]) -> Env
-extend env (x, s) = env { types = Map.insert x s (types env) }
+extend env (x, s) = TypeEnv $ Map.insert x s $ coerce env
 
 remove :: Env -> Name -> Env
 remove (TypeEnv env) var = TypeEnv $ Map.delete var env
 
 extends :: Env -> [(Name, [Scheme])] -> Env
-extends env xs = env { types = Map.fromList xs `Map.union` types env }
+extends env xs = TypeEnv $ Map.fromList xs `Map.union` coerce env
 
 lookup :: Name -> Env -> Maybe [Scheme]
 lookup key (TypeEnv tys) = Map.lookup key tys
 
 merge :: Env -> Env -> Env
 merge (TypeEnv a) (TypeEnv b) = TypeEnv $ a `Map.union` b
 
+mergeRight :: Env -> Env -> Env
+mergeRight (TypeEnv a) (TypeEnv b) = TypeEnv $ b `Map.union` a
+
 mergeEnvs :: [Env] -> Env
 mergeEnvs = foldl' (<>) mempty