[use 'Name' rather than HsName in type checker. other cleanups.
John Meacham <john@repetae.net>**20051206123137] hunk ./DataConstructors.hs 38
-import Util.VarName
hunk ./DataConstructors.hs 51
-    tipe' (TCon (Tycon n k)) =  return $ ELit (LitCons (toName TypeConstructor n) [] (kind k))
+    tipe' (TCon (Tycon n k)) =  return $ ELit (LitCons n [] (kind k))
hunk ./E/FromHs.hs 59
-lt n =  atomIndex $ toAtom $ toName TypeVal n
+lt :: Name -> Int
+lt n | nameType n == TypeVal =  atomIndex $ toAtom $  n
hunk ./E/FromHs.hs 64
-tipe (TCon (Tycon n k)) =  ELit (LitCons (toName TypeConstructor n) [] (kind k))
+tipe (TCon (Tycon n k)) =  ELit (LitCons n [] (kind k))
hunk ./E/FromHs.hs 102
-    lt n =  nameToInt (fromTypishHsName  n)
+    --lt n =  nameToInt (fromTypishHsName  n)
+    lt n =  nameToInt n
hunk ./E/FromHs.hs 109
-    lt n =  nameToInt (fromTypishHsName  n)
+    --lt n =  nameToInt (fromTypishHsName  n)
+    lt n =  nameToInt n
hunk ./E/FromHs.hs 170
-        methodName = toName Name.Val n
+        methodName =  n
hunk ./E/FromHs.hs 172
-        defaultName =  (toName Name.Val (defaultInstanceName n))
+        defaultName =  (defaultInstanceName n)
hunk ./E/FromHs.hs 178
-            name = (toName Name.Val (instanceName n (getTypeCons t)))
+            name = ((instanceName n (getTypeCons t)))
hunk ./E/FromHs.hs 190
-        methodName = toName Name.Val n
-        Just (deftvr@(TVr { tvrType = ty}),defe) = findName (toName Name.Val (defaultInstanceName n))
+        methodName =  n
+        Just (deftvr@(TVr { tvrType = ty}),defe) = findName ((defaultInstanceName n))
hunk ./E/FromHs.hs 205
-            name = toName Name.Val (instanceName n (getTypeCons t))
+            name = (instanceName n (getTypeCons t))
hunk ./E/FromHs.hs 219
-    cClass classRecord =  [ setProperty prop_METHOD $ tVr (nameToInt $ toName Name.Val n) (convertOneVal t) | n :>: t <- classAssumps classRecord ]
+    cClass classRecord =  [ setProperty prop_METHOD $ tVr (nameToInt $ n) (convertOneVal t) | n :>: t <- classAssumps classRecord ]
hunk ./E/FromHs.hs 321
-    cDecl HsNewTypeDecl {  hsDeclName = dname, hsDeclArgs = dargs, hsDeclCon = dcon, hsDeclDerives = derives } = makeDerives dname dargs [dcon] derives
-    cDecl HsDataDecl {  hsDeclName = dname, hsDeclArgs = dargs, hsDeclCons = dcons, hsDeclDerives = derives } = makeDerives dname dargs dcons derives
+    cDecl HsNewTypeDecl {  hsDeclName = dname, hsDeclArgs = dargs, hsDeclCon = dcon, hsDeclDerives = derives } = makeDerives dname dargs [dcon] (map (toName ClassName) derives)
+    cDecl HsDataDecl {  hsDeclName = dname, hsDeclArgs = dargs, hsDeclCons = dcons, hsDeclDerives = derives } = makeDerives dname dargs dcons (map (toName ClassName) derives)
hunk ./E/FromHs.hs 326
-        f n | n == classBounded, all (null . hsConDeclArgs) dcons  = []
+        f n | n == class_Bounded, all (null . hsConDeclArgs) dcons  = []
hunk ./E/FromHs.hs 392
-    getAssumpCon n = case Map.lookup (toName Name.DataConstructor n) assumps of
+    getAssumpCon n  = case Map.lookup (toName Name.DataConstructor n) assumps of
hunk ./E/FromHs.hs 395
-    getAssump n = case Map.lookup (toName Name.Val n) assumps of
+    getAssump n  = case Map.lookup (toName Name.Val n) assumps of
hunk ./E/FromHs.hs 423
-        cr = findClassRecord classHierarchy name
+        cr = findClassRecord classHierarchy (toName ClassName name)
hunk ./E/FromHs.hs 426
-            defaultName = toName Name.Val $ defaultInstanceName n
-            (TVr { tvrType = ty}) = tv n
+            defaultName = defaultInstanceName n
+            (TVr { tvrType = ty}) = tv (nameName n)
hunk ./FrontEnd/Class.hs 51
-    topDefaults
+    topDefaults,
+    derivableClasses,
+    stdClasses,
+    numClasses
hunk ./FrontEnd/Class.hs 185
-showPred (IsIn c t)
-   = show c ++ " " ++ (pretty t)
+showPred (IsIn c t) = show c ++ " " ++ (pretty t)
hunk ./FrontEnd/Class.hs 187
-makeDeriveInstances :: [Pred] -> Type -> [Class] -> [Inst]
-makeDeriveInstances context t [] = []
-makeDeriveInstances context t (c:cs)
-   | c `elem` derivableClasses
-        = (context :=> IsIn c t) : makeDeriveInstances context t cs
-   | otherwise
-        = error $ "makeDeriveInstances: attempt to make type " ++ pretty t ++
-                  "\nan instance of a non-derivable class " ++ show c
hunk ./FrontEnd/Class.hs 188
+--makeDeriveInstances :: [Pred] -> Type -> [Class] -> [Inst]
+--makeDeriveInstances context t [] = []
+--makeDeriveInstances context t (c:cs)
+--   | c `elem` derivableClasses
+--        = (context :=> IsIn c t) : makeDeriveInstances context t cs
+--   | otherwise
+--        = error $ "makeDeriveInstances: attempt to make type " ++ pretty t ++
+--                  "\nan instance of a non-derivable class " ++ show c
+
+{-
hunk ./FrontEnd/Class.hs 216
+-}
hunk ./FrontEnd/Class.hs 219
-
hunk ./FrontEnd/Class.hs 223
-addClassToHierarchy  kt (HsClassDecl _ t decls) (ClassHierarchy h) |   (HsQualType cntxt (HsTyApp (HsTyCon className) (HsTyVar argName)))  <- toHsQualType t = let
+addClassToHierarchy  kt (HsClassDecl _ t decls) (ClassHierarchy h) |   (HsQualType cntxt (HsTyApp (HsTyCon className') (HsTyVar argName')))  <- toHsQualType t = let
hunk ./FrontEnd/Class.hs 226
-   in return $ ClassHierarchy $ Map.insertWith combineClassRecords  className ClassRecord { className = className, classSupers = map fst cntxt, classInsts = [], classDerives = [], classAssumps = qualifiedMethodAssumps } h
+   className = toName ClassName className'
+   argName = toName TypeVal argName'
+   in return $ ClassHierarchy $ Map.insertWith combineClassRecords  className ClassRecord { classSrcLoc = bogusASrcLoc, className = className, classSupers = map fst (hsContextToContext cntxt), classInsts = [], classDerives = [], classAssumps = qualifiedMethodAssumps } h
hunk ./FrontEnd/Class.hs 243
-qualifyMethod :: HsContext -> (HsDecl) -> (HsDecl)
+qualifyMethod :: Context -> (HsDecl) -> (HsDecl)
hunk ./FrontEnd/Class.hs 245
-    = HsTypeSig sloc names (HsQualType ((c,n'):oc) t) where
+    = HsTypeSig sloc names (HsQualType ((nameName c,n'):oc) t) where
hunk ./FrontEnd/Class.hs 251
-        f (HsTyVar n') | hsNameToOrig n' == hsNameToOrig n = return n'
+        f (HsTyVar n') | hsNameToOrig n' == hsNameToOrig (nameName n) = return n'
hunk ./FrontEnd/Class.hs 271
-   printClassDetails :: (HsName, ClassRecord) -> IO ()
+   printClassDetails :: (Name, ClassRecord) -> IO ()
hunk ./FrontEnd/Class.hs 371
-              -> (map (aHsAsstToPred kt) context, cType, aType)
+              -> (map (hsAsstToPred kt) context, cType, aType)
hunk ./FrontEnd/Class.hs 388
-              -> let tyConName = nameOfTyCon tyCon
+              -> let tyConName = nameOfTyCon TypeConstructor tyCon
hunk ./FrontEnd/Class.hs 397
-   className = nameOfTyCon classType
+   className = nameOfTyCon ClassName classType
hunk ./FrontEnd/Class.hs 401
-hsInstDeclToInst kt (HsDataDecl _sloc cntxt tyConName argNames _condecls derives@(_:_))
+hsInstDeclToInst kt (HsDataDecl _sloc _cntxt tyConName argNames _condecls derives@(_:_))
hunk ./FrontEnd/Class.hs 404
-   tyConKind = kindOf tyConName kt
+   tyConKind = kindOf (toName TypeConstructor tyConName) kt
hunk ./FrontEnd/Class.hs 412
-   newContext = map (aHsAsstToPred kt) cntxt
+   --newContext = map (hsAsstToPred kt) cntxt
hunk ./FrontEnd/Class.hs 416
-hsInstDeclToInst kt (HsNewTypeDecl _sloc cntxt tyConName argNames _condecls derives@(_:_))
+hsInstDeclToInst kt (HsNewTypeDecl _sloc _cntxt tyConName argNames _condecls derives@(_:_))
hunk ./FrontEnd/Class.hs 419
-   tyConKind = kindOf tyConName kt
+   tyConKind = kindOf (toName TypeConstructor tyConName) kt
hunk ./FrontEnd/Class.hs 427
-   newContext = map (aHsAsstToPred kt) cntxt
+   --newContext = map (hsAsstToPred kt) cntxt
hunk ./FrontEnd/Class.hs 440
-toType (HsTyCon n, k) = TCon $ Tycon n k
-toType (HsTyVar n, k) = TVar $ tyvar n k Nothing
+toType (HsTyCon n, k) = TCon $ Tycon (toName TypeConstructor n) k
+toType (HsTyVar n, k) = TVar $ tyvar (toName TypeVal n) k Nothing
hunk ./FrontEnd/Class.hs 489
-        | n == classEnum = [cia  (nameName v_toEnum), cia $ nameName (v_fromEnum)]
-        | n == classBounded = [cia  (nameName v_minBound), cia $ nameName v_maxBound]
+        | n == class_Enum = [cia $  v_toEnum, cia $ v_fromEnum]
+        | n == class_Bounded = [cia  ( v_minBound), cia $  v_maxBound]
hunk ./FrontEnd/Class.hs 504
-   methodSigs = case Map.lookup className classHierarchy  of
+   methodSigs = case Map.lookup (toName ClassName className) classHierarchy  of
hunk ./FrontEnd/Class.hs 508
-     (makeDerivation kt classHierarchy (hsDeclName decl) (hsDeclArgs decl) (hsDeclCons decl)) (hsDeclDerives decl)
+     (makeDerivation kt classHierarchy (hsDeclName decl) (hsDeclArgs decl) (hsDeclCons decl)) (map (toName ClassName) $ hsDeclDerives decl)
hunk ./FrontEnd/Class.hs 510
-    (makeDerivation kt classHierarchy (hsDeclName decl) (hsDeclArgs decl) [(hsDeclCon decl)]) (hsDeclDerives decl)
+    (makeDerivation kt classHierarchy (hsDeclName decl) (hsDeclArgs decl) [(hsDeclCon decl)]) (map (toName ClassName) $ hsDeclDerives decl)
hunk ./FrontEnd/Class.hs 524
-instanceName n t = Qual (Module "Instance@") $ HsIdent ('i':show n ++ "." ++ show t)
-defaultInstanceName n = Qual (Module "Instance@") $ HsIdent ('i':show n ++ ".default")
+instanceName n t = toName Val $ Qual (Module "Instance@") $ HsIdent ('i':show n ++ "." ++ show t)
+defaultInstanceName n = toName Val $ Qual (Module "Instance@") $ HsIdent ('i':show n ++ ".default")
hunk ./FrontEnd/Class.hs 527
+createInstanceAssump :: KindEnv -> [Assump] -> HsContext -> Class -> HsType -> Name -> Assump
hunk ./FrontEnd/Class.hs 534
-methodToTopDecls :: KindEnv -> [Assump] -> HsQualType -> (HsName, HsDecl) -> (HsDecl,Assump)
+methodToTopDecls :: KindEnv -> [Assump] -> HsQualType -> (Name, HsDecl) -> (HsDecl,Assump)
hunk ./FrontEnd/Class.hs 549
-renameOneDecl :: HsName -> HsDecl -> HsDecl
+renameOneDecl :: Name -> HsDecl -> HsDecl
hunk ./FrontEnd/Class.hs 555
-   = HsPatBind sloc (HsPVar newName) rhs wheres
+   = HsPatBind sloc (HsPVar (nameName newName)) rhs wheres
hunk ./FrontEnd/Class.hs 557
-renameOneMatch :: HsName -> HsMatch -> HsMatch
+renameOneMatch :: Name -> HsMatch -> HsMatch
hunk ./FrontEnd/Class.hs 559
-   = HsMatch sloc newName pats rhs wheres
+   = HsMatch sloc (nameName newName) pats rhs wheres
hunk ./FrontEnd/Class.hs 563
-newMethodSig' :: KindEnv -> HsName -> HsContext -> Scheme -> HsType -> Scheme
+newMethodSig' :: KindEnv -> Name -> HsContext -> Scheme -> HsType -> Scheme
hunk ./FrontEnd/Class.hs 579
-   at (Tyvar _ n k r) =  tyvar (hsNameIdent_u (hsIdentString_u (++ foo)) n) k r
-   qt = (map (aHsAsstToPred kt) newCntxt ++ restContext) :=> (everywhere (mkT ct) t)
+   at (Tyvar _ n k r) =  tyvar (updateName (++ foo) n) k r
+   updateName f n = toName nt (md,f nm) where
+        (nt,(md::String,nm)) = fromName n
+   qt = (map (hsAsstToPred kt) newCntxt ++ restContext) :=> (everywhere (mkT ct) t)
hunk ./FrontEnd/Class.hs 729
-defaults     = map (\name -> TCon (Tycon (nameName name) Star))
+defaults     = map (\name -> TCon (Tycon name Star))
hunk ./FrontEnd/Class.hs 745
-                newClassContext = [(className, argName)]
-            tell [ClassRecord { className = className, classSrcLoc = sl, classSupers = map fst cntxt, classInsts = [], classDerives = [], classAssumps = qualifiedMethodAssumps }]
+                newClassContext = hsContextToContext [(className, argName)]
+            tell [ClassRecord { className = toName ClassName className, classSrcLoc = sl, classSupers = map fst $ hsContextToContext cntxt, classInsts = [], classDerives = [], classAssumps = qualifiedMethodAssumps }]
hunk ./FrontEnd/Class.hs 805
-nameOfTyCon :: HsType -> HsName
-nameOfTyCon (HsTyCon n) = n
-nameOfTyCon (HsTyTuple xs) = toTuple (length xs)
-nameOfTyCon (HsTyFun _ _) = nameName tc_Arrow
-nameOfTyCon t = error $ "nameOfTyCon: " ++ show t
+nameOfTyCon :: NameType -> HsType -> Name
+nameOfTyCon t (HsTyCon n) = toName t n
+nameOfTyCon t (HsTyTuple xs) = nameTuple t (length xs)
+nameOfTyCon t (HsTyFun _ _) = tc_Arrow
+nameOfTyCon _ t = error $ "nameOfTyCon: " ++ show t
hunk ./FrontEnd/Class.hs 811
-groupEquations :: [HsDecl] -> [(HsName, HsDecl)]
+groupEquations :: [HsDecl] -> [(Name, HsDecl)]
hunk ./FrontEnd/Class.hs 816
+
+derivableClasses,numClasses,stdClasses ::  [Name]
+
+stdClasses = [
+    class_Eq,
+    class_Ord,
+    class_Enum,
+    class_Bounded,
+    class_Show,
+    class_Read,
+    class_Ix,
+    class_Functor,
+    class_Monad,
+    class_Num ,
+    class_Real,
+    class_Integral,
+    class_Fractional,
+    class_Floating,
+    class_RealFrac,
+    class_RealFloat
+    ]
+
+numClasses = [
+    class_Num ,
+    class_Real,
+    class_Integral,
+    class_Fractional,
+    class_Floating,
+    class_RealFrac,
+    class_RealFloat
+    ]
+
+
+derivableClasses = [
+    class_Eq,
+    class_Ord,
+    class_Enum,
+    class_Bounded,
+    class_Show,
+    class_Read
+    ]
hunk ./FrontEnd/DataConsAssump.hs 35
+import Name.Name
hunk ./FrontEnd/DataConsAssump.hs 41
-dataConsEnv :: Module -> KindEnv -> [HsDecl] -> Map.Map HsName Scheme
+dataConsEnv :: Module -> KindEnv -> [HsDecl] -> Map.Map Name Scheme
hunk ./FrontEnd/DataConsAssump.hs 49
-dataDeclEnv :: Module -> KindEnv -> (HsDecl) -> Map.Map HsName Scheme
+dataDeclEnv :: Module -> KindEnv -> (HsDecl) -> Map.Map Name Scheme
hunk ./FrontEnd/DataConsAssump.hs 53
-   typeKind = kindOf typeName kt
+   typeName' = toName TypeConstructor typeName
+   typeKind = kindOf typeName' kt
hunk ./FrontEnd/DataConsAssump.hs 56
-   tycon = TCon (Tycon typeName typeKind)
+   tycon = TCon (Tycon typeName' typeKind)
hunk ./FrontEnd/DataConsAssump.hs 61
-      = TVar (tyvar n k Nothing)
+      = TVar (tyvar (toName TypeVal n) k Nothing)
hunk ./FrontEnd/DataConsAssump.hs 67
-   typeKind = kindOf typeName kt
+   typeName' = toName TypeConstructor typeName
+   typeKind = kindOf typeName' kt
hunk ./FrontEnd/DataConsAssump.hs 70
-   tycon = TCon (Tycon typeName typeKind)
+   tycon = TCon (Tycon typeName' typeKind)
hunk ./FrontEnd/DataConsAssump.hs 75
-      = TVar (tyvar n k Nothing)
+      = TVar (tyvar (toName TypeVal n) k Nothing)
hunk ./FrontEnd/DataConsAssump.hs 86
-conDeclType :: Module -> KindEnv -> [Pred] -> Type -> HsConDecl -> Map.Map HsName Scheme
+conDeclType :: Module -> KindEnv -> [Pred] -> Type -> HsConDecl -> Map.Map Name Scheme
hunk ./FrontEnd/DataConsAssump.hs 88
-   = Map.singleton conName $ quantify (tv qualConType) qualConType
+   = Map.singleton (toName DataConstructor conName) $ quantify (tv qualConType) qualConType
hunk ./FrontEnd/DataConsAssump.hs 93
-   = Map.singleton conName $ quantify (tv qualConType) qualConType
+   = Map.singleton (toName DataConstructor conName) $ quantify (tv qualConType) qualConType
hunk ./FrontEnd/DeclsDepends.hs 20
-import DependAnalysis           (debugBindGroups)
-import FrontEnd.Utils                    (getDeclName)
-import FrontEnd.Rename          (unRename)
+import DependAnalysis(debugBindGroups)
+import FrontEnd.Utils(getDeclName)
+import FrontEnd.Rename(unRename)
+import Name.Name
hunk ./FrontEnd/DeclsDepends.hs 31
-   = debugBindGroups groups (show . unRename . getDeclName)
-                            getDeclName
+   = debugBindGroups groups (show . unRename . nameName . getDeclName)
+                            (nameName . getDeclName)
hunk ./FrontEnd/DeclsDepends.hs 40
-getDeclDeps (HsPatBind _pat _ rhs wheres)
-   = getRhsDeps rhs ++ foldr (++) [] (map getLocalDeclDeps wheres)
-
-getDeclDeps (HsFunBind matches)
-   = foldr (++) [] (map getMatchDeps matches)
-
+getDeclDeps (HsPatBind _pat _ rhs wheres) = getRhsDeps rhs ++ foldr (++) [] (map getLocalDeclDeps wheres)
+getDeclDeps (HsFunBind matches) = foldr (++) [] (map getMatchDeps matches)
hunk ./FrontEnd/DeclsDepends.hs 46
-getMatchDeps (HsMatch _sloc _name _pats rhs wheres)
-   = getRhsDeps rhs ++ foldr (++) [] (map getLocalDeclDeps wheres)
+getMatchDeps (HsMatch _sloc _name _pats rhs wheres) = getRhsDeps rhs ++ foldr (++) [] (map getLocalDeclDeps wheres)
hunk ./FrontEnd/DeclsDepends.hs 51
-getLocalDeclDeps (HsFunBind matches)
-   = foldr (++) [] (map getMatchDeps matches)
+getLocalDeclDeps (HsFunBind matches) = foldr (++) [] (map getMatchDeps matches)
hunk ./FrontEnd/DeclsDepends.hs 53
-getLocalDeclDeps (HsPatBind _sloc _hspat rhs wheres)
-   = getRhsDeps rhs ++ foldr (++) [] (map getLocalDeclDeps wheres)
+getLocalDeclDeps (HsPatBind _sloc _hspat rhs wheres) = getRhsDeps rhs ++ foldr (++) [] (map getLocalDeclDeps wheres)
hunk ./FrontEnd/DeclsDepends.hs 60
-getRhsDeps (HsUnGuardedRhs e)
-   = getExpDeps e
-getRhsDeps (HsGuardedRhss rhss)
-   = foldr (++) [] (map getGuardedRhsDeps rhss)
+getRhsDeps (HsUnGuardedRhs e) = getExpDeps e
+getRhsDeps (HsGuardedRhss rhss) = foldr (++) [] (map getGuardedRhsDeps rhss)
hunk ./FrontEnd/HsErrors.hs 7
-import Class()
+import Class
hunk ./FrontEnd/HsErrors.hs 10
+import Name.Name
+import Name.Names
hunk ./FrontEnd/HsErrors.hs 29
-hsDecl HsDataDecl { hsDeclSrcLoc = sl, hsDeclCons = cs, hsDeclDerives = ds } = do
+hsDecl HsDataDecl { hsDeclSrcLoc = sl, hsDeclCons = cs, hsDeclDerives = ds' } = do
+    let ds = map (toName ClassName) ds'
hunk ./FrontEnd/HsErrors.hs 34
-    when (not isEnum && classEnum `elem` ds) $ warn sl "derive-enum" "Cannot derive enum from non enumeration type"
-    when (not isEnum && length cs /= 1 && classBounded `elem` ds) $ warn sl "derive-bounded" "Cannot derive bounded from non enumeration or unary type"
+    when (not isEnum && class_Enum `elem` ds) $ warn sl "derive-enum" "Cannot derive enum from non enumeration type"
+    when (not isEnum && length cs /= 1 && class_Bounded `elem` ds) $ warn sl "derive-bounded" "Cannot derive bounded from non enumeration or unary type"
hunk ./FrontEnd/HsErrors.hs 37
-hsDecl HsNewTypeDecl { hsDeclSrcLoc = sl, hsDeclDerives = ds } = do
+hsDecl HsNewTypeDecl { hsDeclSrcLoc = sl, hsDeclDerives = ds' } = do
+    let ds = map (toName ClassName) ds'
hunk ./FrontEnd/KindInfer.hs 40
+import GenUtil
hunk ./FrontEnd/KindInfer.hs 135
-restrictKindEnv :: (HsName -> Bool) -> KindEnv -> KindEnv
-restrictKindEnv f (KindEnv m) = KindEnv $ Map.filterWithKey (\k _ -> f (nameName k)) m
+restrictKindEnv :: (Name -> Bool) -> KindEnv -> KindEnv
+restrictKindEnv f (KindEnv m) = KindEnv $ Map.filterWithKey (\k _ -> f k) m
hunk ./FrontEnd/KindInfer.hs 383
-getDataAndClassBg decls
-   = getBindGroups decls getDeclName dataAndClassDeps
+getDataAndClassBg decls = getBindGroups decls getDeclName dataAndClassDeps
hunk ./FrontEnd/KindInfer.hs 385
-dataAndClassDeps :: HsDecl -> [HsName]
+dataAndClassDeps :: HsDecl -> [Name]
hunk ./FrontEnd/KindInfer.hs 387
-   = nub $ namesFromContext cntxt ++ (concatMap namesFromType $ concatMap conDeclToTypes condecls)
+   = snub $ namesFromContext cntxt ++ (concatMap namesFromType $ concatMap conDeclToTypes condecls)
hunk ./FrontEnd/KindInfer.hs 389
-   = nub $ namesFromContext cntxt ++ (concatMap namesFromType $ conDeclToTypes condecl)
+   = snub $ namesFromContext cntxt ++ (concatMap namesFromType $ conDeclToTypes condecl)
hunk ./FrontEnd/KindInfer.hs 391
-   = nub $ namesFromContext cntxt ++ (concat [ namesFromQualType (typeFromSig s) | s <- decls,  isHsTypeSig s])
+   = snub $ namesFromContext cntxt ++ (concat [ namesFromQualType (typeFromSig s) | s <- decls,  isHsTypeSig s])
hunk ./FrontEnd/KindInfer.hs 393
-   = nub $ concat [ namesFromQualType (typeFromSig s) | s <- decls,  isHsTypeSig s]
+   = snub $ concat [ namesFromQualType (typeFromSig s) | s <- decls,  isHsTypeSig s]
hunk ./FrontEnd/KindInfer.hs 395
-namesFromQualType :: HsQualType -> [HsName]
-namesFromQualType (HsQualType cntxt t)
-   = namesFromContext cntxt ++ namesFromType t
-namesFromQualType (HsUnQualType t)
-   = namesFromType t
+namesFromQualType :: HsQualType -> [Name]
+namesFromQualType (HsQualType cntxt t) = namesFromContext cntxt ++ namesFromType t
+namesFromQualType (HsUnQualType t) = namesFromType t
hunk ./FrontEnd/KindInfer.hs 399
-namesFromType :: HsType -> [HsName]
+namesFromType :: HsType -> [Name]
hunk ./FrontEnd/KindInfer.hs 404
-namesFromType (HsTyCon n) = [n]
-namesFromType HsTyForall { hsTypeVars = vs } = map hsTyVarBindName vs
+namesFromType (HsTyCon n) = [toName TypeConstructor n]
+namesFromType HsTyForall { hsTypeVars = vs } = map (toName TypeVal . hsTyVarBindName) vs
hunk ./FrontEnd/KindInfer.hs 407
-namesFromContext :: HsContext -> [HsName]
-namesFromContext cntxt = map fst cntxt
+namesFromContext :: HsContext -> [Name]
+namesFromContext cntxt = map fst (hsContextToContext cntxt)
hunk ./FrontEnd/KindInfer.hs 479
-kindOf :: HsName -> KindEnv -> Kind
-kindOf name (KindEnv env)
-   = case Map.lookup (toName TypeConstructor name) env of
-        Nothing -> case Map.lookup (toName TypeVal name) env of
-            Nothing -> Star
+kindOf :: Name -> KindEnv -> Kind
+kindOf name (KindEnv env) = case Map.lookup name env of
+            Nothing | nameType name `elem` [TypeConstructor,TypeVal] -> Star
hunk ./FrontEnd/KindInfer.hs 483
-        --Nothing -> error $ "kindOf: could not find kind of : " ++ show name
-        Just k -> k
+            _ -> error $ "kindOf: could not find kind of : " ++ show (nameType name,name)
hunk ./FrontEnd/KindInfer.hs 485
-kindOfClass :: HsName -> KindEnv -> [Kind]
-kindOfClass name (KindEnv env)
-   = case Map.lookup (toName ClassName name) env of
+kindOfClass :: Name -> KindEnv -> [Kind]
+kindOfClass name (KindEnv env) = case Map.lookup name env of
hunk ./FrontEnd/KindInfer.hs 488
-        Nothing -> error $ "kindOf: could not find kind of class : " ++ show name
+        Nothing -> error $ "kindOf: could not find kind of class : " ++ show (nameType name,name)
hunk ./FrontEnd/KindInfer.hs 515
-aHsTypeToType kt (HsTyCon name) = TCon $ Tycon name (kindOf name kt)
+aHsTypeToType kt (HsTyCon name) = TCon $ Tycon nn (kindOf nn kt)  where
+    nn =  (toName TypeConstructor name)
hunk ./FrontEnd/KindInfer.hs 523
-toTyvar kt name =  tyvar  name (kindOf name kt) Nothing
+toTyvar kt name =  tyvar  nn (kindOf nn kt) Nothing where
+    nn = toName TypeVal name
hunk ./FrontEnd/KindInfer.hs 557
-   = IsIn className (TVar $ tyvar varName (head $ kindOfClass className kt) Nothing)
+   = IsIn (toName ClassName className) (TVar $ tyvar (toName TypeVal varName) (head $ kindOfClass (toName ClassName className) kt) Nothing)
hunk ./FrontEnd/Rename.hs 1183
-    f cd@(HsClassDecl sl _ ds) = tellF $ (toName ClassName z,sl,snub $ fsts cs):[ (n,a,[]) | (n,a) <- cs]  where
-        Just z = maybeGetDeclName cd
+    f cd@(HsClassDecl sl _ ds) = tellF $ (toName Name.ClassName (nameName z),sl,snub $ fsts cs):[ (n,a,[]) | (n,a) <- cs]  where
+        z = case maybeGetDeclName cd of
+            Just x | nameType x == ClassName -> x
+            --       | otherwise ->  parseName ClassName (show x ++ show (nameType x)) 
hunk ./FrontEnd/Rename.hs 1237
-namesHsDecl cd@(HsClassDecl sl _ ds) = (mconcatMap namesHsDeclTS ds) `mappend` ([],[(z,sl)]) where
-    Just z = maybeGetDeclName cd
+namesHsDecl cd@(HsClassDecl sl _ ds) = (mconcatMap namesHsDeclTS ds) `mappend` ([],[(nameName z,sl)]) where
+    z = case maybeGetDeclName cd of
+        Just x | nameType x == ClassName -> x
+        --       | otherwise ->  parseName ClassName (show x ++ show (nameType x)) 
hunk ./FrontEnd/Representation.hs 72
-    tBool = TCon (Tycon (nameName tc_Bool) Star)
+    tBool = TCon (Tycon tc_Bool Star)
hunk ./FrontEnd/Representation.hs 74
-    tChar      = TCon (Tycon (nameName tc_Char) Star)
-    tUnit = TCon (Tycon (nameName tc_Unit) Star)
+    tChar      = TCon (Tycon tc_Char Star)
+    tUnit = TCon (Tycon tc_Unit Star)
hunk ./FrontEnd/Representation.hs 77
-tList = TCon (Tycon (nameName tc_List) (Kfun Star Star))
+tList = TCon (Tycon tc_List (Kfun Star Star))
hunk ./FrontEnd/Representation.hs 90
-data Tyvar = Tyvar { tyvarAtom :: {-# UNPACK #-} !Atom, tyvarName ::  !HsName, tyvarKind :: Kind, tyvarRef :: Maybe (IORef (Maybe Type)) }
+data Tyvar = Tyvar { tyvarAtom :: {-# UNPACK #-} !Atom, tyvarName ::  !Name, tyvarKind :: Kind, tyvarRef :: Maybe (IORef (Maybe Type)) }
hunk ./FrontEnd/Representation.hs 185
-data Tycon = Tycon HsName Kind
+data Tycon = Tycon Name Kind
hunk ./FrontEnd/Representation.hs 190
-    toTuple n = Tycon (toTuple n) (foldr Kfun Star $ replicate n Star)
+    toTuple n = Tycon (nameTuple TypeConstructor n) (foldr Kfun Star $ replicate n Star)
hunk ./FrontEnd/Representation.hs 344
-type Class = HsName
+type Class = Name
hunk ./FrontEnd/Representation.hs 369
-getTypeCons (TArrow {}) = nameName tc_Arrow
+getTypeCons (TArrow {}) = tc_Arrow
hunk ./FrontEnd/Representation.hs 392
-data Assump =  (:>:) HsName Scheme
+data Assump =  (:>:) Name Scheme
hunk ./FrontEnd/TIMain.hs 23
-import List                     ((\\), intersect, union)
-import FrontEnd.Desugar         (doToExp)
+import Control.Monad.Error
+import List((\\), intersect, union)
+import qualified Data.Map as Map
+import qualified Text.PrettyPrint.HughesPJ as PPrint
+
+import Class(ClassHierarchy, entails, split, topDefaults, splitReduce)
+import DeclsDepends(getDeclDeps)
+import DependAnalysis(getBindGroups)
+import Diagnostic
+import Doc.PPrint as PPrint
+import FrontEnd.Desugar(doToExp)
+import FrontEnd.KindInfer(KindEnv)
+import FrontEnd.Utils(getDeclName)
hunk ./FrontEnd/TIMain.hs 38
+import Name.Name
+import Name.Names
+import Name.VConsts
hunk ./FrontEnd/TIMain.hs 42
+import TIMonad
hunk ./FrontEnd/TIMain.hs 44
-import Diagnostic
-import Class                    (ClassHierarchy,
-                                 entails,
-                                 split,
-                                 topDefaults,
-                                 splitReduce)
-
-import TIMonad
-
-
-import FrontEnd.Utils                    (getDeclName)
-
-
-import DependAnalysis           (getBindGroups)
-import TypeSigs                 (SigEnv)
-import Name.VConsts
-
-import DeclsDepends             (getDeclDeps)
-import Control.Monad.Error
-import FrontEnd.KindInfer(KindEnv)
-import qualified Data.Map as Map
-import Doc.PPrint as PPrint
-import qualified Text.PrettyPrint.HughesPJ as PPrint
+import TypeSigs(SigEnv)
hunk ./FrontEnd/TIMain.hs 64
-type TypeEnv = Map.Map HsName Scheme
+type TypeEnv = Map.Map Name Scheme
hunk ./FrontEnd/TIMain.hs 66
-instance Types a => Types (HsName, a) where
+instance Types a => Types (Name, a) where
hunk ./FrontEnd/TIMain.hs 77
-tiExpr env (HsVar v) | Just sc <- Map.lookup v env = do
+tiExpr env (HsVar v) | Just sc <- Map.lookup (toName Val v) env = do
hunk ./FrontEnd/TIMain.hs 96
-      sc <- dConScheme conName
+      sc <- dConScheme (toName DataConstructor conName)
hunk ./FrontEnd/TIMain.hs 109
-    let newEnv = Map.insert n (toScheme t) nenv
+    let newEnv = Map.insert (toName Val n) (toScheme t) nenv
hunk ./FrontEnd/TIMain.hs 143
-        return (IsIn classNum te : ps, env1, te)
+        return (IsIn class_Num te : ps, env1, te)
hunk ./FrontEnd/TIMain.hs 273
-        return (IsIn classEnum eT : ePs, envE, TAp tList eT)
+        return (IsIn class_Enum eT : ePs, envE, TAp tList eT)
hunk ./FrontEnd/TIMain.hs 280
-        return (IsIn classEnum e1T : IsIn classEnum e2T : (e1Ps ++ e2Ps),
+        return (IsIn class_Enum e1T : IsIn class_Enum e2T : (e1Ps ++ e2Ps),
hunk ./FrontEnd/TIMain.hs 289
-        return (IsIn classEnum e1T : IsIn classEnum e2T : (e1Ps ++ e2Ps),
+        return (IsIn class_Enum e1T : IsIn class_Enum e2T : (e1Ps ++ e2Ps),
hunk ./FrontEnd/TIMain.hs 299
-        return (IsIn classEnum e1T : IsIn classEnum e2T : IsIn classEnum e3T : (e1Ps ++ e2Ps ++ e3Ps),
+        return (IsIn class_Enum e1T : IsIn class_Enum e2T : IsIn class_Enum e3T : (e1Ps ++ e2Ps ++ e3Ps),
hunk ./FrontEnd/TIMain.hs 420
-    let Just qt =  Map.lookup n sigEnv
+    let Just qt =  Map.lookup (toName Val n) sigEnv
hunk ./FrontEnd/TIMain.hs 462
-   = withContext (locMsg sloc "in" $ render $ ppHsName funName) $
+   = withContext (locMsg sloc "in" $ show funName) $
hunk ./FrontEnd/TIMain.hs 608
-getImplsNames :: [Impl] -> [HsName]
-getImplsNames impls
-   = map getDeclName impls
+getImplsNames :: [Impl] -> [Name]
+getImplsNames impls = map getDeclName impls
hunk ./FrontEnd/TIMain.hs 651
-   equationGroups = getBindGroups bindDecls getDeclName getDeclDeps
+   equationGroups = getBindGroups bindDecls (nameName . getDeclName) getDeclDeps
hunk ./FrontEnd/TIMain.hs 708
-        return ([IsIn classNum v], v)
+        return ([IsIn class_Num v], v)
hunk ./FrontEnd/TIMain.hs 713
-        return ([IsIn classFractional v], v)
+        return ([IsIn class_Fractional v], v)
hunk ./FrontEnd/TIMain.hs 721
-tiPat :: HsPat -> TI ([Pred], Map.Map HsName Scheme, Type)
+tiPat :: HsPat -> TI ([Pred], Map.Map Name Scheme, Type)
hunk ./FrontEnd/TIMain.hs 727
-        return ([], Map.singleton i (toScheme v), v)
+        return ([], Map.singleton (toName Val i) (toScheme v), v)
hunk ./FrontEnd/TIMain.hs 747
-        sc <- dConScheme conName
+        sc <- dConScheme (toName DataConstructor conName)
hunk ./FrontEnd/TIMain.hs 756
-        sc <- dConScheme conName
+        sc <- dConScheme (toName DataConstructor conName)
hunk ./FrontEnd/TIMain.hs 785
-      let newEnv = Map.insert  i (toScheme t) env
+      let newEnv = Map.insert  (toName Val i) (toScheme t) env
hunk ./FrontEnd/TIMain.hs 794
-tiPats :: [HsPat] -> TI ([Pred], Map.Map HsName Scheme, [Type])
+tiPats :: [HsPat] -> TI ([Pred], Map.Map Name Scheme, [Type])
hunk ./FrontEnd/TIModule.hs 7
+import Maybe
hunk ./FrontEnd/TIModule.hs 44
-getDeclNames ::  HsDecl -> [HsName]
-getDeclNames (HsTypeSig _ ns _ ) =  ns
+getDeclNames ::  HsDecl -> [Name]
+getDeclNames (HsTypeSig _ ns _ ) =  map (toName Val) ns
hunk ./FrontEnd/TIModule.hs 50
-    tiDataLiftedInstances :: Map.Map HsName HsDecl,
+    tiDataLiftedInstances :: Map.Map Name HsDecl,
hunk ./FrontEnd/TIModule.hs 56
-isGlobal (Qual _ x) | (h:_) <- hsIdentString x =  not $ isDigit h
+isGlobal x |  (_,(_::String,(h:_))) <- fromName x =  not $ isDigit h
hunk ./FrontEnd/TIModule.hs 67
-pprintEnv :: PPrint Doc a => Map.Map HsName a -> Doc
+pprintEnv :: PPrint Doc a => Map.Map Name a -> Doc
hunk ./FrontEnd/TIModule.hs 71
-    (local_sys,local_norm) = partition (\(x,_) -> last (hsIdentString (hsNameIdent x)) == '@' ) local
+    (local_sys,local_norm) = partition (\(x,_) -> last (show x) == '@' ) local
hunk ./FrontEnd/TIModule.hs 124
-    let importVarEnv = Map.fromList [ (n,y) | (x,y) <- Map.toList $ hoAssumps me, let (t,n) = fromName x, t == Name.Val ]
-        importDConsEnv = Map.fromList [ (n,y) | (x,y) <- Map.toList $ hoAssumps me, let (t,n) = fromName x, t == Name.DataConstructor ]
+    let importVarEnv = Map.fromList [ (x,y) | (x,y) <- Map.toList $ hoAssumps me, nameType x == Name.Val ]
+        importDConsEnv = Map.fromList [ (x,y) | (x,y) <- Map.toList $ hoAssumps me, nameType x ==  Name.DataConstructor ]
hunk ./FrontEnd/TIModule.hs 165
-             putStrLn $ PPrint.render $ pprintEnv localDConsEnv}
+             putStrLn $ PPrint.render $ pprint localDConsEnv}
hunk ./FrontEnd/TIModule.hs 223
-        fakeForeignDecls = [ [HsForeignDecl bogusASrcLoc ForeignPrimitive "" x (HsUnQualType $ HsTyTuple []) ] | (x,_) <- Map.toList noDefaultSigs]
+        fakeForeignDecls = [ [HsForeignDecl bogusASrcLoc ForeignPrimitive "" (nameName x) (HsUnQualType $ HsTyTuple []) ] | (x,_) <- Map.toList noDefaultSigs]
hunk ./FrontEnd/TIModule.hs 225
-    let programBgs
-           = getBindGroups bindings getDeclName getDeclDeps
+    let programBgs = getBindGroups bindings (nameName . getDeclName) getDeclDeps
hunk ./FrontEnd/TIModule.hs 258
-    let externalEnv = Map.filterWithKey (\ x@(Qual m _) _ -> isGlobal x && (m `elem` map modInfoName ms)) localVarEnv `Map.union` noDefaultSigs
+    let externalEnv = Map.filterWithKey (\ x _ -> isGlobal x && (fromJust (getModule x) `elem` map modInfoName ms)) localVarEnv `Map.union` noDefaultSigs
hunk ./FrontEnd/TIModule.hs 261
-    let externalKindEnv = restrictKindEnv (\ x@(Qual m _)  -> isGlobal x && (m `elem` map modInfoName ms)) kindInfo
+    let externalKindEnv = restrictKindEnv (\ x  -> isGlobal x && (fromJust (getModule x) `elem` map modInfoName ms)) kindInfo
hunk ./FrontEnd/TIModule.hs 265
-    let allAssumps = Map.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Map.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Map.toList localVarEnv ]
+    let allAssumps = localDConsEnv `Map.union` localVarEnv -- Map.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Map.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Map.toList localVarEnv ]
hunk ./FrontEnd/TIModule.hs 267
-        expAssumps = Map.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Map.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Map.toList $ externalEnv ]
+        --expAssumps = Map.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Map.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Map.toList $ externalEnv ]
+        expAssumps = localDConsEnv `Map.union` externalEnv -- Map.fromList $ [ (toName Name.DataConstructor x,y) | (x,y) <- Map.toList localDConsEnv ] ++ [ (toName Name.Val x,y) | (x,y) <- Map.toList $ externalEnv ]
hunk ./FrontEnd/TIMonad.hs 56
+import Name.Name
hunk ./FrontEnd/TIMonad.hs 69
-      tcDConsEnv          :: Map.Map HsName Scheme,
+      tcDConsEnv          :: Map.Map Name Scheme,
hunk ./FrontEnd/TIMonad.hs 99
-runTI :: Map.Map HsName Scheme-> ClassHierarchy -> KindEnv -> SigEnv -> Module -> TI a -> IO a
+runTI :: Map.Map Name Scheme-> ClassHierarchy -> KindEnv -> SigEnv -> Module -> TI a -> IO a
hunk ./FrontEnd/TIMonad.hs 130
-getDConsTypeEnv :: TI (Map.Map HsName Scheme)
+getDConsTypeEnv :: TI (Map.Map Name Scheme)
hunk ./FrontEnd/TIMonad.hs 147
-dConScheme :: HsName -> TI Scheme
+dConScheme :: Name -> TI Scheme
hunk ./FrontEnd/TIMonad.hs 188
-    let ident = Qual (tcModuleName te) $ HsIdent $ "v" ++ show n
+    --let ident = Qual (tcModuleName te) $ HsIdent $ "v" ++ show n
+    let ident = toName TypeVal (show $ tcModuleName te,'v':show n)
hunk ./FrontEnd/Type.hs 55
-import HsSyn   (HsName (..))
+import Name.Name
hunk ./FrontEnd/Type.hs 282
-assumpToPair :: Assump -> (HsName, Scheme)
+assumpToPair :: Assump -> (Name, Scheme)
hunk ./FrontEnd/Type.hs 285
-pairToAssump :: (HsName, Scheme) -> Assump
+pairToAssump :: (Name, Scheme) -> Assump
hunk ./FrontEnd/Type.hs 293
-assumpId :: Assump -> HsName
+assumpId :: Assump -> Name
hunk ./FrontEnd/Type.hs 299
-makeAssump :: HsName -> Scheme -> Assump
+makeAssump :: Name -> Scheme -> Assump
hunk ./FrontEnd/TypeSigs.hs 20
-import Type             (assumpToPair)
-
-import FrontEnd.KindInfer        (KindEnv)
-
-import Representation   (Scheme)
-
-import TypeUtils        (aHsTypeSigToAssumps)
+import Type(assumpToPair)
+import FrontEnd.KindInfer(KindEnv)
+import Representation(Scheme)
+import TypeUtils(aHsTypeSigToAssumps)
+import Name.Name
hunk ./FrontEnd/TypeSigs.hs 197
-type SigEnv = Map.Map HsName Scheme
+type SigEnv = Map.Map Name Scheme
hunk ./FrontEnd/TypeUtils.hs 18
-module TypeUtils (aHsTypeSigToAssumps,
-                  aHsAsstToPred,
-                  flattenLeftTypeApplication) where
+module TypeUtils (aHsTypeSigToAssumps,flattenLeftTypeApplication) where
hunk ./FrontEnd/TypeUtils.hs 32
+import Name.Name
hunk ./FrontEnd/TypeUtils.hs 49
-aHsAsstToPred :: KindEnv -> HsAsst -> Pred
-aHsAsstToPred kt (className, varName)
+--aHsAsstToPred :: KindEnv -> HsAsst -> Pred
+--aHsAsstToPred kt (className, varName)
hunk ./FrontEnd/TypeUtils.hs 52
-   = IsIn className (TVar $ tyvar varName (kindOf className kt) Nothing)
+--   = IsIn className (TVar $ tyvar varName (kindOf className kt) Nothing)
hunk ./FrontEnd/TypeUtils.hs 58
-aHsTypeSigToAssumps kt sig@(HsTypeSig _ names qualType) = [n :>: scheme | n <- names] where
+aHsTypeSigToAssumps kt sig@(HsTypeSig _ names qualType) = [ toName Val n :>: scheme | n <- names] where
hunk ./FrontEnd/TypeUtils.hs 81
-qualifyAssump :: Module -> Assump -> Assump
-qualifyAssump mod assump
-   | isQual ident = assump  -- do nothing
-   | otherwise = makeAssump newQualIdent scheme
-   where
-   scheme :: Scheme
-   scheme = assumpScheme assump
-   ident :: HsName
-   ident = assumpId assump
-   newQualIdent :: HsName
-   newQualIdent = Qual mod $ HsIdent $ show ident
+--qualifyAssump :: Module -> Assump -> Assump
+--qualifyAssump mod assump
+--   | isQual ident = assump  -- do nothing
+--   | otherwise = makeAssump newQualIdent scheme
+--   where
+--   scheme :: Scheme
+--   scheme = assumpScheme assump
+--   ident :: Name
+--   ident = assumpId assump
+--   newQualIdent :: Name
+--   newQualIdent = Qual mod $ HsIdent $ show ident
+
hunk ./FrontEnd/Utils.hs 21
-maybeGetDeclName :: Monad m => HsDecl -> m HsName
-maybeGetDeclName (HsPatBind sloc (HsPVar name) rhs wheres) = return name
-maybeGetDeclName (HsFunBind ((HsMatch _ name _ _ _):_)) = return name
-maybeGetDeclName (HsDataDecl _ _ name  _ _ _) = return name
-maybeGetDeclName (HsNewTypeDecl _ _ name  _ _ _) = return name
+maybeGetDeclName :: Monad m => HsDecl -> m Name
+maybeGetDeclName (HsPatBind sloc (HsPVar name) rhs wheres) = return (toName Val name)
+maybeGetDeclName (HsFunBind ((HsMatch _ name _ _ _):_)) = return (toName Val name)
+maybeGetDeclName (HsDataDecl _ _ name  _ _ _) = return (toName TypeConstructor name)
+maybeGetDeclName (HsNewTypeDecl _ _ name  _ _ _) = return (toName TypeConstructor name)
hunk ./FrontEnd/Utils.hs 30
-            leftMostTyCon (HsTyTuple ts) = toTuple (length ts)
+            leftMostTyCon (HsTyTuple ts) = error "lehtMostTyCon applied to tuple" -- toTuple (length ts)
hunk ./FrontEnd/Utils.hs 33
-            leftMostTyCon (HsTyCon n) = n
+            leftMostTyCon (HsTyCon n) = (toName ClassName n)
hunk ./FrontEnd/Utils.hs 35
-maybeGetDeclName (HsForeignDecl _ _ _ n _) = return n
+maybeGetDeclName (HsForeignDecl _ _ _ n _) = return (toName Val n)
hunk ./FrontEnd/Utils.hs 61
+type Context = [(Name,Name)]
+hsContextToContext :: HsContext -> [(Name,Name)]
+hsContextToContext xs = [ (toName ClassName c, toName TypeVal t) | (c,t) <- xs]
hunk ./Name/Names.hs 120
+
+class_Eq = toName ClassName ("Prelude","Eq")
+class_Ord = toName ClassName ("Prelude","Ord")
+class_Enum = toName ClassName ("Prelude","Enum")
+class_Bounded = toName ClassName ("Prelude","Bounded")
+class_Show = toName ClassName ("Prelude.Text","Show")
+class_Read = toName ClassName ("Prelude.Text","Read")
+class_Ix = toName ClassName ("Ix","Ix")
+class_Functor = toName ClassName ("Prelude","Functor")
+class_Monad = toName ClassName ("Prelude","Monad")
+class_Num = toName ClassName ("Prelude","Num")
+class_Real = toName ClassName ("Prelude","Real")
+class_Integral = toName ClassName ("Prelude","Integral")
+class_Fractional = toName ClassName ("Prelude","Fractional")
+class_Floating = toName ClassName ("Prelude","Floating")
+class_RealFrac = toName ClassName ("Prelude","RealFrac")
+class_RealFloat = toName ClassName ("Prelude","RealFloat")
+
+
hunk ./Name/VConsts.hs 130
-derivableClasses,numClasses,stdClasses :: ClassNames a => [a]
+_derivableClasses,_numClasses,_stdClasses :: ClassNames a => [a]
hunk ./Name/VConsts.hs 132
-stdClasses = [
+_stdClasses = [
hunk ./Name/VConsts.hs 151
-numClasses = [
+_numClasses = [
hunk ./Name/VConsts.hs 162
-derivableClasses = [
+_derivableClasses = [
hunk ./data/PrimitiveOperators-in.hs 21
-toHsName x = nameName $ parseName TypeConstructor x
+toTypeName x = parseName TypeConstructor x
+toClassName x = parseName ClassName x
hunk ./utils/op_process.prl 103
-    my $v = "$n = toHsName \"$_[0]\"";
+    my $v = "$n = toClassName \"$_[0]\"";
hunk ./utils/op_process.prl 114
-    my $v = "$n = TCon (Tycon (toHsName \"$_[0]\") Star)";
+    my $v = "$n = TCon (Tycon (toTypeName \"$_[0]\") Star)";