Type.Type: rm Name in favour Expr.Types.VarName

Author: Anton-Latukha

src/Nix/Type/Assumption.hs

@@ -18,9 +18,10 @@ import           Prelude                 hiding ( Type
                                                 , empty
                                                 )
 
+import           Nix.Expr
 import           Nix.Type.Type
 
-newtype Assumption = Assumption { assumptions :: [(Name, Type)] }
+newtype Assumption = Assumption { assumptions :: [(VarName, Type)] }
   deriving (Eq, Show)
 
 -- We pretend that Assumptions can be inconsistent (nonunique keys),
@@ -33,25 +34,25 @@ instance Monoid Assumption where
   mempty = empty
 
 instance One Assumption where
-  type OneItem Assumption = (Name, Type)
+  type OneItem Assumption = (VarName, Type)
   one (x, y) = Assumption [(x, y)]
 
 empty :: Assumption
 empty = Assumption mempty
 
-extend :: Assumption -> (Name, Type) -> Assumption
+extend :: Assumption -> (VarName, Type) -> Assumption
 extend (Assumption a) (x, s) =
   Assumption $
     (x, s) : a
 
-remove :: Assumption -> Name -> Assumption
+remove :: Assumption -> VarName -> Assumption
 remove (Assumption a) var =
   Assumption $
     filter
       (\(n, _) -> n /= var)
       a
 
-lookup :: Name -> Assumption -> [Type]
+lookup :: VarName -> Assumption -> [Type]
 lookup key (Assumption a) =
   snd <$>
     filter
@@ -65,8 +66,8 @@ merge (Assumption a) (Assumption b) =
 mergeAssumptions :: [Assumption] -> Assumption
 mergeAssumptions = foldl' (<>) mempty
 
-singleton :: Name -> Type -> Assumption
+singleton :: VarName -> Type -> Assumption
 singleton x y = Assumption [(x, y)]
 
-keys :: Assumption -> [Name]
+keys :: Assumption -> [VarName]
 keys (Assumption a) = fst <$> a

src/Nix/Type/Env.hs

@@ -20,14 +20,15 @@ import           Prelude                 hiding ( empty
                                                 , fromList
                                                 )
 
+import           Nix.Expr.Types
 import           Nix.Type.Type
 
 import qualified Data.Map                      as Map
 
 
 -- * Typing Environment
 
-newtype Env = TypeEnv (Map.Map Name [Scheme])
+newtype Env = TypeEnv (Map.Map VarName [Scheme])
   deriving (Eq, Show)
 
 instance Semigroup Env where
@@ -39,22 +40,22 @@ instance Monoid Env where
   mempty = empty
 
 instance One Env where
-  type OneItem Env = (Name, Scheme)
+  type OneItem Env = (VarName, Scheme)
   one = uncurry singleton
 
 empty :: Env
 empty = TypeEnv mempty
 
-extend :: Env -> (Name, [Scheme]) -> Env
+extend :: Env -> (VarName, [Scheme]) -> Env
 extend env (x, s) = TypeEnv $ Map.insert x s $ coerce env
 
-remove :: Env -> Name -> Env
+remove :: Env -> VarName -> Env
 remove (TypeEnv env) var = TypeEnv $ Map.delete var env
 
-extends :: Env -> [(Name, [Scheme])] -> Env
+extends :: Env -> [(VarName, [Scheme])] -> Env
 extends env xs = TypeEnv $ Map.fromList xs <> coerce env
 
-lookup :: Name -> Env -> Maybe [Scheme]
+lookup :: VarName -> Env -> Maybe [Scheme]
 lookup key (TypeEnv tys) = Map.lookup key tys
 
 merge :: Env -> Env -> Env
@@ -66,15 +67,15 @@ mergeRight (TypeEnv a) (TypeEnv b) = TypeEnv $ b <> a
 mergeEnvs :: [Env] -> Env
 mergeEnvs = foldl' (<>) mempty
 
-singleton :: Name -> Scheme -> Env
+singleton :: VarName -> Scheme -> Env
 singleton x y = TypeEnv $ one (x, [y])
 
-keys :: Env -> [Name]
+keys :: Env -> [VarName]
 keys (TypeEnv env) = Map.keys env
 
-fromList :: [(Name, [Scheme])] -> Env
+fromList :: [(VarName, [Scheme])] -> Env
 fromList xs = TypeEnv $ Map.fromList xs
 
-toList :: Env -> [(Name, [Scheme])]
+toList :: Env -> [(VarName, [Scheme])]
 toList (TypeEnv env) = Map.toList env
 

src/Nix/Type/Type.hs

@@ -7,8 +7,6 @@ import           Prelude                 hiding ( Type, TVar )
 import           Data.Foldable                  ( foldr1 )
 import           Nix.Utils                      ( AttrSet )
 
-type Name = Text
-
 -- | Hindrey-Milner type interface
 
 -- | Type variable in the Nix type system.