th-typegraph (empty) → 0.14

raw patch · 16 files changed

+2297/−0 lines, 16 filesdep +arraydep +basedep +bytestringsetup-changed

Dependencies added: array, base, bytestring, containers, data-default, deepseq, ghc-prim, haskell-src-exts, hspec, hspec-core, lens, mtl, syb, template-haskell, text, th-desugar, th-orphans, th-reify-many, th-typegraph

Files

• Language/Haskell/TH/TypeGraph.hs +21/−0
• Language/Haskell/TH/TypeGraph/Core.hs +146/−0
• Language/Haskell/TH/TypeGraph/Edges.hs +26/−0
• Language/Haskell/TH/TypeGraph/Expand.hs +87/−0
• Language/Haskell/TH/TypeGraph/Graph.hs +88/−0
• Language/Haskell/TH/TypeGraph/Hints.hs +48/−0
• Language/Haskell/TH/TypeGraph/Info.hs +260/−0
• Language/Haskell/TH/TypeGraph/Monad.hs +198/−0
• Language/Haskell/TH/TypeGraph/Unsafe.hs +22/−0
• Language/Haskell/TH/TypeGraph/Vertex.hs +63/−0
• Setup.hs +3/−0
• test/Common.hs +48/−0
• test/Tests.hs +24/−0
• test/TypeGraph.hs +110/−0
• test/Values.hs +1098/−0
• th-typegraph.cabal +55/−0

@@ -0,0 +1,21 @@+module Language.Haskell.TH.TypeGraph+    ( module Language.Haskell.TH.TypeGraph.Core+    , module Language.Haskell.TH.TypeGraph.Edges+    , module Language.Haskell.TH.TypeGraph.Expand+    , module Language.Haskell.TH.TypeGraph.Graph+    , module Language.Haskell.TH.TypeGraph.Hints+    , module Language.Haskell.TH.TypeGraph.Info+    , module Language.Haskell.TH.TypeGraph.Monad+    -- , module Language.Haskell.TH.TypeGraph.Unsafe+    , module Language.Haskell.TH.TypeGraph.Vertex+    ) where++import Language.Haskell.TH.TypeGraph.Core+import Language.Haskell.TH.TypeGraph.Edges+import Language.Haskell.TH.TypeGraph.Expand+import Language.Haskell.TH.TypeGraph.Graph+import Language.Haskell.TH.TypeGraph.Hints+import Language.Haskell.TH.TypeGraph.Info+import Language.Haskell.TH.TypeGraph.Monad+import Language.Haskell.TH.TypeGraph.Unsafe ()+import Language.Haskell.TH.TypeGraph.Vertex

@@ -0,0 +1,146 @@+-- | Helper functions for dealing with record fields, type shape, type+-- arity, primitive types, and pretty printing.+{-# LANGUAGE CPP, DeriveDataTypeable, FlexibleInstances, RankNTypes, ScopedTypeVariables, TemplateHaskell #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+module Language.Haskell.TH.TypeGraph.Core+    ( -- * Declaration shape+      FieldType(FieldType, fPos, fNameAndType)+    , fName+    , fType+    , prettyField+    , constructorFields+    , foldShape+    -- * Constructor deconstructors+    , constructorName+    -- * Queries+    , typeArity+    , unlifted+    -- * Pretty print without extra whitespace+    , pprint'+    ) where++#if __GLASGOW_HASKELL__ < 709+import Control.Applicative ((<$>), (<*>))+#endif+import Data.Data (Data)+import Data.Map as Map (Map, fromList, toList)+import Data.Set as Set (Set, fromList, toList)+import Data.Typeable (Typeable)+import Language.Haskell.Exts.Syntax ()+import Language.Haskell.TH+import Language.Haskell.TH.Desugar ({- instances -})+import Language.Haskell.TH.Syntax+import Language.Haskell.TH.TypeGraph.Expand (E, markExpanded, runExpanded)++data FieldType+    = FieldType+      { fPos :: Int+      , fNameAndType :: Either StrictType VarStrictType }+    deriving (Eq, Ord, Show, Data, Typeable)++fName :: FieldType -> Maybe Name+fName = either (\ (_, _) -> Nothing) (\ (x, _, _) -> Just x) . fNameAndType++prettyField :: FieldType -> String+prettyField fld = maybe (show (fPos fld)) nameBase (fName fld)++-- | fType' with leading foralls stripped+fType :: FieldType -> Type+fType = either (\ (_, x) -> x) (\ (_, _, x) -> x) . fNameAndType++-- | Given the list of constructors from a Dec, dispatch on the+-- different levels of complexity of the type they represent - a+-- wrapper is a single arity one constructor, an enum is+-- several arity zero constructors, and so on.+foldShape :: Monad m =>+             ([(Con, [FieldType])] -> m r) -- dataFn - several constructors not all of which are arity zero+          -> (Con -> [FieldType] -> m r)   -- recordFn - one constructor which has arity greater than one+          -> ([Con] -> m r)                -- enumFn - all constructors are of arity zero+          -> (Con -> FieldType -> m r)     -- wrapperFn - one constructor of arity one+          -> [Con] -> m r+foldShape dataFn recordFn enumFn wrapperFn cons =+    case zip cons (map constructorFields cons) :: [(Con, [FieldType])] of+      [(con, [fld])] ->+          wrapperFn con fld+      [(con, flds)] ->+          recordFn con flds+      pairs | all (== 0) (map (length . snd) pairs) ->+          enumFn (map fst pairs)+      pairs ->+          dataFn pairs++constructorName :: Con -> Name+constructorName (ForallC _ _ con) = constructorName con+constructorName (NormalC name _) = name+constructorName (RecC name _) = name+constructorName (InfixC _ name _) = name++constructorFields :: Con -> [FieldType]+constructorFields (ForallC _ _ con) = constructorFields con+constructorFields (NormalC _ ts) = map (uncurry FieldType) (zip [1..] (map Left ts))+constructorFields (RecC _ ts) = map (uncurry FieldType) (zip [1..] (map Right ts))+constructorFields (InfixC t1 _ t2) = map (uncurry FieldType) [(1, Left t1), (2, Left t2)]++-- | Compute the arity of a type - the number of type parameters that+-- must be applied to it in order to obtain a concrete type.+typeArity :: Quasi m => Type -> m Int+typeArity (ForallT _ _ typ) = typeArity typ+typeArity ListT = return 1+typeArity (VarT _) = return 1+typeArity (TupleT n) = return n+typeArity (AppT t _) = typeArity t >>= \ n -> return $ n - 1+typeArity (ConT name) = qReify name >>= infoArity+    where+      infoArity (TyConI dec) = decArity dec+      infoArity (PrimTyConI _ _ _) = return 0+      infoArity (FamilyI dec _) = decArity dec+      infoArity info = error $ "typeArity - unexpected: " ++ pprint' info+      decArity (DataD _ _ vs _ _) = return $ length vs+      decArity (NewtypeD _ _ vs _ _) = return $ length vs+      decArity (TySynD _ vs t) = typeArity t >>= \ n -> return $ n + length vs+      decArity (FamilyD _ _ vs _mk) = return $ {- not sure what to do with the kind mk here -} length vs+      decArity dec = error $ "decArity - unexpected: " ++ show dec+typeArity typ = error $ "typeArity - unexpected type: " ++ show typ++-- | Pretty print a 'Ppr' value on a single line with each block of+-- white space (newlines, tabs, etc.) converted to a single space.+pprint' :: Ppr a => a -> [Char]+pprint' typ = unwords $ words $ pprint typ++-- | Does the type or the declaration to which it refers contain a+-- primitive (aka unlifted) type?  This will traverse down any 'Dec'+-- to the named types, and then check whether any of their 'Info'+-- records are 'PrimTyConI' values.+class IsUnlifted t where+    unlifted :: Quasi m => t -> m Bool++instance IsUnlifted Dec where+    unlifted (DataD _ _ _ cons _) = or <$> mapM unlifted cons+    unlifted (NewtypeD _ _ _ con _) = unlifted con+    unlifted (TySynD _ _ typ) = unlifted typ+    unlifted _ = return False++instance IsUnlifted Con where+    unlifted (ForallC _ _ con) = unlifted con+    unlifted (NormalC _ ts) = or <$> mapM (unlifted . snd) ts+    unlifted (RecC _ ts) = or <$> mapM (\ (_, _, t) -> unlifted t) ts+    unlifted (InfixC t1 _ t2) = or <$> mapM (unlifted . snd) [t1, t2]++instance IsUnlifted Type where+    unlifted (ForallT _ _ typ) = unlifted typ+    unlifted (ConT name) = qReify name >>= unlifted+    unlifted (AppT t1 t2) = (||) <$> unlifted t1 <*> unlifted t2+    unlifted _ = return False++instance IsUnlifted Info where+    unlifted (PrimTyConI _ _ _) = return True+    unlifted _ = return False -- traversal stops here++instance Lift a => Lift (Set a) where+    lift s = [|Set.fromList $(lift (Set.toList s))|]++instance (Lift a, Lift b) => Lift (Map a b) where+    lift mp = [|Map.fromList $(lift (Map.toList mp))|]++instance Lift (E Type) where+    lift etype = [|markExpanded $(lift (runExpanded etype))|]

@@ -0,0 +1,26 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TypeSynonymInstances #-}+module Language.Haskell.TH.TypeGraph.Edges+    ( TypeGraphEdges+    ) where++import Data.List as List (intercalate, map)+import Data.Map as Map (toList)+import Data.Set as Set (toList)+import Language.Haskell.Exts.Syntax ()+import Language.Haskell.TH -- (Con, Dec, nameBase, Type)+import Language.Haskell.TH.TypeGraph.Graph (GraphEdges)+import Language.Haskell.TH.TypeGraph.Core (pprint')+import Language.Haskell.TH.TypeGraph.Vertex (TypeGraphVertex)+import Language.Haskell.TH.Instances ()+import Language.Haskell.TH.PprLib (ptext)++type TypeGraphEdges = GraphEdges TypeGraphVertex++instance Ppr TypeGraphEdges where+    ppr x =+        ptext $ intercalate "\n  " $+          "edges:" : (List.map+                       (\ (k, ks) -> intercalate "\n    " ((pprint' k ++ "->") : List.map pprint' (Set.toList ks)))+                       (Map.toList x))

@@ -0,0 +1,87 @@+-- | The 'Expanded' class helps keep track of which 'Type' values have+-- been fully expanded to a canonical form.  This lets us use the 'Eq'+-- and 'Ord' relationships on 'Type' and 'Pred' values when reasoning+-- about instance context.  What the 'expandType' function does is use+-- the function from @th-desugar@ to replace occurrences of @ConT name@+-- with the associated 'Type' if @name@ is a declared type synonym+-- @TySynD name _ typ@.  For convenience, a wrapper type 'E' is+-- provided, along with the 'Expanded' instances @E Type@ and @E+-- Pred@.  Now the 'expandType' and 'expandPred' functions can be used+-- to return values of type @E Type@ and @E Pred@ respectively.+--+-- Instances @Expanded Type Type@ and @Expanded Pred Pred@ are+-- provided in "Language.Haskell.TH.Context.Unsafe", for when less+-- type safety is required.++{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE ScopedTypeVariables #-}++module Language.Haskell.TH.TypeGraph.Expand+    ( Expanded(markExpanded, runExpanded)+    , runExpanded'+    , expandType+    , expandPred+    , expandClassP+    , E(E)+    ) where++#if __GLASGOW_HASKELL__ < 709+import Control.Applicative+#endif+import Language.Haskell.Exts.Syntax ()+import Language.Haskell.TH+import Language.Haskell.TH.Desugar as DS (DsMonad, dsType, expand, typeToTH)+import Language.Haskell.TH.Instances ()+import Prelude hiding (pred)++-- | This class lets us use the same expand* functions to work with+-- specially marked expanded types or with the original types.+class Expanded un ex | ex -> un where+    markExpanded :: un -> ex -- ^ Unsafely mark a value as expanded+    runExpanded :: ex -> un -- ^ Strip mark off an expanded value++-- | Apply the th-desugar expand function to a 'Type' and mark it as expanded.+expandType :: (DsMonad m, Expanded Type e)  => Type -> m e+expandType typ = markExpanded <$> DS.typeToTH <$> (DS.dsType typ >>= DS.expand)++-- | Apply the th-desugar expand function to a 'Pred' and mark it as expanded.+-- Note that the definition of 'Pred' changed in template-haskell-2.10.0.0.+expandPred :: (DsMonad m, Expanded Pred e)  => Pred -> m e+#if MIN_VERSION_template_haskell(2,10,0)+expandPred = expandType+#else+expandPred (ClassP className typeParameters) = markExpanded <$> (ClassP className . map runExpanded') <$> mapM expandType typeParameters+expandPred (EqualP type1 type2) = markExpanded <$> (EqualP <$> (runExpanded' <$> expandType type1) <*> (runExpanded' <$> expandType type2))+#endif++-- | Expand a list of 'Type' and build an expanded 'ClassP' 'Pred'.+expandClassP :: forall m e. (DsMonad m, Expanded Pred e)  => Name -> [Type] -> m e+expandClassP className typeParameters =+#if MIN_VERSION_template_haskell(2,10,0)+      (expandType $ foldl AppT (ConT className) typeParameters) :: m e+#else+      (markExpanded . ClassP className . map runExpanded') <$> mapM expandType typeParameters+#endif++runExpanded' :: Expanded a (E a) => E a -> a+runExpanded' = runExpanded++-- | A concrete type for which Expanded instances are declared below.+newtype E a = E a deriving (Eq, Ord, Show)++instance Expanded Type (E Type) where+    markExpanded = E+    runExpanded (E x) = x++#if !MIN_VERSION_template_haskell(2,10,0)+instance Expanded Pred (E Pred) where+    markExpanded = E+    runExpanded (E x) = x+#endif++instance Ppr a => Ppr (E a) where+    ppr (E x) = ppr x

@@ -0,0 +1,88 @@+-- | Abstract operations on Maps containing graph edges.++{-# LANGUAGE CPP #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}++module Language.Haskell.TH.TypeGraph.Graph+    ( GraphEdges+    , cutVertex+    , cutVertices+    , cutVerticesM+    , mergeVertex+    , mergeVertices+    , mergeVerticesM+    , partitionM+    , flatten+    , graphFromMap+    ) where++import Control.Monad (filterM)+import Data.Graph hiding (edges)+import Data.List as List+import Data.Map as Map+import Data.Set as Set++type GraphEdges v = Map v (Set v)++-- | Remove a node and all its in- and out-edges.+cutVertex :: (Eq a, Ord a) => a -> GraphEdges a -> GraphEdges a+cutVertex victim edges = Map.map (Set.filter (/= victim)) $ Map.filterWithKey (\k _ -> k /= victim) edges++-- | Cut vertices for which the predicate returns False+cutVertices :: (Eq a, Ord a) => (a -> Bool) -> GraphEdges a -> GraphEdges a+cutVertices victim edges = List.foldr cutVertex edges (List.filter victim (Map.keys edges))++-- | Cut vertices for which the predicate returns False+cutVerticesM :: (Monad m, Eq a, Ord a) => (a -> m Bool) -> GraphEdges a -> m (GraphEdges a)+cutVerticesM victim edges = do+  victims <- filterM victim (Map.keys edges) >>= return . Set.fromList+  return $ cutVertices (`Set.member` victims) edges++-- | Merge a node into the nodes that are its in-edges.+mergeVertex :: (Eq a, Ord a) => a -> GraphEdges a -> GraphEdges a+mergeVertex victim edges =+  survivorEdges'+    where+      -- Wherever the victim vertex appears as an out-edge, substitute the victimOut set+      survivorEdges' = Map.mapWithKey (\ k s -> if Set.member victim s then Set.union (Set.delete victim s) (Set.delete k victimOut) else s) survivorEdges+      -- Split map into victim vertex and other vertices+      (victimEdges, survivorEdges) = partitionWithKey (\ v _ -> (v == victim)) edges+      -- Get the out-edges of the victim vertex+      victimOut = Set.delete victim $ Set.unions $ Map.elems victimEdges++mergeVertices :: (Eq a, Ord a) => (a -> Bool) -> GraphEdges a -> GraphEdges a+mergeVertices keep edges = List.foldr mergeVertex edges (List.filter (not . keep) (Map.keys edges))++mergeVerticesM :: (Monad m, Ord  a) => (a -> m Bool) -> GraphEdges a -> m (GraphEdges a)+mergeVerticesM predicateM edges =+    mapM predicateM (Map.keys edges) >>= \flags -> return $ mergeVertices (makePredicate (zip (Map.keys edges) flags)) edges+    where+      makePredicate :: Ord a => [(a, Bool)] -> a -> Bool+      makePredicate pairs = flip (Map.findWithDefault False) (Map.fromList pairs)++partitionM :: forall m a. Monad m => (a -> m Bool) -> [a] -> m ([a], [a])+partitionM p l = do+  (flags :: [Bool]) <- mapM p l+  let pairs :: [(a, Bool)]+      pairs = zip l flags+      as :: [(a, Bool)]+      bs :: [(a, Bool)]+      (as, bs) = List.partition snd pairs+  return $ (List.map fst as, List.map fst bs)++flatten :: Ord a => Set (Set a) -> Set a+flatten = Set.fold Set.union Set.empty+++-- | Build a graph from the result of typeGraphEdges, each edge goes+-- from a type to one of the types it contains.  Thus, each edge+-- represents a primitive lens, and each path in the graph is a+-- composition of lenses.+graphFromMap :: forall node key a. (Ord a, node ~ a, key ~ a) =>+                GraphEdges a -> (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex)+graphFromMap mp =+    graphFromEdges triples+    where+      triples :: [(node, key, [key])]+      triples = List.map (\ (k, ks) -> (k, k, Set.toList ks)) $ Map.toList mp

@@ -0,0 +1,48 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TupleSections #-}+{-# OPTIONS_GHC -Wall #-}+module Language.Haskell.TH.TypeGraph.Hints+    ( VertexHint(..)+    ) where++import Data.Default (Default(def))+import Language.Haskell.Exts.Syntax ()+import Language.Haskell.TH -- (Con, Dec, nameBase, Type)+import Language.Haskell.TH.Instances ()+import Language.Haskell.TH.PprLib (hcat, ptext)+import Language.Haskell.TH.Syntax (Lift(lift))++-- | When a VertexHint value is associated with a Type it describes+-- alterations in the type graph from the usual default.+data VertexHint+    = Normal      -- ^ normal case+    | Hidden      -- ^ don't create this vertex, no in or out edges+    | Sink        -- ^ out degree zero - don't create any out edges+    | Divert Type -- ^ replace all out edges with an edge to an alternate type+    | Extra Type  -- ^ add an extra out edge to the given type+    deriving (Eq, Ord, Show)++instance Default VertexHint where+    def = Normal++instance Lift VertexHint where+    lift Normal = [|Normal|]+    lift Hidden = [|Hidden|]+    lift Sink = [|Sink|]+    lift (Divert x) = [|Divert $(lift x)|]+    lift (Extra x) = [|Extra $(lift x)|]++instance Ppr VertexHint where+    ppr Normal = ptext "Normal"+    ppr Hidden = ptext "Hidden"+    ppr Sink = ptext "Sink"+    ppr (Divert x) = hcat [ptext "Divert (", ppr x, ptext ")"]+    ppr (Extra x) = hcat [ptext "Extra (", ppr x, ptext ")"]

@@ -0,0 +1,260 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TupleSections #-}+{-# OPTIONS_GHC -Wall #-}+module Language.Haskell.TH.TypeGraph.Info+    ( TypeGraphInfo+    , emptyTypeGraphInfo+    , typeGraphInfo+    , expanded, fields, hints, infoMap, synonyms, typeSet+    , withTypeGraphInfo+    ) where++#if __GLASGOW_HASKELL__ < 709+import Control.Applicative ((<$>))+import Data.Monoid (mempty)+#endif+import Control.Lens -- (makeLenses, view)+import Control.Monad.Reader (ReaderT, runReaderT)+import Control.Monad.State (execStateT, StateT)+import Data.List as List (intercalate, map)+import Data.Map as Map (elems, fromListWith, insert, insertWith, Map, toList)+import Data.Maybe (mapMaybe)+import Data.Set as Set (insert, member, Set, singleton, toList, union)+import Language.Haskell.Exts.Syntax ()+import Language.Haskell.TH+import Language.Haskell.TH.TypeGraph.Core (pprint')+import Language.Haskell.TH.TypeGraph.Expand (E(E), expandType)+import Language.Haskell.TH.TypeGraph.Hints (VertexHint(..))+import Language.Haskell.TH.TypeGraph.Vertex (TypeGraphVertex)+import Language.Haskell.TH.Desugar as DS (DsMonad)+import Language.Haskell.TH.Instances ()+import Language.Haskell.TH.PprLib (ptext)+import Language.Haskell.TH.Syntax (Lift(lift), Quasi(..))++-- | Information collected about the graph implied by the structure of+-- one or more 'Type' values.+data TypeGraphInfo+    = TypeGraphInfo+      { _typeSet :: Set Type+      -- All the types encountered, including embedded types such as the+      -- 'Maybe' and the 'Int' in @Maybe Int@.+      , _infoMap :: Map Name Info+      -- The Info record of all known named types+      , _expanded :: Map Type (E Type)+      -- The types with all type synonyms replaced with their expansions.+      , _synonyms :: Map (E Type) (Set Name)+      -- Map from field type to field names+      , _fields :: Map (E Type) (Set (Name, Name, Either Int Name))+{-+      -- Map from type name to the field names that type contains+      , _decfields :: Map Name (Set (Name, Name, Either Int Name))+      -- Information about record fields which contain a given type+      , _edges :: GraphEdges TypeGraphVertex+-}+      -- The edges of the "has this subtype" graph.  A type has+      -- subtypes via either type application ('AppT'), field type+      -- ('StrictType', 'VarStrictType') or the 'VertexHint'+      -- mechanism.+      , _hints :: Map TypeGraphVertex [VertexHint]+      } deriving (Show, Eq, Ord)++instance Ppr TypeGraphInfo where+    ppr (TypeGraphInfo {_typeSet = t, _infoMap = i, _expanded = e, _synonyms = s, _fields = f, _hints = h}) =+        ptext $ intercalate "\n  " ["TypeGraphInfo:", ppt, ppi, ppe, pps, ppf, pph] ++ "\n"+        where+          ppt = intercalate "\n    " ("typeSet:" : concatMap (lines . pprint) (Set.toList t))+          ppi = intercalate "\n    " ("infoMap:" : concatMap (lines . (\ (name, info) -> show name ++ " -> " ++ pprint info)) (Map.toList i))+          ppe = intercalate "\n    " ("expanded:" : concatMap (lines . (\ (typ, (E etyp)) -> pprint typ ++ " -> " ++ pprint etyp)) (Map.toList e))+          pps = intercalate "\n    " ("synonyms:" : concatMap (lines . (\ (E etyp, ns) -> pprint etyp ++ " -> " ++ show ns)) (Map.toList s))+          ppf = intercalate "\n    " ("fields:" : concatMap (lines . (\ (E etyp, fs) -> pprint etyp ++ " -> " ++ show fs)) (Map.toList f))+          pph = intercalate "\n    " ("hints:" : concatMap (lines . (\ (v, hs) -> pprint v ++ " -> " ++ intercalate " " (map pprint hs))) (Map.toList h))++$(makeLenses ''TypeGraphInfo)++emptyTypeGraphInfo :: TypeGraphInfo+emptyTypeGraphInfo = TypeGraphInfo {_typeSet = mempty, _infoMap = mempty, _expanded = mempty, _synonyms = mempty, _fields = mempty, _hints = mempty}++withTypeGraphInfo :: forall m a. DsMonad m => [(TypeGraphVertex, VertexHint)] -> [Type] -> ReaderT TypeGraphInfo m a -> m a+withTypeGraphInfo hintList types action = typeGraphInfo hintList types >>= runReaderT action++-- | Build a TypeGraphInfo value by scanning the supplied types and hints.+typeGraphInfo :: forall m. DsMonad m => [(TypeGraphVertex, VertexHint)] -> [Type] -> m TypeGraphInfo+typeGraphInfo hintList types = flip execStateT emptyTypeGraphInfo $ do+  hints .= Map.fromListWith (++) (List.map (\ (n, h) -> (n, [h])) hintList)+  hintTypes <- (mapMaybe hintType . concat . Map.elems) <$> use hints+  mapM_ doType (types ++ hintTypes)+    where+      hintType :: VertexHint -> Maybe Type+      hintType (Divert x) = Just x+      hintType (Extra x) = Just x+      hintType _ = Nothing++      doType :: Type -> StateT TypeGraphInfo m ()+      doType typ = do+        (s :: Set Type) <- use typeSet+        case Set.member typ s of+          True -> return ()+          False -> do typeSet %= Set.insert typ+                      etyp <- expandType typ+                      expanded %= Map.insert typ etyp+                      doType' typ++      doType' :: Type -> StateT TypeGraphInfo m ()+      doType' (ConT name) = do+        info <- qReify name+        infoMap %= Map.insert name info+        doInfo name info+      doType' (AppT typ1 typ2) = doType typ1 >> doType typ2+      doType' ListT = return ()+      doType' (VarT _) = return ()+      doType' (TupleT _) = return ()+      doType' typ = error $ "typeGraphInfo: " ++ pprint' typ++      doInfo :: Name -> Info -> StateT TypeGraphInfo m ()+      doInfo _tname (TyConI dec) = doDec dec+      doInfo _tname (PrimTyConI _ _ _) = return ()+      doInfo _tname (FamilyI _ _) = return () -- Not sure what to do here+      doInfo _ info = error $ "typeGraphInfo: " ++ show info++      doDec :: Dec -> StateT TypeGraphInfo m ()+      doDec (TySynD tname _ typ) = do+        etyp <- expandType typ+        synonyms %= Map.insertWith union etyp (singleton tname)+        doType typ+      doDec (NewtypeD _ tname _ constr _) = doCon tname constr+      doDec (DataD _ tname _ constrs _) = mapM_ (doCon tname) constrs+      doDec dec = error $ "typeGraphInfo: " ++ pprint' dec++      doCon :: Name -> Con -> StateT TypeGraphInfo m ()+      doCon tname (ForallC _ _ con) = doCon tname con+      doCon tname (NormalC cname flds) = mapM_ doField (zip (List.map (\n -> (tname, cname, Left n)) ([1..] :: [Int])) (List.map snd flds))+      doCon tname (RecC cname flds) = mapM_ doField (List.map (\ (fname, _, ftype) -> ((tname, cname, Right fname), ftype)) flds)+      doCon tname (InfixC (_, lhs) cname (_, rhs)) = mapM_ doField [((tname, cname, Left 1), lhs), ((tname, cname, Left 2), rhs)]++      doField :: ((Name, Name, Either Int Name), Type) -> StateT TypeGraphInfo m ()+      doField (fld, ftyp) = do+        etyp <- expandType ftyp+        expanded %= Map.insert ftyp etyp+        fields %= Map.insertWith union etyp (singleton fld)+        doType ftyp++#if 0+  (ex :: Map Type (E Type)) <- findExpanded types'+  (sy :: Map (E Type) (Set Name)) <-+      -- Build the type synonym map and then expand the types in its+      -- keys.  This will collapse some of the nodes if they differed+      -- only in the use of synonyms.+      findSynonyms types' >>= return . Map.fromListWith union . List.map (\ (typ, names) -> (expand ex typ, names))  . Map.toList+  fl <- findFields types' >>= return . Map.fromListWith union . List.map (\ (typ, names) -> (expand ex typ, names))  . Map.toList+  -- ed <- findEdges types' ex sy -- >>= return . Map.fromListWith union . List.map (\ (typ, dests) -> (expand ex typ, Set.map (expand ex) dests)) . Map.toList+  let etypes' = Set.fromList $ List.map (expand ex) (Set.toList types')+  return $ TypeGraphInfo { _expanded = ex+                         , _synonyms = sy+                         , _fields = fl+                         , _typeSet = etypes'+                         , _hints =  Map.fromListWith (++) (List.map (\ (n, h) -> (n, [h])) hintList)+                         }+      where expand ex typ = let Just etyp = Map.lookup typ ex in etyp+#endif++#if 0+-- | This is now the only function that actually recurses through the+-- type structure.  It collects the set of all accessable types.+scanTypes :: forall m. DsMonad m => [Type] -> StateT TypeGraphInfo m ()+scanTypes types =+    mapM doType types+    where+      doType :: Type -> StateT (Set Type) m ()+      doType typ = do+        (s :: Set Type) <- get+        case Set.member typ s of+          True -> return ()+          False -> modify (\ (ts, im) -> (Set.insert typ ts, im)) >> doType' typ++      doType' :: Type -> StateT (Set Type) m ()+      doType' (ConT name) = qReify name >>= \info -> modify (\ (ts, im) -> (ts, Map.insert name info im)) >> doInfo name+      doType' (AppT typ1 typ2) = doType typ1 >> doType typ2+      doType' ListT = return ()+      doType' (VarT _) = return ()+      doType' (TupleT _) = return ()+      doType' typ = error $ "scanTypes: " ++ show typ++      doInfo :: Name -> Info -> StateT (Set Type) m ()+      doInfo _tname (TyConI dec) = doDec dec+      doInfo _tname (PrimTyConI _ _ _) = return ()+      doInfo _tname (FamilyI _ _) = return () -- Not sure what to do here+      doInfo _ info = error $ "scanTypes: " ++ show info++      doDec :: Dec -> StateT (Set Type) m ()+      doDec (TySynD _ _ typ) = doType typ+      doDec (NewtypeD _ _ _ constr _) = doCon constr+      doDec (DataD _ _ _ constrs _) = mapM_ doCon constrs+      doDec dec = error $ "scanTypes: " ++ pprint' dec++      doCon :: Con -> StateT (Set Type) m ()+      doCon (ForallC _ _ con) = doCon con+      doCon (NormalC _ flds) = mapM_ doField (zip (List.map Left ([1..] :: [Int])) (List.map snd flds))+      doCon (RecC _ flds) = mapM_ doField (List.map (\ (fname, _, ftype) -> (Right fname, ftype)) flds)+      doCon (InfixC (_, lhs) _ (_, rhs)) = mapM_ doField [(Left 1, lhs), (Left 2, rhs)]++      doField :: (Either Int Name, Type) -> StateT (Set Type) m ()+      doField (_, ftyp) = doType ftyp++-- | Discover the types with all type synonyms fully expanded.+findExpanded :: DsMonad m => Set Type -> m (Map Type (E Type))+findExpanded types =+    execStateT (mapM (\typ -> expandType typ >>= \etyp -> modify (Map.insert typ etyp)) (Set.toList types)) mempty++-- | Discover the type synonyms+findSynonyms :: DsMonad m => Set Type -> m (Map Type (Set Name))+findSynonyms types =+    execStateT (mapM_ doType (Set.toList types)) mempty+    where+      doType (ConT name) = qReify name >>= doInfo+      doType (AppT typ1 typ2) = doType typ1 >> doType typ2+      doType _ = return ()+      doInfo (TyConI dec) = doDec dec+      doInfo _ = return ()+      doDec (TySynD tname _ typ) = modify (Map.insertWith union typ (singleton tname))+      doDec _ = return ()++-- | Discover the field types+findFields :: DsMonad m => Set Type -> m (Map Type (Set (Name, Name, Either Int Name)))+findFields types =+    execStateT (mapM_ doType (Set.toList types)) mempty+    where+      doType (ConT name) = qReify name >>= doInfo+      doType (AppT typ1 typ2) = doType typ1 >> doType typ2+      doType _ = return ()++      doInfo (TyConI dec) = doDec dec+      doInfo _ = return ()++      doDec (NewtypeD _ tname _ constr _) = doCon tname constr+      doDec (DataD _ tname _ constrs _) = mapM_ (doCon tname) constrs+      doDec _ = return ()++      doCon tname (ForallC _ _ con) = doCon tname con+      doCon tname (NormalC cname flds) = mapM_ (doField tname cname) (zip (List.map Left ([1..] :: [Int])) (List.map snd flds))+      doCon tname (RecC cname flds) = mapM_ (doField tname cname) (List.map (\ (fname, _, ftype) -> (Right fname, ftype)) flds)+      doCon tname (InfixC (_, lhs) cname (_, rhs)) = mapM_ (doField tname cname) [(Left 1, lhs), (Left 2, rhs)]++      doField tname cname (fname, ftyp) = modify (Map.insertWith union ftyp (singleton (tname, cname, fname)))+#endif++instance Lift TypeGraphInfo where+    lift (TypeGraphInfo {_typeSet = t, _infoMap = i, _expanded = e, _synonyms = s, _fields = f, _hints = h}) =+        [| TypeGraphInfo {_typeSet = $(lift t),+                          _infoMap = $(lift i),+                          _expanded = $(lift e),+                          _synonyms = $(lift s),+                          _fields = $(lift f),+                          _hints = $(lift h)} |]

@@ -0,0 +1,198 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TupleSections #-}+{-# OPTIONS_GHC -Wall #-}+module Language.Haskell.TH.TypeGraph.Monad+    ( findEdges+    , typeVertex+    , fieldVertex+    -- , typeVertices+    , typeGraphEdges+    , typeGraphVertices+    , typeGraph+    , simpleEdges+    , simpleVertex+    , typeSynonymMap+    , typeSynonymMapSimple+    ) where++#if __GLASGOW_HASKELL__ < 709+import Control.Applicative+import Data.Monoid (mempty)+#endif+import Control.Lens -- (makeLenses, view)+import Control.Monad.Reader (MonadReader)+import Control.Monad.State (execStateT, modify, StateT)+import Data.Graph (Graph, Vertex)+import Data.List as List (map)+import Data.Map as Map ((!), filter, findWithDefault, fromList, fromListWith,+                        keys, Map, map, mapKeys, mapWithKey, toList, alter)+import Data.Maybe (fromMaybe)+import Data.Set as Set (delete, empty, fromList, insert, map, null, Set, singleton, toList, union)+import Language.Haskell.Exts.Syntax ()+import Language.Haskell.TH -- (Con, Dec, nameBase, Type)+import Language.Haskell.TH.TypeGraph.Expand (E(E))+import Language.Haskell.TH.TypeGraph.Graph (cutVertex, GraphEdges, graphFromMap)+import Language.Haskell.TH.TypeGraph.Edges (TypeGraphEdges)+import Language.Haskell.TH.TypeGraph.Hints (VertexHint(..))+import Language.Haskell.TH.TypeGraph.Info (TypeGraphInfo, expanded, fields, hints, infoMap, synonyms, typeSet)+import Language.Haskell.TH.TypeGraph.Vertex (TypeGraphVertex(..), etype, field)+import Language.Haskell.TH.Desugar as DS (DsMonad)+import Language.Haskell.TH.Instances ()++-- | Build a TypeGraphVertex from an unexpanded type.+typeVertex :: MonadReader TypeGraphInfo m => E Type -> m TypeGraphVertex+typeVertex etyp = do+  sm <- view synonyms+  return $ TypeGraphVertex {_field = Nothing, _syns = Map.findWithDefault Set.empty etyp sm, _etype = etyp}++-- | Build a TypeGraphVertex for a field of a record.  This calls+-- 'typeVertex' and then sets the _field value.+fieldVertex :: MonadReader TypeGraphInfo m => E Type -> (Name, Name, Either Int Name) -> m TypeGraphVertex+fieldVertex typ fld = typeVertex typ >>= \vertex -> return $ vertex {_field = Just fld}++-- | Return the set of vertices referred to by a hint's vertex - if+-- field is Nothing it means all the fields with that type, if it is+-- something it means just itself.+fieldVertices :: MonadReader TypeGraphInfo m => TypeGraphVertex -> m (Set TypeGraphVertex)+fieldVertices v =+    case view field v of+      Just _ -> return $ singleton v+      Nothing -> do+        fm <- view fields+        let fs = Map.findWithDefault Set.empty (view etype v) fm+            vs = Set.map (\fld -> set field (Just fld) v) fs+        return $ Set.insert v vs++-- | Start with the type graph on the known types with no field+-- information, and build a new graph which incorporates the+-- information from the vertex hints.  This means splitting the nodes+-- according to record fields, because hints can refer to particular+-- fields of a record.+typeGraphEdges :: forall m. MonadReader TypeGraphInfo m => m TypeGraphEdges+typeGraphEdges = do+  findEdges >>= execStateT (view hints >>= mapM (uncurry doHint) . concat . List.map (\ (a, bs) -> List.map (a,) bs) . Map.toList)+    where+      doHint :: TypeGraphVertex -> VertexHint -> StateT TypeGraphEdges m ()+      doHint v Sink = fieldVertices v >>= mapM_ (modify . Map.alter (\_ -> Just Set.empty)) . Set.toList+      doHint _ Normal = return ()+      doHint v Hidden = fieldVertices v >>= mapM_ (modify . cutVertex) . Set.toList+      doHint v (Divert typ) = do+        em <- view expanded+        v' <- typeVertex (em ! typ)+        fieldVertices v >>= mapM_ (modify . Map.alter (\_ -> Just (singleton v'))) . Set.toList+      doHint v (Extra typ) = do+        em <- view expanded+        v' <- typeVertex (em ! typ)+        fieldVertices v >>= mapM_ (modify . Map.alter (\ mvs -> Just (Set.insert v' (fromMaybe Set.empty mvs)))) . Set.toList++-- | Find all the 'TypeGraphVertex' that involve this type.  All+-- returned nodes will have the same set of type synonyms, but there+-- will be one for each field where the type appears and one with+-- field Nothing.+typeVertices :: MonadReader TypeGraphInfo m => E Type -> m (Set TypeGraphVertex)+typeVertices typ = do+  syns <- view synonyms >>= return . Map.findWithDefault Set.empty typ+  flds <- view fields >>= return . Set.insert Nothing . Set.map Just . Map.findWithDefault Set.empty typ+  return $ Set.map (\ f -> TypeGraphVertex {_etype = typ, _syns = syns, _field = f}) flds++-- | Given the discovered set of types and maps of type synonyms and+-- fields, build and return the GraphEdges relation on TypeGraphVertex.+-- This is not a recursive function, it stops when it reaches the field+-- types.+findEdges :: forall m. (MonadReader TypeGraphInfo m) =>+             m (GraphEdges TypeGraphVertex)+findEdges = do+  execStateT (view typeSet >>= \ts -> mapM_ doType (Set.toList ts)) mempty+    where+      doType :: Type -> StateT (GraphEdges TypeGraphVertex) m ()+      doType typ = view expanded >>= \em -> typeVertex (em ! typ) >>= doVertex++      doVertex :: TypeGraphVertex -> StateT (GraphEdges TypeGraphVertex) m ()+      doVertex v = do+        vs <- fieldVertices v+        mapM_ node (Set.toList vs)+        case view etype v of+          E (ConT tname) -> view infoMap >>= \ mp -> doInfo vs (mp ! tname)+          E (AppT typ1 typ2) -> do+            v1 <- typeVertex (E typ1)+            v2 <- typeVertex (E typ2)+            mapM_ (flip edge v1) (Set.toList vs)+            mapM_ (flip edge v2) (Set.toList vs)+            doVertex v1+            doVertex v2+          _ -> return ()++      doInfo :: Set TypeGraphVertex -> Info -> StateT (GraphEdges TypeGraphVertex) m ()+      doInfo vs (TyConI dec) = doDec vs dec+      -- doInfo vs (PrimTyConI tname _ _) = return ()+      doInfo _ _ = return ()++      doDec :: Set TypeGraphVertex -> Dec -> StateT (GraphEdges TypeGraphVertex) m ()+      doDec _ (TySynD _ _ _) = return () -- This type will be in typeSet+      doDec vs (NewtypeD _ tname _ constr _) = doCon vs tname constr+      doDec vs (DataD _ tname _ constrs _) = mapM_ (doCon vs tname) constrs+      doDec _ _ = return ()++      doCon :: Set TypeGraphVertex -> Name -> Con -> StateT (GraphEdges TypeGraphVertex) m ()+      doCon vs tname (ForallC _ _ con) = doCon vs tname con+      doCon vs tname (NormalC cname flds) = mapM_ (uncurry (doField vs tname cname)) (List.map (\ (n, (_, ftype)) -> (Left n, ftype)) (zip [1..] flds))+      doCon vs tname (RecC cname flds) = mapM_ (uncurry (doField vs tname cname)) (List.map (\ (fname, _, ftype) -> (Right fname, ftype)) flds)+      doCon vs tname (InfixC (_, lhs) cname (_, rhs)) = doField vs tname cname (Left 1) lhs >> doField vs tname cname (Left 2) rhs++      -- Connect the vertex for this record type to one particular field vertex+      doField ::  Set TypeGraphVertex ->Name -> Name -> Either Int Name -> Type -> StateT (GraphEdges TypeGraphVertex) m ()+      doField vs tname cname fld ftyp = do+        em <- view expanded+        v2 <- fieldVertex (em ! ftyp) (tname, cname, fld)+        mapM_ (flip edge v2) (Set.toList vs)+        -- Here's where we don't recurse, see?+        -- doVertex v2++      node v = modify (Map.alter (Just . maybe Set.empty id) v)+      edge v1 v2 = modify (Map.alter (Just . maybe (singleton v2) (Set.insert v2)) v1) >> node v2++-- | Return the set of types embedded in the given type.  This is just+-- the nodes of the type graph.  The type synonymes are expanded by the+-- th-desugar package to make them suitable for use as map keys.+typeGraphVertices :: forall m. (DsMonad m, MonadReader TypeGraphInfo m) => m (Set TypeGraphVertex)+typeGraphVertices = (Set.fromList . Map.keys) <$> typeGraphEdges++-- | Build a graph from the result of typeGraphEdges, each edge goes+-- from a type to one of the types it contains.  Thus, each edge+-- represents a primitive lens, and each path in the graph is a+-- composition of lenses.+typeGraph :: forall m node key. (DsMonad m, MonadReader TypeGraphInfo m, node ~ TypeGraphVertex, key ~ TypeGraphVertex) =>+                m (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex)+typeGraph = graphFromMap <$> typeGraphEdges++-- | Simplify a graph by throwing away the field information in each+-- node.  This means the nodes only contain the fully expanded Type+-- value (and any type synonyms.)+simpleEdges :: TypeGraphEdges -> TypeGraphEdges+simpleEdges = Map.mapWithKey Set.delete . Map.mapKeys simpleVertex . Map.map (Set.map simpleVertex)++simpleVertex :: TypeGraphVertex -> TypeGraphVertex+simpleVertex node = node {_field = Nothing}++-- | Find all the reachable type synonyms and return then in a Map.+typeSynonymMap :: forall m. (DsMonad m, MonadReader TypeGraphInfo m) => m (Map TypeGraphVertex (Set Name))+typeSynonymMap =+     (Map.filter (not . Set.null) .+      Map.fromList .+      List.map (\node -> (node, _syns node)) .+      Map.keys) <$> typeGraphEdges++typeSynonymMapSimple :: forall m. (DsMonad m, MonadReader TypeGraphInfo m) => m (Map (E Type) (Set Name))+typeSynonymMapSimple =+    simplify <$> typeSynonymMap+    where+      simplify :: Map TypeGraphVertex (Set Name) -> Map (E Type) (Set Name)+      simplify mp = Map.fromListWith Set.union (List.map (\ (k, a) -> (_etype k, a)) (Map.toList mp))

@@ -0,0 +1,22 @@+-- | Degenerate instances of Expanded that must be explicitly imported+-- if you want to use them.  They are fine for simple uses of+-- expandType, but not if you are trying to use the return value of+-- expandType as a Map key.++{-# LANGUAGE CPP #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+module Language.Haskell.TH.TypeGraph.Unsafe () where++import Language.Haskell.TH (Pred, Type)+import Language.Haskell.TH.TypeGraph.Expand (Expanded(markExpanded, runExpanded))++instance Expanded Type Type where+    markExpanded = id+    runExpanded = id++#if !MIN_VERSION_template_haskell(2,10,0)+instance Expanded Pred Pred where+    markExpanded = id+    runExpanded = id+#endif

@@ -0,0 +1,63 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE TemplateHaskell #-}+module Language.Haskell.TH.TypeGraph.Vertex+    ( TypeGraphVertex(..)+    , field, syns, etype+    , typeNames+    ) where++import Control.Lens -- (makeLenses, view)+import Data.Generics (Data, everywhere, mkT)+import Data.List as List (concatMap, intersperse)+import Data.Set as Set (insert, Set, toList)+import Language.Haskell.Exts.Syntax ()+import Language.Haskell.TH -- (Con, Dec, nameBase, Type)+import Language.Haskell.TH.TypeGraph.Core ()+import Language.Haskell.TH.TypeGraph.Expand (E(E), runExpanded)+import Language.Haskell.TH.Instances ()+import Language.Haskell.TH.PprLib (hcat, ptext)+import Language.Haskell.TH.Syntax (Lift(lift))++-- | For simple type graphs always set _field and _synonyms to Nothing.+data TypeGraphVertex+    = TypeGraphVertex+      { _field :: Maybe (Name, Name, Either Int Name) -- ^ The record filed which contains this type+      , _syns :: Set Name -- ^ All the type synonyms that expand to this type+      , _etype :: E Type -- ^ The fully expanded type+      } deriving (Eq, Ord, Show)++instance Ppr TypeGraphVertex where+    ppr (TypeGraphVertex {_field = fld, _syns = ns, _etype = typ}) =+        hcat (ppr (unReify (runExpanded typ)) :+              case (fld, Set.toList ns) of+                 (Nothing, []) -> []+                 _ ->   [ptext " ("] +++                        intersperse (ptext ", ")+                          (List.concatMap (\ n -> [ptext ("aka " ++ show (unReifyName n))]) (Set.toList ns) +++                           maybe [] (\ f -> [ptext (printField f)]) fld) +++                        [ptext ")"])+        where+          printField :: (Name, Name, Either Int Name) -> String+          printField (tname, cname, field) =+              "field " +++              show (unReifyName tname) ++ "." +++              either (\ n -> show (unReifyName cname) ++ "[" ++ show n ++ "]") (\ f -> show (unReifyName f)) field++          unReify :: Data a => a -> a+          unReify = everywhere (mkT unReifyName)++          unReifyName :: Name -> Name+          unReifyName = mkName . nameBase++$(makeLenses ''TypeGraphVertex)++-- | Return the set of 'Name' of a type's synonyms, plus the name (if+-- any) used in its data declaration.  Note that this might return the+-- empty set.+typeNames :: TypeGraphVertex -> Set Name+typeNames (TypeGraphVertex {_etype = E (ConT tname), _syns = s}) = Set.insert tname s+typeNames (TypeGraphVertex {_syns = s}) = s++instance Lift TypeGraphVertex where+    lift (TypeGraphVertex {_field = f, _syns = ns, _etype = t}) =+        [|TypeGraphVertex {_field = $(lift f), _syns = $(lift ns), _etype = $(lift t)}|]

@@ -0,0 +1,3 @@+import Distribution.Simple+main :: IO ()+main = defaultMain

@@ -0,0 +1,48 @@+{-# LANGUAGE FlexibleContexts, FlexibleInstances, TemplateHaskell #-}+module Common where++import Data.List as List (intercalate, map)+import Data.Map as Map (Map, fromList, toList)+import Data.Monoid ((<>))+import Data.Set as Set (Set, difference, empty, fromList, null, toList)+import Data.Generics (Data, everywhere, mkT)+import Language.Haskell.TH+import Language.Haskell.TH.TypeGraph.Core (pprint')+import Language.Haskell.TH.TypeGraph.Expand (E, markExpanded, runExpanded)+import Language.Haskell.TH.TypeGraph.Edges (TypeGraphEdges)+import Language.Haskell.TH.TypeGraph.Vertex (TypeGraphVertex(..))++import Language.Haskell.TH.Syntax (Lift(lift))++data SetDifferences a = SetDifferences {unexpected :: Set a, missing :: Set a} deriving (Eq, Ord, Show)++setDifferences :: Ord a => Set a -> Set a -> SetDifferences a+setDifferences actual expected = SetDifferences {unexpected = Set.difference actual expected, missing = Set.difference expected actual}+noDifferences = SetDifferences {unexpected = Set.empty, missing = Set.empty}++unReify :: Data a => a -> a+unReify = everywhere (mkT unReifyName)++unReifyName :: Name -> Name+unReifyName = mkName . nameBase++-- Some very nasty bug is triggered here in ghc-7.8 if we try to implement+-- a generic function that unReifies the symbols.  Ghc-7.10 works fine++-- pprint'' :: (Data a, Ppr a) => a -> String+-- pprint'' = pprint' . unReify++pprintDec :: Dec -> String+pprintDec = pprint' . unReify++pprintType :: E Type -> String+pprintType = pprint' . unReify . runExpanded++pprintVertex :: TypeGraphVertex -> String+pprintVertex = pprint'++pprintPred :: E Pred -> String+pprintPred = pprint' . unReify . runExpanded++edgesToStrings :: TypeGraphEdges -> [(String, [String])]+edgesToStrings mp = List.map (\ (t, ts) -> (pprintVertex t, map pprintVertex (Set.toList ts))) (Map.toList mp)

@@ -0,0 +1,24 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE TemplateHaskell #-}+module Main where++import Control.DeepSeq+import Control.Monad.State (evalStateT, runStateT)+import Data.Array.Base+import Data.ByteString (ByteString)+import Data.List as List (intercalate, map, null)+import Data.Map as Map (Map, fromList, toList, map, mapKeys, empty)+import Data.Set as Set (Set, fromList, toList, null, difference, empty)+import Data.Text (Text)+import Data.Monoid (mempty)+import Language.Haskell.TH+import Language.Haskell.TH.Desugar (withLocalDeclarations)+import Language.Haskell.TH.ReifyMany+import Language.Haskell.TH.Syntax (Lift(lift), Quasi(qReifyInstances))+import System.Exit (ExitCode)+import Test.Hspec hiding (runIO)+import TypeGraph (tests)++main :: IO ()+main = hspec $ do+  TypeGraph.tests

@@ -0,0 +1,110 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TemplateHaskell #-}+{-# OPTIONS_GHC -Wall #-}+module TypeGraph where++import Control.Applicative ((<$>))+import Control.Lens+import Data.List as List (map)+import Data.Map as Map ((!), fromList)+import Data.Set as Set (fromList, singleton, toList)+import Language.Haskell.TH+import Language.Haskell.TH.TypeGraph.Core (typeArity)+import Language.Haskell.TH.TypeGraph.Expand (runExpanded, E(E))+import Language.Haskell.TH.TypeGraph.Graph (mergeVerticesM {-filterVerticesM, extendEdges, mapVerticesM-})+import Language.Haskell.TH.TypeGraph.Info (typeGraphInfo, synonyms, withTypeGraphInfo, expanded)+import Language.Haskell.TH.TypeGraph.Monad (typeGraphVertices, typeGraphEdges, typeVertex, simpleEdges)+import Language.Haskell.TH.TypeGraph.Vertex (TypeGraphVertex(..))+import Language.Haskell.TH.Desugar (withLocalDeclarations)+import Language.Haskell.TH.Instances ()+import Language.Haskell.TH.Syntax+import Test.Hspec hiding (runIO)+import Test.Hspec.Core.Spec (SpecM)++import Common+import Values++tests :: SpecM () ()+tests = do++  it "records a type synonym 1" $ do+     $([t|String|] >>= \ string -> typeGraphInfo [] [string] >>= lift . view synonyms) `shouldBe` (Map.fromList [(E (AppT ListT (ConT ''Char)), Set.singleton ''String)])++  it "records a type synonym 2" $ do+     $([t|String|] >>= \ string -> withTypeGraphInfo [] [string] (view expanded >>= \em -> typeVertex (em ! string)) >>= lift) `shouldBe` (TypeGraphVertex Nothing (singleton ''String) (E (AppT ListT (ConT ''Char))))++  it "can build the TypeInfoGraph for Type" $ do+    $(runQ [t|Type|] >>= \typ -> typeGraphInfo [] [typ] >>= lift . pprint) `shouldBe` typeGraphInfoOfType++  it "can find the edges of the (simplified) subtype graph of Type (typeEdges)" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                runQ [t|Type|] >>= \typ ->+                                withTypeGraphInfo [] [typ] typeGraphEdges >>= return . simpleEdges >>=+                                runQ . lift . edgesToStrings)) simpleTypeEdges+        `shouldBe` noDifferences++  it "can find the edges of the (unsimplified) subtype graph of Type (typeEdges)" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                runQ [t|Type|] >>= \typ ->+                                withTypeGraphInfo [] [typ] typeGraphEdges >>=+                                runQ . lift . edgesToStrings)) typeEdges+        `shouldBe` noDifferences++  it "can find the subtypesOfType" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                  runQ [t|Type|] >>= \typ ->+                                  withTypeGraphInfo [] [typ] typeGraphVertices >>=+                                  runQ . lift . List.map pprintVertex . Set.toList)) subtypesOfType+        `shouldBe` noDifferences++  it "can find the edges of the arity 0 subtype graph of Type (arity0TypeEdges)" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                runQ [t|Type|] >>= \typ ->+                                withTypeGraphInfo [] [typ] typeGraphEdges >>= return . simpleEdges >>=+                                mergeVerticesM (\ v -> (== 0) <$> (typeArity . runExpanded . _etype) v) >>=+                                runQ . lift . edgesToStrings)) arity0TypeEdges+        `shouldBe` noDifferences+#if 0+  it "can find the edges of the simple subtype graph of Dec (decEdges)" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                runQ [t|Dec|] >>= \typ ->+                                withTypeGraphInfo [] [typ] typeGraphEdges >>= return . simpleEdges >>=+                                runQ . lift . edgesToStrings)) decEdges+        `shouldBe` noDifferences++  it "can find the edges of the arity 0 subtype graph of Dec (arity0DecEdges)" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                runQ [t|Dec|] >>= \typ ->+                                withTypeGraphInfo [] [typ] typeGraphEdges >>= return . simpleEdges >>=+                                mergeVerticesM (\ v -> (== 0) <$> (typeArity . runExpanded . _etype) v) >>=+                                runQ . lift . edgesToStrings)) arity0DecEdges+        `shouldBe` noDifferences++  it "can find the subtypesOfDec" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                runQ [t|Dec|] >>= \typ ->+                                withTypeGraphInfo [] [typ] typeGraphVertices >>=+                                runQ . lift . List.map pprint . Set.toList . Set.map simpleVertex)) subtypesOfDec+        `shouldBe` noDifferences++  it "can find the arity0SubtypesOfDec" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                runQ [t|Dec|] >>= \typ ->+                                withTypeGraphInfo [] [typ] typeGraphVertices >>=+                                return . Set.toList . Set.map simpleVertex >>=+                                filterM (\ t -> typeArity (runExpanded (_etype t)) >>= \ a -> return (a == 0)) >>=+                                runQ . lift . List.map pprint)) arity0SubtypesOfDec+        `shouldBe` noDifferences++  it "can find the simpleSubtypesOfDec" $ do+     setDifferences (Set.fromList $(withLocalDeclarations [] $+                                runQ [t|Dec|] >>= \typ ->+                                withTypeGraphInfo [] [typ] typeGraphVertices >>=+                                runQ . lift . List.map pprint . Set.toList . Set.map simpleVertex)) simpleSubtypesOfDec+        `shouldBe` noDifferences++  it "can find the type synonyms in Dec (decTypeSynonyms)" $ do+     $(withLocalDeclarations [] $+       runQ [t|Dec|] >>= \typ -> withTypeGraphInfo [] [typ] (typeSynonymMapSimple >>= runQ . lift)) `shouldBe` decTypeSynonyms+#endif

@@ -0,0 +1,1098 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE TemplateHaskell #-}+module Values where++import Control.Monad (filterM)+import Data.Map as Map (Map, fromList, toList)+import Data.Ratio (Ratio)+import Data.Set as Set (Set, empty, fromList, toList, union)+import GHC.Prim -- ByteArray#, Char#, etc+import Language.Haskell.TH+import Language.Haskell.TH.TypeGraph.Core (typeArity)+import Language.Haskell.TH.TypeGraph.Expand (E(E), expandType, markExpanded)+import Language.Haskell.TH.TypeGraph.Hints (VertexHint(Normal))+import Language.Haskell.TH.TypeGraph.Monad (typeGraphVertices, typeGraphEdges)+import Language.Haskell.TH.TypeGraph.Vertex (TypeGraphVertex(..))+import Language.Haskell.TH.Desugar (withLocalDeclarations)+import Language.Haskell.TH.Instances ()+import Language.Haskell.TH.Syntax+import Test.Hspec hiding (runIO)+import Test.Hspec.Core.Spec (SpecM)++import Common++typeGraphInfoOfType =+    unlines+#if MIN_VERSION_template_haskell(2,10,0)+    [ "TypeGraphInfo:",+      "  typeSet:",+      "    [GHC.Types.Char]",+      "    [Language.Haskell.TH.Syntax.Pred]",+      "    [Language.Haskell.TH.Syntax.TyVarBndr]",+      "    GHC.Base.String",+      "    GHC.Prim.ByteArray#",+      "    GHC.Prim.Char#",+      "    GHC.Prim.Int#",+      "    GHC.Types.Char",+      "    GHC.Types.Int",+      "    GHC.Integer.Type.BigNat",+      "    GHC.Integer.Type.Integer",+      "    Language.Haskell.TH.Syntax.Cxt",+      "    Language.Haskell.TH.Syntax.Kind",+      "    Language.Haskell.TH.Syntax.ModName",+      "    Language.Haskell.TH.Syntax.Name",+      "    Language.Haskell.TH.Syntax.NameFlavour",+      "    Language.Haskell.TH.Syntax.NameSpace",+      "    Language.Haskell.TH.Syntax.OccName",+      "    Language.Haskell.TH.Syntax.PkgName",+      "    Language.Haskell.TH.Syntax.Pred",+      "    Language.Haskell.TH.Syntax.TyLit",+      "    Language.Haskell.TH.Syntax.TyVarBndr",+      "    Language.Haskell.TH.Syntax.Type",+      "    []",+      "  infoMap:",+      "    GHC.Base.String -> type GHC.Base.String = [GHC.Types.Char]",+      "    GHC.Prim.ByteArray# -> Primitive unlifted type constructor 'GHC.Prim.ByteArray#' (arity 0)",+      "    GHC.Prim.Char# -> Primitive unlifted type constructor 'GHC.Prim.Char#' (arity 0)",+      "    GHC.Prim.Int# -> Primitive unlifted type constructor 'GHC.Prim.Int#' (arity 0)",+      "    GHC.Types.Char -> data GHC.Types.Char = GHC.Types.C# GHC.Prim.Char#",+      "    GHC.Types.Int -> data GHC.Types.Int = GHC.Types.I# GHC.Prim.Int#",+      "    GHC.Integer.Type.BigNat -> data GHC.Integer.Type.BigNat",+      "        = GHC.Integer.Type.BN# GHC.Prim.ByteArray#",+      "    GHC.Integer.Type.Integer -> data GHC.Integer.Type.Integer",+      "        = GHC.Integer.Type.S# !GHC.Prim.Int#",+      "        | GHC.Integer.Type.Jp# {-# UNPACK #-} !GHC.Integer.Type.BigNat",+      "        | GHC.Integer.Type.Jn# {-# UNPACK #-} !GHC.Integer.Type.BigNat",+      "    Language.Haskell.TH.Syntax.Cxt -> type Language.Haskell.TH.Syntax.Cxt = [Language.Haskell.TH.Syntax.Pred]",+      "    Language.Haskell.TH.Syntax.Kind -> type Language.Haskell.TH.Syntax.Kind = Language.Haskell.TH.Syntax.Type",+      "    Language.Haskell.TH.Syntax.ModName -> newtype Language.Haskell.TH.Syntax.ModName",+      "      = Language.Haskell.TH.Syntax.ModName GHC.Base.String",+      "    Language.Haskell.TH.Syntax.Name -> data Language.Haskell.TH.Syntax.Name",+      "        = Language.Haskell.TH.Syntax.Name Language.Haskell.TH.Syntax.OccName",+      "                                          Language.Haskell.TH.Syntax.NameFlavour",+      "    Language.Haskell.TH.Syntax.NameFlavour -> data Language.Haskell.TH.Syntax.NameFlavour",+      "        = Language.Haskell.TH.Syntax.NameS",+      "        | Language.Haskell.TH.Syntax.NameQ Language.Haskell.TH.Syntax.ModName",+      "        | Language.Haskell.TH.Syntax.NameU {-# UNPACK #-} !GHC.Types.Int",+      "        | Language.Haskell.TH.Syntax.NameL {-# UNPACK #-} !GHC.Types.Int",+      "        | Language.Haskell.TH.Syntax.NameG Language.Haskell.TH.Syntax.NameSpace",+      "                                           Language.Haskell.TH.Syntax.PkgName",+      "                                           Language.Haskell.TH.Syntax.ModName",+      "    Language.Haskell.TH.Syntax.NameSpace -> data Language.Haskell.TH.Syntax.NameSpace",+      "        = Language.Haskell.TH.Syntax.VarName",+      "        | Language.Haskell.TH.Syntax.DataName",+      "        | Language.Haskell.TH.Syntax.TcClsName",+      "    Language.Haskell.TH.Syntax.OccName -> newtype Language.Haskell.TH.Syntax.OccName",+      "      = Language.Haskell.TH.Syntax.OccName GHC.Base.String",+      "    Language.Haskell.TH.Syntax.PkgName -> newtype Language.Haskell.TH.Syntax.PkgName",+      "      = Language.Haskell.TH.Syntax.PkgName GHC.Base.String",+      "    Language.Haskell.TH.Syntax.Pred -> type Language.Haskell.TH.Syntax.Pred = Language.Haskell.TH.Syntax.Type",+      "    Language.Haskell.TH.Syntax.TyLit -> data Language.Haskell.TH.Syntax.TyLit",+      "        = Language.Haskell.TH.Syntax.NumTyLit GHC.Integer.Type.Integer",+      "        | Language.Haskell.TH.Syntax.StrTyLit GHC.Base.String",+      "    Language.Haskell.TH.Syntax.TyVarBndr -> data Language.Haskell.TH.Syntax.TyVarBndr",+      "        = Language.Haskell.TH.Syntax.PlainTV Language.Haskell.TH.Syntax.Name",+      "        | Language.Haskell.TH.Syntax.KindedTV Language.Haskell.TH.Syntax.Name",+      "                                              Language.Haskell.TH.Syntax.Kind",+      "    Language.Haskell.TH.Syntax.Type -> data Language.Haskell.TH.Syntax.Type",+      "        = Language.Haskell.TH.Syntax.ForallT ([Language.Haskell.TH.Syntax.TyVarBndr])",+      "                                             Language.Haskell.TH.Syntax.Cxt",+      "                                             Language.Haskell.TH.Syntax.Type",+      "        | Language.Haskell.TH.Syntax.AppT Language.Haskell.TH.Syntax.Type",+      "                                          Language.Haskell.TH.Syntax.Type",+      "        | Language.Haskell.TH.Syntax.SigT Language.Haskell.TH.Syntax.Type",+      "                                          Language.Haskell.TH.Syntax.Kind",+      "        | Language.Haskell.TH.Syntax.VarT Language.Haskell.TH.Syntax.Name",+      "        | Language.Haskell.TH.Syntax.ConT Language.Haskell.TH.Syntax.Name",+      "        | Language.Haskell.TH.Syntax.PromotedT Language.Haskell.TH.Syntax.Name",+      "        | Language.Haskell.TH.Syntax.TupleT GHC.Types.Int",+      "        | Language.Haskell.TH.Syntax.UnboxedTupleT GHC.Types.Int",+      "        | Language.Haskell.TH.Syntax.ArrowT",+      "        | Language.Haskell.TH.Syntax.EqualityT",+      "        | Language.Haskell.TH.Syntax.ListT",+      "        | Language.Haskell.TH.Syntax.PromotedTupleT GHC.Types.Int",+      "        | Language.Haskell.TH.Syntax.PromotedNilT",+      "        | Language.Haskell.TH.Syntax.PromotedConsT",+      "        | Language.Haskell.TH.Syntax.StarT",+      "        | Language.Haskell.TH.Syntax.ConstraintT",+      "        | Language.Haskell.TH.Syntax.LitT Language.Haskell.TH.Syntax.TyLit",+      "  expanded:",+      "    [GHC.Types.Char] -> [GHC.Types.Char]",+      "    [Language.Haskell.TH.Syntax.Pred] -> [Language.Haskell.TH.Syntax.Type]",+      "    [Language.Haskell.TH.Syntax.TyVarBndr] -> [Language.Haskell.TH.Syntax.TyVarBndr]",+      "    GHC.Base.String -> [GHC.Types.Char]",+      "    GHC.Prim.ByteArray# -> GHC.Prim.ByteArray#",+      "    GHC.Prim.Char# -> GHC.Prim.Char#",+      "    GHC.Prim.Int# -> GHC.Prim.Int#",+      "    GHC.Types.Char -> GHC.Types.Char",+      "    GHC.Types.Int -> GHC.Types.Int",+      "    GHC.Integer.Type.BigNat -> GHC.Integer.Type.BigNat",+      "    GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer",+      "    Language.Haskell.TH.Syntax.Cxt -> [Language.Haskell.TH.Syntax.Type]",+      "    Language.Haskell.TH.Syntax.Kind -> Language.Haskell.TH.Syntax.Type",+      "    Language.Haskell.TH.Syntax.ModName -> Language.Haskell.TH.Syntax.ModName",+      "    Language.Haskell.TH.Syntax.Name -> Language.Haskell.TH.Syntax.Name",+      "    Language.Haskell.TH.Syntax.NameFlavour -> Language.Haskell.TH.Syntax.NameFlavour",+      "    Language.Haskell.TH.Syntax.NameSpace -> Language.Haskell.TH.Syntax.NameSpace",+      "    Language.Haskell.TH.Syntax.OccName -> Language.Haskell.TH.Syntax.OccName",+      "    Language.Haskell.TH.Syntax.PkgName -> Language.Haskell.TH.Syntax.PkgName",+      "    Language.Haskell.TH.Syntax.Pred -> Language.Haskell.TH.Syntax.Type",+      "    Language.Haskell.TH.Syntax.TyLit -> Language.Haskell.TH.Syntax.TyLit",+      "    Language.Haskell.TH.Syntax.TyVarBndr -> Language.Haskell.TH.Syntax.TyVarBndr",+      "    Language.Haskell.TH.Syntax.Type -> Language.Haskell.TH.Syntax.Type",+      "    [] -> []",+      "  synonyms:",+      "    [GHC.Types.Char] -> fromList [GHC.Base.String]",+      "    [Language.Haskell.TH.Syntax.Type] -> fromList [Language.Haskell.TH.Syntax.Cxt]",+      "    Language.Haskell.TH.Syntax.Type -> fromList [Language.Haskell.TH.Syntax.Kind,Language.Haskell.TH.Syntax.Pred]",+      "  fields:",+      "    [GHC.Types.Char] -> fromList [(Language.Haskell.TH.Syntax.ModName,Language.Haskell.TH.Syntax.ModName,Left 1),(Language.Haskell.TH.Syntax.OccName,Language.Haskell.TH.Syntax.OccName,Left 1),(Language.Haskell.TH.Syntax.PkgName,Language.Haskell.TH.Syntax.PkgName,Left 1),(Language.Haskell.TH.Syntax.TyLit,Language.Haskell.TH.Syntax.StrTyLit,Left 1)]",+      "    [Language.Haskell.TH.Syntax.TyVarBndr] -> fromList [(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.ForallT,Left 1)]",+      "    [Language.Haskell.TH.Syntax.Type] -> fromList [(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.ForallT,Left 2)]",+      "    GHC.Prim.ByteArray# -> fromList [(GHC.Integer.Type.BigNat,GHC.Integer.Type.BN#,Left 1)]",+      "    GHC.Prim.Char# -> fromList [(GHC.Types.Char,GHC.Types.C#,Left 1)]",+      "    GHC.Prim.Int# -> fromList [(GHC.Types.Int,GHC.Types.I#,Left 1),(GHC.Integer.Type.Integer,GHC.Integer.Type.S#,Left 1)]",+      "    GHC.Types.Int -> fromList [(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameL,Left 1),(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameU,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.PromotedTupleT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.TupleT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.UnboxedTupleT,Left 1)]",+      "    GHC.Integer.Type.BigNat -> fromList [(GHC.Integer.Type.Integer,GHC.Integer.Type.Jn#,Left 1),(GHC.Integer.Type.Integer,GHC.Integer.Type.Jp#,Left 1)]",+      "    GHC.Integer.Type.Integer -> fromList [(Language.Haskell.TH.Syntax.TyLit,Language.Haskell.TH.Syntax.NumTyLit,Left 1)]",+      "    Language.Haskell.TH.Syntax.ModName -> fromList [(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameG,Left 3),(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameQ,Left 1)]",+      "    Language.Haskell.TH.Syntax.Name -> fromList [(Language.Haskell.TH.Syntax.TyVarBndr,Language.Haskell.TH.Syntax.KindedTV,Left 1),(Language.Haskell.TH.Syntax.TyVarBndr,Language.Haskell.TH.Syntax.PlainTV,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.ConT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.PromotedT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.VarT,Left 1)]",+      "    Language.Haskell.TH.Syntax.NameFlavour -> fromList [(Language.Haskell.TH.Syntax.Name,Language.Haskell.TH.Syntax.Name,Left 2)]",+      "    Language.Haskell.TH.Syntax.NameSpace -> fromList [(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameG,Left 1)]",+      "    Language.Haskell.TH.Syntax.OccName -> fromList [(Language.Haskell.TH.Syntax.Name,Language.Haskell.TH.Syntax.Name,Left 1)]",+      "    Language.Haskell.TH.Syntax.PkgName -> fromList [(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameG,Left 2)]",+      "    Language.Haskell.TH.Syntax.TyLit -> fromList [(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.LitT,Left 1)]",+      "    Language.Haskell.TH.Syntax.Type -> fromList [(Language.Haskell.TH.Syntax.TyVarBndr,Language.Haskell.TH.Syntax.KindedTV,Left 2),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.AppT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.AppT,Left 2),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.ForallT,Left 3),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.SigT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.SigT,Left 2)]",+      "  hints:" ]+#else+    [ "TypeGraphInfo:",+      "  typeSet:",+      "    [GHC.Types.Char]",+      "    [Language.Haskell.TH.Syntax.Pred]",+      "    [Language.Haskell.TH.Syntax.TyVarBndr]",+      "    [Language.Haskell.TH.Syntax.Type]",+      "    GHC.Base.String",+      "    GHC.Prim.ByteArray#",+      "    GHC.Prim.Char#",+      "    GHC.Prim.Int#",+      "    GHC.Types.Char",+      "    GHC.Types.Int",+      "    GHC.Integer.Type.Integer",+      "    Language.Haskell.TH.Syntax.Cxt",+      "    Language.Haskell.TH.Syntax.Kind",+      "    Language.Haskell.TH.Syntax.ModName",+      "    Language.Haskell.TH.Syntax.Name",+      "    Language.Haskell.TH.Syntax.NameFlavour",+      "    Language.Haskell.TH.Syntax.NameSpace",+      "    Language.Haskell.TH.Syntax.OccName",+      "    Language.Haskell.TH.Syntax.PkgName",+      "    Language.Haskell.TH.Syntax.Pred",+      "    Language.Haskell.TH.Syntax.TyLit",+      "    Language.Haskell.TH.Syntax.TyVarBndr",+      "    Language.Haskell.TH.Syntax.Type",+      "    []",+      "  infoMap:",+      "    GHC.Base.String -> type GHC.Base.String = [GHC.Types.Char]",+      "    GHC.Prim.ByteArray# -> Primitive unlifted type constructor 'GHC.Prim.ByteArray#' (arity 0)",+      "    GHC.Prim.Char# -> Primitive unlifted type constructor 'GHC.Prim.Char#' (arity 0)",+      "    GHC.Prim.Int# -> Primitive unlifted type constructor 'GHC.Prim.Int#' (arity 0)",+      "    GHC.Types.Char -> data GHC.Types.Char = GHC.Types.C# GHC.Prim.Char#",+      "    GHC.Types.Int -> data GHC.Types.Int = GHC.Types.I# GHC.Prim.Int#",+      "    GHC.Integer.Type.Integer -> data GHC.Integer.Type.Integer",+      "        = GHC.Integer.Type.S# GHC.Prim.Int#",+      "        | GHC.Integer.Type.J# GHC.Prim.Int# GHC.Prim.ByteArray#",+      "    Language.Haskell.TH.Syntax.Cxt -> type Language.Haskell.TH.Syntax.Cxt = [Language.Haskell.TH.Syntax.Pred]",+      "    Language.Haskell.TH.Syntax.Kind -> type Language.Haskell.TH.Syntax.Kind = Language.Haskell.TH.Syntax.Type",+      "    Language.Haskell.TH.Syntax.ModName -> newtype Language.Haskell.TH.Syntax.ModName",+      "      = Language.Haskell.TH.Syntax.ModName GHC.Base.String",+      "    Language.Haskell.TH.Syntax.Name -> data Language.Haskell.TH.Syntax.Name",+      "        = Language.Haskell.TH.Syntax.Name Language.Haskell.TH.Syntax.OccName",+      "                                          Language.Haskell.TH.Syntax.NameFlavour",+      "    Language.Haskell.TH.Syntax.NameFlavour -> data Language.Haskell.TH.Syntax.NameFlavour",+      "        = Language.Haskell.TH.Syntax.NameS",+      "        | Language.Haskell.TH.Syntax.NameQ Language.Haskell.TH.Syntax.ModName",+      "        | Language.Haskell.TH.Syntax.NameU GHC.Prim.Int#",+      "        | Language.Haskell.TH.Syntax.NameL GHC.Prim.Int#",+      "        | Language.Haskell.TH.Syntax.NameG Language.Haskell.TH.Syntax.NameSpace",+      "                                           Language.Haskell.TH.Syntax.PkgName",+      "                                           Language.Haskell.TH.Syntax.ModName",+      "    Language.Haskell.TH.Syntax.NameSpace -> data Language.Haskell.TH.Syntax.NameSpace",+      "        = Language.Haskell.TH.Syntax.VarName",+      "        | Language.Haskell.TH.Syntax.DataName",+      "        | Language.Haskell.TH.Syntax.TcClsName",+      "    Language.Haskell.TH.Syntax.OccName -> newtype Language.Haskell.TH.Syntax.OccName",+      "      = Language.Haskell.TH.Syntax.OccName GHC.Base.String",+      "    Language.Haskell.TH.Syntax.PkgName -> newtype Language.Haskell.TH.Syntax.PkgName",+      "      = Language.Haskell.TH.Syntax.PkgName GHC.Base.String",+      "    Language.Haskell.TH.Syntax.Pred -> data Language.Haskell.TH.Syntax.Pred",+      "        = Language.Haskell.TH.Syntax.ClassP Language.Haskell.TH.Syntax.Name",+      "                                            ([Language.Haskell.TH.Syntax.Type])",+      "        | Language.Haskell.TH.Syntax.EqualP Language.Haskell.TH.Syntax.Type",+      "                                            Language.Haskell.TH.Syntax.Type",+      "    Language.Haskell.TH.Syntax.TyLit -> data Language.Haskell.TH.Syntax.TyLit",+      "        = Language.Haskell.TH.Syntax.NumTyLit GHC.Integer.Type.Integer",+      "        | Language.Haskell.TH.Syntax.StrTyLit GHC.Base.String",+      "    Language.Haskell.TH.Syntax.TyVarBndr -> data Language.Haskell.TH.Syntax.TyVarBndr",+      "        = Language.Haskell.TH.Syntax.PlainTV Language.Haskell.TH.Syntax.Name",+      "        | Language.Haskell.TH.Syntax.KindedTV Language.Haskell.TH.Syntax.Name",+      "                                              Language.Haskell.TH.Syntax.Kind",+      "    Language.Haskell.TH.Syntax.Type -> data Language.Haskell.TH.Syntax.Type",+      "        = Language.Haskell.TH.Syntax.ForallT ([Language.Haskell.TH.Syntax.TyVarBndr])",+      "                                             Language.Haskell.TH.Syntax.Cxt",+      "                                             Language.Haskell.TH.Syntax.Type",+      "        | Language.Haskell.TH.Syntax.AppT Language.Haskell.TH.Syntax.Type",+      "                                          Language.Haskell.TH.Syntax.Type",+      "        | Language.Haskell.TH.Syntax.SigT Language.Haskell.TH.Syntax.Type",+      "                                          Language.Haskell.TH.Syntax.Kind",+      "        | Language.Haskell.TH.Syntax.VarT Language.Haskell.TH.Syntax.Name",+      "        | Language.Haskell.TH.Syntax.ConT Language.Haskell.TH.Syntax.Name",+      "        | Language.Haskell.TH.Syntax.PromotedT Language.Haskell.TH.Syntax.Name",+      "        | Language.Haskell.TH.Syntax.TupleT GHC.Types.Int",+      "        | Language.Haskell.TH.Syntax.UnboxedTupleT GHC.Types.Int",+      "        | Language.Haskell.TH.Syntax.ArrowT",+      "        | Language.Haskell.TH.Syntax.ListT",+      "        | Language.Haskell.TH.Syntax.PromotedTupleT GHC.Types.Int",+      "        | Language.Haskell.TH.Syntax.PromotedNilT",+      "        | Language.Haskell.TH.Syntax.PromotedConsT",+      "        | Language.Haskell.TH.Syntax.StarT",+      "        | Language.Haskell.TH.Syntax.ConstraintT",+      "        | Language.Haskell.TH.Syntax.LitT Language.Haskell.TH.Syntax.TyLit",+      "  expanded:",+      "    [GHC.Types.Char] -> [GHC.Types.Char]",+      "    [Language.Haskell.TH.Syntax.Pred] -> [Language.Haskell.TH.Syntax.Pred]",+      "    [Language.Haskell.TH.Syntax.TyVarBndr] -> [Language.Haskell.TH.Syntax.TyVarBndr]",+      "    [Language.Haskell.TH.Syntax.Type] -> [Language.Haskell.TH.Syntax.Type]",+      "    GHC.Base.String -> [GHC.Types.Char]",+      "    GHC.Prim.ByteArray# -> GHC.Prim.ByteArray#",+      "    GHC.Prim.Char# -> GHC.Prim.Char#",+      "    GHC.Prim.Int# -> GHC.Prim.Int#",+      "    GHC.Types.Char -> GHC.Types.Char",+      "    GHC.Types.Int -> GHC.Types.Int",+      "    GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer",+      "    Language.Haskell.TH.Syntax.Cxt -> [Language.Haskell.TH.Syntax.Pred]",+      "    Language.Haskell.TH.Syntax.Kind -> Language.Haskell.TH.Syntax.Type",+      "    Language.Haskell.TH.Syntax.ModName -> Language.Haskell.TH.Syntax.ModName",+      "    Language.Haskell.TH.Syntax.Name -> Language.Haskell.TH.Syntax.Name",+      "    Language.Haskell.TH.Syntax.NameFlavour -> Language.Haskell.TH.Syntax.NameFlavour",+      "    Language.Haskell.TH.Syntax.NameSpace -> Language.Haskell.TH.Syntax.NameSpace",+      "    Language.Haskell.TH.Syntax.OccName -> Language.Haskell.TH.Syntax.OccName",+      "    Language.Haskell.TH.Syntax.PkgName -> Language.Haskell.TH.Syntax.PkgName",+      "    Language.Haskell.TH.Syntax.Pred -> Language.Haskell.TH.Syntax.Pred",+      "    Language.Haskell.TH.Syntax.TyLit -> Language.Haskell.TH.Syntax.TyLit",+      "    Language.Haskell.TH.Syntax.TyVarBndr -> Language.Haskell.TH.Syntax.TyVarBndr",+      "    Language.Haskell.TH.Syntax.Type -> Language.Haskell.TH.Syntax.Type",+      "    [] -> []",+      "  synonyms:",+      "    [GHC.Types.Char] -> fromList [GHC.Base.String]",+      "    [Language.Haskell.TH.Syntax.Pred] -> fromList [Language.Haskell.TH.Syntax.Cxt]",+      "    Language.Haskell.TH.Syntax.Type -> fromList [Language.Haskell.TH.Syntax.Kind]",+      "  fields:",+      "    [GHC.Types.Char] -> fromList [(Language.Haskell.TH.Syntax.ModName,Language.Haskell.TH.Syntax.ModName,Left 1),(Language.Haskell.TH.Syntax.OccName,Language.Haskell.TH.Syntax.OccName,Left 1),(Language.Haskell.TH.Syntax.PkgName,Language.Haskell.TH.Syntax.PkgName,Left 1),(Language.Haskell.TH.Syntax.TyLit,Language.Haskell.TH.Syntax.StrTyLit,Left 1)]",+      "    [Language.Haskell.TH.Syntax.Pred] -> fromList [(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.ForallT,Left 2)]",+      "    [Language.Haskell.TH.Syntax.TyVarBndr] -> fromList [(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.ForallT,Left 1)]",+      "    [Language.Haskell.TH.Syntax.Type] -> fromList [(Language.Haskell.TH.Syntax.Pred,Language.Haskell.TH.Syntax.ClassP,Left 2)]",+      "    GHC.Prim.ByteArray# -> fromList [(GHC.Integer.Type.Integer,GHC.Integer.Type.J#,Left 2)]",+      "    GHC.Prim.Char# -> fromList [(GHC.Types.Char,GHC.Types.C#,Left 1)]",+      "    GHC.Prim.Int# -> fromList [(GHC.Types.Int,GHC.Types.I#,Left 1),(GHC.Integer.Type.Integer,GHC.Integer.Type.J#,Left 1),(GHC.Integer.Type.Integer,GHC.Integer.Type.S#,Left 1),(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameL,Left 1),(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameU,Left 1)]",+      "    GHC.Types.Int -> fromList [(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.PromotedTupleT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.TupleT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.UnboxedTupleT,Left 1)]",+      "    GHC.Integer.Type.Integer -> fromList [(Language.Haskell.TH.Syntax.TyLit,Language.Haskell.TH.Syntax.NumTyLit,Left 1)]",+      "    Language.Haskell.TH.Syntax.ModName -> fromList [(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameG,Left 3),(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameQ,Left 1)]",+      "    Language.Haskell.TH.Syntax.Name -> fromList [(Language.Haskell.TH.Syntax.Pred,Language.Haskell.TH.Syntax.ClassP,Left 1),(Language.Haskell.TH.Syntax.TyVarBndr,Language.Haskell.TH.Syntax.KindedTV,Left 1),(Language.Haskell.TH.Syntax.TyVarBndr,Language.Haskell.TH.Syntax.PlainTV,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.ConT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.PromotedT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.VarT,Left 1)]",+      "    Language.Haskell.TH.Syntax.NameFlavour -> fromList [(Language.Haskell.TH.Syntax.Name,Language.Haskell.TH.Syntax.Name,Left 2)]",+      "    Language.Haskell.TH.Syntax.NameSpace -> fromList [(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameG,Left 1)]",+      "    Language.Haskell.TH.Syntax.OccName -> fromList [(Language.Haskell.TH.Syntax.Name,Language.Haskell.TH.Syntax.Name,Left 1)]",+      "    Language.Haskell.TH.Syntax.PkgName -> fromList [(Language.Haskell.TH.Syntax.NameFlavour,Language.Haskell.TH.Syntax.NameG,Left 2)]",+      "    Language.Haskell.TH.Syntax.TyLit -> fromList [(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.LitT,Left 1)]",+      "    Language.Haskell.TH.Syntax.Type -> fromList [(Language.Haskell.TH.Syntax.Pred,Language.Haskell.TH.Syntax.EqualP,Left 1),(Language.Haskell.TH.Syntax.Pred,Language.Haskell.TH.Syntax.EqualP,Left 2),(Language.Haskell.TH.Syntax.TyVarBndr,Language.Haskell.TH.Syntax.KindedTV,Left 2),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.AppT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.AppT,Left 2),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.ForallT,Left 3),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.SigT,Left 1),(Language.Haskell.TH.Syntax.Type,Language.Haskell.TH.Syntax.SigT,Left 2)]",+      "  hints:" ]+#endif++subtypesOfType :: Set String+subtypesOfType =+    Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+     "BigNat","BigNat (field Integer.Jn#[1])","BigNat (field Integer.Jp#[1])","ByteArray#","ByteArray# (field BigNat.BN#[1])","Char","Char#","Char# (field Char.C#[1])","Int","Int (field NameFlavour.NameL[1])","Int (field NameFlavour.NameU[1])","Int (field Type.PromotedTupleT[1])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Int#","Int# (field Int.I#[1])","Int# (field Integer.S#[1])","Integer","Integer (field TyLit.NumTyLit[1])","ModName","ModName (field NameFlavour.NameG[3])","ModName (field NameFlavour.NameQ[1])","Name","Name (field TyVarBndr.KindedTV[1])","Name (field TyVarBndr.PlainTV[1])","Name (field Type.ConT[1])","Name (field Type.PromotedT[1])","Name (field Type.VarT[1])","NameFlavour","NameFlavour (field Name.Name[2])","NameSpace","NameSpace (field NameFlavour.NameG[1])","OccName","OccName (field Name.Name[1])","PkgName","PkgName (field NameFlavour.NameG[2])","TyLit","TyLit (field Type.LitT[1])","TyVarBndr","Type (aka Kind, aka Pred)","Type (aka Kind, aka Pred, field TyVarBndr.KindedTV[2])","Type (aka Kind, aka Pred, field Type.AppT[1])","Type (aka Kind, aka Pred, field Type.AppT[2])","Type (aka Kind, aka Pred, field Type.ForallT[3])","Type (aka Kind, aka Pred, field Type.SigT[1])","Type (aka Kind, aka Pred, field Type.SigT[2])","[Char] (aka String)","[Char] (aka String, field ModName.ModName[1])","[Char] (aka String, field OccName.OccName[1])","[Char] (aka String, field PkgName.PkgName[1])","[Char] (aka String, field TyLit.StrTyLit[1])","[TyVarBndr]","[TyVarBndr] (field Type.ForallT[1])","[Type] (aka Cxt)","[Type] (aka Cxt, field Type.ForallT[2])","[]"+#else+     "ByteArray#","ByteArray# (field Integer.J#[2])","Char","Char#","Char# (field Char.C#[1])","Int","Int (field Type.PromotedTupleT[1])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Int#","Int# (field Int.I#[1])","Int# (field Integer.J#[1])","Int# (field Integer.S#[1])","Int# (field NameFlavour.NameL[1])","Int# (field NameFlavour.NameU[1])","Integer","Integer (field TyLit.NumTyLit[1])","ModName","ModName (field NameFlavour.NameG[3])","ModName (field NameFlavour.NameQ[1])","Name","Name (field Pred.ClassP[1])","Name (field TyVarBndr.KindedTV[1])","Name (field TyVarBndr.PlainTV[1])","Name (field Type.ConT[1])","Name (field Type.PromotedT[1])","Name (field Type.VarT[1])","NameFlavour","NameFlavour (field Name.Name[2])","NameSpace","NameSpace (field NameFlavour.NameG[1])","OccName","OccName (field Name.Name[1])","PkgName","PkgName (field NameFlavour.NameG[2])","Pred","TyLit","TyLit (field Type.LitT[1])","TyVarBndr","Type (aka Kind)","Type (aka Kind, field Pred.EqualP[1])","Type (aka Kind, field Pred.EqualP[2])","Type (aka Kind, field TyVarBndr.KindedTV[2])","Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Type (aka Kind, field Type.ForallT[3])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","[Char] (aka String)","[Char] (aka String, field ModName.ModName[1])","[Char] (aka String, field OccName.OccName[1])","[Char] (aka String, field PkgName.PkgName[1])","[Char] (aka String, field TyLit.StrTyLit[1])","[Pred] (aka Cxt)","[Pred] (aka Cxt, field Type.ForallT[2])","[TyVarBndr]","[TyVarBndr] (field Type.ForallT[1])","[Type]","[Type] (field Pred.ClassP[2])","[]"+#endif+    ]++simpleTypeEdges :: Set (String, [String])+simpleTypeEdges =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+     ("BigNat",["ByteArray#"]),+     ("ByteArray#",[]),+     ("Char",["Char#"]),+     ("Char#",[]),+     ("Int",["Int#"]),+     ("Int#",[]),+     ("Integer",["Int#","BigNat"]),+     ("ModName",["[Char] (aka String)"]),+     ("Name",["NameFlavour","OccName"]),+     ("NameFlavour",["Int","ModName","NameSpace","PkgName"]),+     ("NameSpace",[]),+     ("OccName",["[Char] (aka String)"]),+     ("PkgName",["[Char] (aka String)"]),+     ("TyLit",["Integer","[Char] (aka String)"]),+     ("TyVarBndr",["Name","Type (aka Kind, aka Pred)"]),+     ("Type (aka Kind, aka Pred)",["[TyVarBndr]","Int","Name","TyLit","[Type] (aka Cxt)"]),+     ("[Char] (aka String)",["Char","[]"]),+     ("[TyVarBndr]",["TyVarBndr","[]"]),+     ("[Type] (aka Cxt)",["[]","Type (aka Kind, aka Pred)"]),+     ("[]",[])+#else+     ("ByteArray#",[]),+     ("Char",["Char#"]),+     ("Char#",[]),+     ("Int",["Int#"]),+     ("Int#",[]),+     ("Integer",["ByteArray#","Int#"]),+     ("ModName",["[Char] (aka String)"]),+     ("Name",["NameFlavour","OccName"]),+     ("NameFlavour",["Int#","ModName","NameSpace","PkgName"]),+     ("NameSpace",[]),+     ("OccName",["[Char] (aka String)"]),+     ("PkgName",["[Char] (aka String)"]),+     ("Pred",["[Type]","Name","Type (aka Kind)"]),+     ("TyLit",["Integer","[Char] (aka String)"]),+     ("TyVarBndr",["Name","Type (aka Kind)"]),+     ("Type (aka Kind)",["[TyVarBndr]","Int","Name","TyLit","[Pred] (aka Cxt)"]),+     ("[Char] (aka String)",["Char","[]"]),+     ("[Pred] (aka Cxt)",["Pred","[]"]),+     ("[TyVarBndr]",["TyVarBndr","[]"]),+     ("[Type]",["[]","Type (aka Kind)"]),+     ("[]",[])+#endif+    ]++typeEdges ::  Set (String, [String])+typeEdges =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+     ("BigNat",["ByteArray# (field BigNat.BN#[1])"]),+     ("BigNat (field Integer.Jn#[1])",["ByteArray# (field BigNat.BN#[1])"]),+     ("BigNat (field Integer.Jp#[1])",["ByteArray# (field BigNat.BN#[1])"]),+     ("ByteArray#",[]),+     ("ByteArray# (field BigNat.BN#[1])",[]),+     ("Char",["Char# (field Char.C#[1])"]),+     ("Char#",[]),+     ("Char# (field Char.C#[1])",[]),+     ("Int",["Int# (field Int.I#[1])"]),+     ("Int (field NameFlavour.NameL[1])",["Int# (field Int.I#[1])"]),+     ("Int (field NameFlavour.NameU[1])",["Int# (field Int.I#[1])"]),+     ("Int (field Type.PromotedTupleT[1])",["Int# (field Int.I#[1])"]),+     ("Int (field Type.TupleT[1])",["Int# (field Int.I#[1])"]),+     ("Int (field Type.UnboxedTupleT[1])",["Int# (field Int.I#[1])"]),+     ("Int#",[]),+     ("Int# (field Int.I#[1])",[]),+     ("Int# (field Integer.S#[1])",[]),+     ("Integer",["BigNat (field Integer.Jn#[1])","BigNat (field Integer.Jp#[1])","Int# (field Integer.S#[1])"]),+     ("Integer (field TyLit.NumTyLit[1])",["BigNat (field Integer.Jn#[1])","BigNat (field Integer.Jp#[1])","Int# (field Integer.S#[1])"]),+     ("ModName",["[Char] (aka String, field ModName.ModName[1])"]),+     ("ModName (field NameFlavour.NameG[3])",["[Char] (aka String, field ModName.ModName[1])"]),+     ("ModName (field NameFlavour.NameQ[1])",["[Char] (aka String, field ModName.ModName[1])"]),+     ("Name",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field TyVarBndr.KindedTV[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field TyVarBndr.PlainTV[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field Type.ConT[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field Type.PromotedT[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field Type.VarT[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("NameFlavour",["NameSpace (field NameFlavour.NameG[1])","PkgName (field NameFlavour.NameG[2])","ModName (field NameFlavour.NameG[3])","Int (field NameFlavour.NameL[1])","ModName (field NameFlavour.NameQ[1])","Int (field NameFlavour.NameU[1])"]),+     ("NameFlavour (field Name.Name[2])",["NameSpace (field NameFlavour.NameG[1])","PkgName (field NameFlavour.NameG[2])","ModName (field NameFlavour.NameG[3])","Int (field NameFlavour.NameL[1])","ModName (field NameFlavour.NameQ[1])","Int (field NameFlavour.NameU[1])"]),+     ("NameSpace",[]),+     ("NameSpace (field NameFlavour.NameG[1])",[]),+     ("OccName",["[Char] (aka String, field OccName.OccName[1])"]),+     ("OccName (field Name.Name[1])",["[Char] (aka String, field OccName.OccName[1])"]),+     ("PkgName",["[Char] (aka String, field PkgName.PkgName[1])"]),+     ("PkgName (field NameFlavour.NameG[2])",["[Char] (aka String, field PkgName.PkgName[1])"]),+     ("TyLit",["Integer (field TyLit.NumTyLit[1])","[Char] (aka String, field TyLit.StrTyLit[1])"]),+     ("TyLit (field Type.LitT[1])",["Integer (field TyLit.NumTyLit[1])","[Char] (aka String, field TyLit.StrTyLit[1])"]),+     ("TyVarBndr",["Name (field TyVarBndr.KindedTV[1])","Type (aka Kind, aka Pred, field TyVarBndr.KindedTV[2])","Name (field TyVarBndr.PlainTV[1])"]),+     ("Type (aka Kind, aka Pred)",["Type (aka Kind, aka Pred, field Type.AppT[1])","Type (aka Kind, aka Pred, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Type] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, aka Pred, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, aka Pred, field Type.SigT[1])","Type (aka Kind, aka Pred, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, aka Pred, field TyVarBndr.KindedTV[2])",["Type (aka Kind, aka Pred, field Type.AppT[1])","Type (aka Kind, aka Pred, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Type] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, aka Pred, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, aka Pred, field Type.SigT[1])","Type (aka Kind, aka Pred, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, aka Pred, field Type.AppT[1])",["Type (aka Kind, aka Pred, field Type.AppT[1])","Type (aka Kind, aka Pred, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Type] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, aka Pred, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, aka Pred, field Type.SigT[1])","Type (aka Kind, aka Pred, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, aka Pred, field Type.AppT[2])",["Type (aka Kind, aka Pred, field Type.AppT[1])","Type (aka Kind, aka Pred, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Type] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, aka Pred, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, aka Pred, field Type.SigT[1])","Type (aka Kind, aka Pred, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, aka Pred, field Type.ForallT[3])",["Type (aka Kind, aka Pred, field Type.AppT[1])","Type (aka Kind, aka Pred, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Type] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, aka Pred, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, aka Pred, field Type.SigT[1])","Type (aka Kind, aka Pred, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, aka Pred, field Type.SigT[1])",["Type (aka Kind, aka Pred, field Type.AppT[1])","Type (aka Kind, aka Pred, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Type] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, aka Pred, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, aka Pred, field Type.SigT[1])","Type (aka Kind, aka Pred, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, aka Pred, field Type.SigT[2])",["Type (aka Kind, aka Pred, field Type.AppT[1])","Type (aka Kind, aka Pred, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Type] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, aka Pred, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, aka Pred, field Type.SigT[1])","Type (aka Kind, aka Pred, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("[Char] (aka String)",["Char","[]"]),+     ("[Char] (aka String, field ModName.ModName[1])",["Char","[]"]),+     ("[Char] (aka String, field OccName.OccName[1])",["Char","[]"]),+     ("[Char] (aka String, field PkgName.PkgName[1])",["Char","[]"]),+     ("[Char] (aka String, field TyLit.StrTyLit[1])",["Char","[]"]),+     ("[TyVarBndr]",["TyVarBndr","[]"]),+     ("[TyVarBndr] (field Type.ForallT[1])",["TyVarBndr","[]"]),+     ("[Type] (aka Cxt)",["[]","Type (aka Kind, aka Pred)"]),+     ("[Type] (aka Cxt, field Type.ForallT[2])",["[]","Type (aka Kind, aka Pred)"]),+     ("[]",[])+#else+     ("ByteArray#",[]),+     ("ByteArray# (field Integer.J#[2])",[]),+     ("Char",["Char# (field Char.C#[1])"]),+     ("Char#",[]),+     ("Char# (field Char.C#[1])",[]),+     ("Int",["Int# (field Int.I#[1])"]),+     ("Int (field Type.PromotedTupleT[1])",["Int# (field Int.I#[1])"]),+     ("Int (field Type.TupleT[1])",["Int# (field Int.I#[1])"]),+     ("Int (field Type.UnboxedTupleT[1])",["Int# (field Int.I#[1])"]),+     ("Int#",[]),+     ("Int# (field Int.I#[1])",[]),+     ("Int# (field Integer.J#[1])",[]),+     ("Int# (field Integer.S#[1])",[]),+     ("Int# (field NameFlavour.NameL[1])",[]),+     ("Int# (field NameFlavour.NameU[1])",[]),+     ("Integer",["Int# (field Integer.J#[1])","ByteArray# (field Integer.J#[2])","Int# (field Integer.S#[1])"]),+     ("Integer (field TyLit.NumTyLit[1])",["Int# (field Integer.J#[1])","ByteArray# (field Integer.J#[2])","Int# (field Integer.S#[1])"]),+     ("ModName",["[Char] (aka String, field ModName.ModName[1])"]),+     ("ModName (field NameFlavour.NameG[3])",["[Char] (aka String, field ModName.ModName[1])"]),+     ("ModName (field NameFlavour.NameQ[1])",["[Char] (aka String, field ModName.ModName[1])"]),+     ("Name",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field Pred.ClassP[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field TyVarBndr.KindedTV[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field TyVarBndr.PlainTV[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field Type.ConT[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field Type.PromotedT[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("Name (field Type.VarT[1])",["OccName (field Name.Name[1])","NameFlavour (field Name.Name[2])"]),+     ("NameFlavour",["NameSpace (field NameFlavour.NameG[1])","PkgName (field NameFlavour.NameG[2])","ModName (field NameFlavour.NameG[3])","Int# (field NameFlavour.NameL[1])","ModName (field NameFlavour.NameQ[1])","Int# (field NameFlavour.NameU[1])"]),+     ("NameFlavour (field Name.Name[2])",["NameSpace (field NameFlavour.NameG[1])","PkgName (field NameFlavour.NameG[2])","ModName (field NameFlavour.NameG[3])","Int# (field NameFlavour.NameL[1])","ModName (field NameFlavour.NameQ[1])","Int# (field NameFlavour.NameU[1])"]),+     ("NameSpace",[]),+     ("NameSpace (field NameFlavour.NameG[1])",[]),+     ("OccName",["[Char] (aka String, field OccName.OccName[1])"]),+     ("OccName (field Name.Name[1])",["[Char] (aka String, field OccName.OccName[1])"]),+     ("PkgName",["[Char] (aka String, field PkgName.PkgName[1])"]),+     ("PkgName (field NameFlavour.NameG[2])",["[Char] (aka String, field PkgName.PkgName[1])"]),+     ("Pred",["Name (field Pred.ClassP[1])","[Type] (field Pred.ClassP[2])","Type (aka Kind, field Pred.EqualP[1])","Type (aka Kind, field Pred.EqualP[2])"]),+     ("TyLit",["Integer (field TyLit.NumTyLit[1])","[Char] (aka String, field TyLit.StrTyLit[1])"]),+     ("TyLit (field Type.LitT[1])",["Integer (field TyLit.NumTyLit[1])","[Char] (aka String, field TyLit.StrTyLit[1])"]),+     ("TyVarBndr",["Name (field TyVarBndr.KindedTV[1])","Type (aka Kind, field TyVarBndr.KindedTV[2])","Name (field TyVarBndr.PlainTV[1])"]),+     ("Type (aka Kind)",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, field Pred.EqualP[1])",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, field Pred.EqualP[2])",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, field TyVarBndr.KindedTV[2])",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, field Type.AppT[1])",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, field Type.AppT[2])",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, field Type.ForallT[3])",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, field Type.SigT[1])",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("Type (aka Kind, field Type.SigT[2])",["Type (aka Kind, field Type.AppT[1])","Type (aka Kind, field Type.AppT[2])","Name (field Type.ConT[1])","[TyVarBndr] (field Type.ForallT[1])","[Pred] (aka Cxt, field Type.ForallT[2])","Type (aka Kind, field Type.ForallT[3])","TyLit (field Type.LitT[1])","Name (field Type.PromotedT[1])","Int (field Type.PromotedTupleT[1])","Type (aka Kind, field Type.SigT[1])","Type (aka Kind, field Type.SigT[2])","Int (field Type.TupleT[1])","Int (field Type.UnboxedTupleT[1])","Name (field Type.VarT[1])"]),+     ("[Char] (aka String)",["Char","[]"]),+     ("[Char] (aka String, field ModName.ModName[1])",["Char","[]"]),+     ("[Char] (aka String, field OccName.OccName[1])",["Char","[]"]),+     ("[Char] (aka String, field PkgName.PkgName[1])",["Char","[]"]),+     ("[Char] (aka String, field TyLit.StrTyLit[1])",["Char","[]"]),+     ("[Pred] (aka Cxt)",["Pred","[]"]),+     ("[Pred] (aka Cxt, field Type.ForallT[2])",["Pred","[]"]),+     ("[TyVarBndr]",["TyVarBndr","[]"]),+     ("[TyVarBndr] (field Type.ForallT[1])",["TyVarBndr","[]"]),+     ("[Type]",["[]","Type (aka Kind)"]),+     ("[Type] (field Pred.ClassP[2])",["[]","Type (aka Kind)"]),+     ("[]",[])+#endif+    ]++arity0TypeEdges :: Set (String, [String])+arity0TypeEdges =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+     ("BigNat",["ByteArray#"]),+     ("ByteArray#",[]),+     ("Char",["Char#"]),+     ("Char#",[]),+     ("Int",["Int#"]),+     ("Int#",[]),+     ("Integer",["Int#","BigNat"]),+     ("ModName",["[Char] (aka String)"]),+     ("Name",["NameFlavour","OccName"]),+     ("NameFlavour",["Int","ModName","NameSpace","PkgName"]),+     ("NameSpace",[]),+     ("OccName",["[Char] (aka String)"]),+     ("PkgName",["[Char] (aka String)"]),+     ("TyLit",["Integer","[Char] (aka String)"]),+     ("TyVarBndr",["Name","Type (aka Kind, aka Pred)"]),+     ("Type (aka Kind, aka Pred)",["[TyVarBndr]","Int","Name","TyLit","[Type] (aka Cxt)"]),+     ("[Char] (aka String)",["Char"]),+     ("[TyVarBndr]",["TyVarBndr"]),+     ("[Type] (aka Cxt)",["Type (aka Kind, aka Pred)"])+#else+     ("ByteArray#",[]),+     ("Char",["Char#"]),+     ("Char#",[]),+     ("Int",["Int#"]),+     ("Int#",[]),+     ("Integer",["ByteArray#","Int#"]),+     ("ModName",["[Char] (aka String)"]),+     ("Name",["NameFlavour","OccName"]),+     ("NameFlavour",["Int#","ModName","NameSpace","PkgName"]),+     ("NameSpace",[]),+     ("OccName",["[Char] (aka String)"]),+     ("PkgName",["[Char] (aka String)"]),+     ("Pred",["[Type]","Name","Type (aka Kind)"]),+     ("TyLit",["Integer","[Char] (aka String)"]),+     ("TyVarBndr",["Name","Type (aka Kind)"]),+     ("Type (aka Kind)",["[TyVarBndr]","Int","Name","TyLit","[Pred] (aka Cxt)"]),+     ("[Char] (aka String)",["Char"]),+     ("[Pred] (aka Cxt)",["Pred"]),+     ("[TyVarBndr]",["TyVarBndr"]),+     ("[Type]",["Type (aka Kind)"])+#endif+    ]++arity0TypeEdges' :: Set (String, [String])+arity0TypeEdges' =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+#else+     ("ByteArray#",[]),+     ("Char",[]),+     ("Char#",[]),+     ("Int",[]),+     ("Int#",[]),+     ("Integer",[]),+     ("ModName",["Char","[]","[Char] (aka String)"]),+     ("Name",["Int#","ModName","NameSpace","PkgName","[Char] (aka String)"]),+     ("NameFlavour",["[Char] (aka String)"]),+     ("NameSpace",[]),+     ("OccName",["Char","[]","[Char] (aka String)"]),+     ("PkgName",["Char","[]","[Char] (aka String)"]),+     ("Pred",["[TyVarBndr]","Int","Name","NameFlavour","OccName","TyLit","[]","[Pred] (aka Cxt)","Type (aka Kind)"]),+     ("TyLit",["ByteArray#","Int#","Char","[]","[Char] (aka String)"]),+     ("TyVarBndr",["[TyVarBndr]","Int","Name","NameFlavour","OccName","TyLit","[Pred] (aka Cxt)","Type (aka Kind)"]),+     ("Type (aka Kind)",["[TyVarBndr]","Int#","Int","Integer","Name","NameFlavour","OccName","Pred","TyLit","TyVarBndr","[]","[Char] (aka String)","[Pred] (aka Cxt)","Type (aka Kind)"]),+     ("[Char] (aka String)",["Char#","Char","[]","[Char] (aka String)"]),+     ("[Pred] (aka Cxt)",["[Type]","Name","Pred","[]","[Pred] (aka Cxt)","Type (aka Kind)"]),+     ("[TyVarBndr]",["Name","[]","Type (aka Kind)"]),+     ("[Type]",["[TyVarBndr]","Int","Name","TyLit","[]","[Pred] (aka Cxt)","Type (aka Kind)"])+#endif+    ]++decEdges :: Set (String, [String])+decEdges =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+     ("(,)",[]),+     ("(,) Guard",["Guard","(,)"]),+     ("(,) Name",["Name","(,)"]),+     ("(,) Strict",["Strict","(,)"]),+     ("(,,)",[]),+     ("(,,) Name",["Name","(,,)"]),+     ("(,,) Name Strict",["(,,) Name","Strict"]),+     ("(Guard, Exp)",["(,) Guard","Exp"]),+     ("(Name, Exp) (aka FieldExp)",["(,) Name","Exp"]),+     ("(Name, Pat) (aka FieldPat)",["(,) Name","Pat"]),+     ("(Name, Strict, Type) (aka VarStrictType)",["(,,) Name Strict","Type (aka Kind, aka Pred)"]),+     ("(Strict, Type) (aka StrictType)",["(,) Strict","Type (aka Kind, aka Pred)"]),+     ("AnnTarget",["Name"]),+     ("BigNat",["ByteArray#"]),+     ("Body",["[(Guard, Exp)]","Exp"]),+     ("ByteArray#",[]),+     ("Callconv",[]),+     ("Char",["Char#"]),+     ("Char#",[]),+     ("Clause",["[Dec]","[Pat]","Body"]),+     ("Con",["[(Name, Strict, Type)]","[(Strict, Type)]","[TyVarBndr]","Name","[Type] (aka Cxt)","(Strict, Type) (aka StrictType)"]),+     ("Dec",["Maybe Type","[Clause]","[Con]","[Dec]","[FunDep]","[Name]","[Role]","[TySynEqn]","[TyVarBndr]","Body","Con","FamFlavour","Fixity","Foreign","Name","Pat","Pragma","TySynEqn","[Type] (aka Cxt)","Type (aka Kind, aka Pred)"]),+     ("Exp",["Maybe Exp","[(Guard, Exp)]","[(Name, Exp)]","[Dec]","[Exp]","[Match]","[Pat]","[Stmt]","Lit","Name","Range","Type (aka Kind, aka Pred)"]),+     ("FamFlavour",[]),+     ("Fixity",["Int","FixityDirection"]),+     ("FixityDirection",[]),+     ("Foreign",["Callconv","Name","Safety","[Char] (aka String)","Type (aka Kind, aka Pred)"]),+     ("FunDep",["[Name]"]),+     ("Guard",["[Stmt]","Exp"]),+     ("Inline",[]),+     ("Int",["Int#"]),+     ("Int#",[]),+     ("Integer",["Int#","BigNat"]),+     ("Lit",["[Word8]","Char","Integer","[Char] (aka String)","Ratio Integer (aka Rational)"]),+     ("Match",["[Dec]","Body","Pat"]),+     ("Maybe",["a"]),+     ("Maybe Exp",["Maybe","Exp"]),+     ("Maybe Inline",["Maybe","Inline"]),+     ("Maybe Type",["Maybe","Type (aka Kind, aka Pred)"]),+     ("ModName",["[Char] (aka String)"]),+     ("Name",["NameFlavour","OccName"]),+     ("NameFlavour",["Int","ModName","NameSpace","PkgName"]),+     ("NameSpace",[]),+     ("OccName",["[Char] (aka String)"]),+     ("Pat",["[(Name, Pat)]","[Pat]","Exp","Lit","Name","Type (aka Kind, aka Pred)"]),+     ("Phases",["Int"]),+     ("PkgName",["[Char] (aka String)"]),+     ("Pragma",["Maybe Inline","[RuleBndr]","Int","AnnTarget","Exp","Inline","Name","Phases","RuleMatch","[Char] (aka String)","Type (aka Kind, aka Pred)"]),+     ("Range",["Exp"]),+     ("Ratio",["a"]),+     ("Ratio Integer (aka Rational)",["Ratio","Integer"]),+     ("Role",[]),+     ("RuleBndr",["Name","Type (aka Kind, aka Pred)"]),+     ("RuleMatch",[]),+     ("Safety",[]),+     ("Stmt",["[[Stmt]]","[Dec]","Exp","Pat"]),+     ("Strict",[]),+     ("TyLit",["Integer","[Char] (aka String)"]),+     ("TySynEqn",["[Type] (aka Cxt)","Type (aka Kind, aka Pred)"]),+     ("TyVarBndr",["Name","Type (aka Kind, aka Pred)"]),+     ("Type (aka Kind, aka Pred)",["[TyVarBndr]","Int","Name","TyLit","[Type] (aka Cxt)"]),+     ("Word#",[]),+     ("Word8",["Word#"]),+     ("[(Guard, Exp)]",["(Guard, Exp)","[]"]),+     ("[(Name, Exp)]",["[]","(Name, Exp) (aka FieldExp)"]),+     ("[(Name, Pat)]",["[]","(Name, Pat) (aka FieldPat)"]),+     ("[(Name, Strict, Type)]",["[]","(Name, Strict, Type) (aka VarStrictType)"]),+     ("[(Strict, Type)]",["[]","(Strict, Type) (aka StrictType)"]),+     ("[Char] (aka String)",["Char","[]"]),+     ("[Clause]",["Clause","[]"]),+     ("[Con]",["Con","[]"]),+     ("[Dec]",["Dec","[]"]),+     ("[Exp]",["Exp","[]"]),+     ("[FunDep]",["FunDep","[]"]),+     ("[Match]",["Match","[]"]),+     ("[Name]",["Name","[]"]),+     ("[Pat]",["Pat","[]"]),+     ("[Role]",["Role","[]"]),+     ("[RuleBndr]",["RuleBndr","[]"]),+     ("[Stmt]",["Stmt","[]"]),+     ("[TySynEqn]",["TySynEqn","[]"]),+     ("[TyVarBndr]",["TyVarBndr","[]"]),+     ("[Type] (aka Cxt)",["[]","Type (aka Kind, aka Pred)"]),+     ("[Word8]",["Word8","[]"]),+     ("[[Stmt]]",["[Stmt]","[]"]),+     ("[]",[]),+     ("a",[])+#else+     ("(,)",[]),+     ("(,) Guard",["Guard","(,)"]),+     ("(,) Name",["Name","(,)"]),+     ("(,) Strict",["Strict","(,)"]),+     ("(,,)",[]),+     ("(,,) Name",["Name","(,,)"]),+     ("(,,) Name Strict",["(,,) Name","Strict"]),+     ("(Guard, Exp)",["(,) Guard","Exp"]),+     ("(Name, Exp) (aka FieldExp)",["(,) Name","Exp"]),+     ("(Name, Pat) (aka FieldPat)",["(,) Name","Pat"]),+     ("(Name, Strict, Type) (aka VarStrictType)",["(,,) Name Strict","Type (aka Kind)"]),+     ("(Strict, Type) (aka StrictType)",["(,) Strict","Type (aka Kind)"]),+     ("AnnTarget",["Name"]),+     ("Body",["[(Guard, Exp)]","Exp"]),+     ("ByteArray#",[]),+     ("Callconv",[]),+     ("Char",["Char#"]),+     ("Char#",[]),+     ("Clause",["[Dec]","[Pat]","Body"]),+     ("Con",["[(Name, Strict, Type)]","[(Strict, Type)]","[TyVarBndr]","Name","[Pred] (aka Cxt)","(Strict, Type) (aka StrictType)"]),+     ("Dec",["Maybe Type","[Clause]","[Con]","[Dec]","[FunDep]","[Name]","[Role]","[TySynEqn]","[TyVarBndr]","[Type]","Body","Con","FamFlavour","Fixity","Foreign","Name","Pat","Pragma","TySynEqn","[Pred] (aka Cxt)","Type (aka Kind)"]),+     ("Exp",["Maybe Exp","[(Guard, Exp)]","[(Name, Exp)]","[Dec]","[Exp]","[Match]","[Pat]","[Stmt]","Lit","Name","Range","Type (aka Kind)"]),+     ("FamFlavour",[]),+     ("Fixity",["Int","FixityDirection"]),+     ("FixityDirection",[]),+     ("Foreign",["Callconv","Name","Safety","[Char] (aka String)","Type (aka Kind)"]),+     ("FunDep",["[Name]"]),+     ("Guard",["[Stmt]","Exp"]),+     ("Inline",[]),+     ("Int",["Int#"]),+     ("Int#",[]),+     ("Integer",["ByteArray#","Int#"]),+     ("Lit",["[Word8]","Char","Integer","[Char] (aka String)","Ratio Integer (aka Rational)"]),+     ("Match",["[Dec]","Body","Pat"]),+     ("Maybe",["a"]),+     ("Maybe Exp",["Maybe","Exp"]),+     ("Maybe Inline",["Maybe","Inline"]),+     ("Maybe Type",["Maybe","Type (aka Kind)"]),+     ("ModName",["[Char] (aka String)"]),+     ("Name",["NameFlavour","OccName"]),+     ("NameFlavour",["Int#","ModName","NameSpace","PkgName"]),+     ("NameSpace",[]),+     ("OccName",["[Char] (aka String)"]),+     ("Pat",["[(Name, Pat)]","[Pat]","Exp","Lit","Name","Type (aka Kind)"]),+     ("Phases",["Int"]),+     ("PkgName",["[Char] (aka String)"]),+     ("Pragma",["Maybe Inline","[RuleBndr]","AnnTarget","Exp","Inline","Name","Phases","RuleMatch","[Char] (aka String)","Type (aka Kind)"]),+     ("Pred",["[Type]","Name","Type (aka Kind)"]),+     ("Range",["Exp"]),+     ("Ratio",["a"]),+     ("Ratio Integer (aka Rational)",["Ratio","Integer"]),+     ("Role",[]),+     ("RuleBndr",["Name","Type (aka Kind)"]),+     ("RuleMatch",[]),+     ("Safety",[]),+     ("Stmt",["[[Stmt]]","[Dec]","Exp","Pat"]),+     ("Strict",[]),+     ("TyLit",["Integer","[Char] (aka String)"]),+     ("TySynEqn",["[Type]","Type (aka Kind)"]),+     ("TyVarBndr",["Name","Type (aka Kind)"]),+     ("Type (aka Kind)",["[TyVarBndr]","Int","Name","TyLit","[Pred] (aka Cxt)"]),+     ("Word#",[]),+     ("Word8",["Word#"]),+     ("[(Guard, Exp)]",["(Guard, Exp)","[]"]),+     ("[(Name, Exp)]",["[]","(Name, Exp) (aka FieldExp)"]),+     ("[(Name, Pat)]",["[]","(Name, Pat) (aka FieldPat)"]),+     ("[(Name, Strict, Type)]",["[]","(Name, Strict, Type) (aka VarStrictType)"]),+     ("[(Strict, Type)]",["[]","(Strict, Type) (aka StrictType)"]),+     ("[Char] (aka String)",["Char","[]"]),+     ("[Clause]",["Clause","[]"]),+     ("[Con]",["Con","[]"]),+     ("[Dec]",["Dec","[]"]),+     ("[Exp]",["Exp","[]"]),+     ("[FunDep]",["FunDep","[]"]),+     ("[Match]",["Match","[]"]),+     ("[Name]",["Name","[]"]),+     ("[Pat]",["Pat","[]"]),+     ("[Pred] (aka Cxt)",["Pred","[]"]),+     ("[Role]",["Role","[]"]),+     ("[RuleBndr]",["RuleBndr","[]"]),+     ("[Stmt]",["Stmt","[]"]),+     ("[TySynEqn]",["TySynEqn","[]"]),+     ("[TyVarBndr]",["TyVarBndr","[]"]),+     ("[Type]",["[]","Type (aka Kind)"]),+     ("[Word8]",["Word8","[]"]),+     ("[[Stmt]]",["[Stmt]","[]"]),+     ("[]",[]),+     ("a",[])+#endif+    ]++arity0DecEdges :: Set (String, [String])+arity0DecEdges =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+     ("(Guard, Exp)",["Exp","Guard"]),+     ("(Name, Exp) (aka FieldExp)",["Exp","Name"]),+     ("(Name, Pat) (aka FieldPat)",["Name","Pat"]),+     ("(Name, Strict, Type) (aka VarStrictType)",["Name","Strict","Type (aka Kind, aka Pred)"]),+     ("(Strict, Type) (aka StrictType)",["Strict","Type (aka Kind, aka Pred)"]),+     ("AnnTarget",["Name"]),+     ("BigNat",["ByteArray#"]),+     ("Body",["[(Guard, Exp)]","Exp"]),+     ("ByteArray#",[]),+     ("Callconv",[]),+     ("Char",["Char#"]),+     ("Char#",[]),+     ("Clause",["[Dec]","[Pat]","Body"]),+     ("Con",["[(Name, Strict, Type)]","[(Strict, Type)]","[TyVarBndr]","Name","[Type] (aka Cxt)","(Strict, Type) (aka StrictType)"]),+     ("Dec",["Maybe Type","[Clause]","[Con]","[Dec]","[FunDep]","[Name]","[Role]","[TySynEqn]","[TyVarBndr]","Body","Con","FamFlavour","Fixity","Foreign","Name","Pat","Pragma","TySynEqn","[Type] (aka Cxt)","Type (aka Kind, aka Pred)"]),+     ("Exp",["Maybe Exp","[(Guard, Exp)]","[(Name, Exp)]","[Dec]","[Exp]","[Match]","[Pat]","[Stmt]","Lit","Name","Range","Type (aka Kind, aka Pred)"]),+     ("FamFlavour",[]),+     ("Fixity",["Int","FixityDirection"]),+     ("FixityDirection",[]),+     ("Foreign",["Callconv","Name","Safety","[Char] (aka String)","Type (aka Kind, aka Pred)"]),+     ("FunDep",["[Name]"]),+     ("Guard",["[Stmt]","Exp"]),+     ("Inline",[]),+     ("Int",["Int#"]),+     ("Int#",[]),+     ("Integer",["Int#","BigNat"]),+     ("Lit",["[Word8]","Char","Integer","[Char] (aka String)","Ratio Integer (aka Rational)"]),+     ("Match",["[Dec]","Body","Pat"]),+     ("Maybe Exp",["Exp"]),+     ("Maybe Inline",["Inline"]),+     ("Maybe Type",["Type (aka Kind, aka Pred)"]),+     ("ModName",["[Char] (aka String)"]),+     ("Name",["NameFlavour","OccName"]),+     ("NameFlavour",["Int","ModName","NameSpace","PkgName"]),+     ("NameSpace",[]),+     ("OccName",["[Char] (aka String)"]),+     ("Pat",["[(Name, Pat)]","[Pat]","Exp","Lit","Name","Type (aka Kind, aka Pred)"]),+     ("Phases",["Int"]),+     ("PkgName",["[Char] (aka String)"]),+     ("Pragma",["Maybe Inline","[RuleBndr]","Int","AnnTarget","Exp","Inline","Name","Phases","RuleMatch","[Char] (aka String)","Type (aka Kind, aka Pred)"]),+     ("Range",["Exp"]),+     ("Ratio Integer (aka Rational)",["Integer"]),+     ("Role",[]),+     ("RuleBndr",["Name","Type (aka Kind, aka Pred)"]),+     ("RuleMatch",[]),+     ("Safety",[]),+     ("Stmt",["[[Stmt]]","[Dec]","Exp","Pat"]),+     ("Strict",[]),+     ("TyLit",["Integer","[Char] (aka String)"]),+     ("TySynEqn",["[Type] (aka Cxt)","Type (aka Kind, aka Pred)"]),+     ("TyVarBndr",["Name","Type (aka Kind, aka Pred)"]),+     ("Type (aka Kind, aka Pred)",["[TyVarBndr]","Int","Name","TyLit","[Type] (aka Cxt)"]),+     ("Word#",[]),+     ("Word8",["Word#"]),+     ("[(Guard, Exp)]",["(Guard, Exp)"]),+     ("[(Name, Exp)]",["(Name, Exp) (aka FieldExp)"]),+     ("[(Name, Pat)]",["(Name, Pat) (aka FieldPat)"]),+     ("[(Name, Strict, Type)]",["(Name, Strict, Type) (aka VarStrictType)"]),+     ("[(Strict, Type)]",["(Strict, Type) (aka StrictType)"]),+     ("[Char] (aka String)",["Char"]),+     ("[Clause]",["Clause"]),+     ("[Con]",["Con"]),+     ("[Dec]",["Dec"]),+     ("[Exp]",["Exp"]),+     ("[FunDep]",["FunDep"]),+     ("[Match]",["Match"]),+     ("[Name]",["Name"]),+     ("[Pat]",["Pat"]),+     ("[Role]",["Role"]),+     ("[RuleBndr]",["RuleBndr"]),+     ("[Stmt]",["Stmt"]),+     ("[TySynEqn]",["TySynEqn"]),+     ("[TyVarBndr]",["TyVarBndr"]),+     ("[Type] (aka Cxt)",["Type (aka Kind, aka Pred)"]),+     ("[Word8]",["Word8"]),+     ("[[Stmt]]",["[Stmt]"])+#else+     ("(Guard, Exp)",["Exp","Guard"]),+     ("(Name, Exp) (aka FieldExp)",["Exp","Name"]),+     ("(Name, Pat) (aka FieldPat)",["Name","Pat"]),+     ("(Name, Strict, Type) (aka VarStrictType)",["Name","Strict","Type (aka Kind)"]),+     ("(Strict, Type) (aka StrictType)",["Strict","Type (aka Kind)"]),+     ("AnnTarget",["Name"]),+     ("Body",["[(Guard, Exp)]","Exp"]),+     ("ByteArray#",[]),+     ("Callconv",[]),+     ("Char",["Char#"]),+     ("Char#",[]),+     ("Clause",["[Dec]","[Pat]","Body"]),+     ("Con",["[(Name, Strict, Type)]","[(Strict, Type)]","[TyVarBndr]","Name","[Pred] (aka Cxt)","(Strict, Type) (aka StrictType)"]),+     ("Dec",["Maybe Type","[Clause]","[Con]","[Dec]","[FunDep]","[Name]","[Role]","[TySynEqn]","[TyVarBndr]","[Type]","Body","Con","FamFlavour","Fixity","Foreign","Name","Pat","Pragma","TySynEqn","[Pred] (aka Cxt)","Type (aka Kind)"]),+     ("Exp",["Maybe Exp","[(Guard, Exp)]","[(Name, Exp)]","[Dec]","[Exp]","[Match]","[Pat]","[Stmt]","Lit","Name","Range","Type (aka Kind)"]),+     ("FamFlavour",[]),+     ("Fixity",["Int","FixityDirection"]),+     ("FixityDirection",[]),+     ("Foreign",["Callconv","Name","Safety","[Char] (aka String)","Type (aka Kind)"]),+     ("FunDep",["[Name]"]),+     ("Guard",["[Stmt]","Exp"]),+     ("Inline",[]),+     ("Int",["Int#"]),+     ("Int#",[]),+     ("Integer",["ByteArray#","Int#"]),+     ("Lit",["[Word8]","Char","Integer","[Char] (aka String)","Ratio Integer (aka Rational)"]),+     ("Match",["[Dec]","Body","Pat"]),+     ("Maybe Exp",["Exp"]),+     ("Maybe Inline",["Inline"]),+     ("Maybe Type",["Type (aka Kind)"]),+     ("ModName",["[Char] (aka String)"]),+     ("Name",["NameFlavour","OccName"]),+     ("NameFlavour",["Int#","ModName","NameSpace","PkgName"]),+     ("NameSpace",[]),+     ("OccName",["[Char] (aka String)"]),+     ("Pat",["[(Name, Pat)]","[Pat]","Exp","Lit","Name","Type (aka Kind)"]),+     ("Phases",["Int"]),+     ("PkgName",["[Char] (aka String)"]),+     ("Pragma",["Maybe Inline","[RuleBndr]","AnnTarget","Exp","Inline","Name","Phases","RuleMatch","[Char] (aka String)","Type (aka Kind)"]),+     ("Pred",["[Type]","Name","Type (aka Kind)"]),+     ("Range",["Exp"]),+     ("Ratio Integer (aka Rational)",["Integer"]),+     ("Role",[]),+     ("RuleBndr",["Name","Type (aka Kind)"]),+     ("RuleMatch",[]),+     ("Safety",[]),+     ("Stmt",["[[Stmt]]","[Dec]","Exp","Pat"]),+     ("Strict",[]),+     ("TyLit",["Integer","[Char] (aka String)"]),+     ("TySynEqn",["[Type]","Type (aka Kind)"]),+     ("TyVarBndr",["Name","Type (aka Kind)"]),+     ("Type (aka Kind)",["[TyVarBndr]","Int","Name","TyLit","[Pred] (aka Cxt)"]),+     ("Word#",[]),+     ("Word8",["Word#"]),+     ("[(Guard, Exp)]",["(Guard, Exp)"]),+     ("[(Name, Exp)]",["(Name, Exp) (aka FieldExp)"]),+     ("[(Name, Pat)]",["(Name, Pat) (aka FieldPat)"]),+     ("[(Name, Strict, Type)]",["(Name, Strict, Type) (aka VarStrictType)"]),+     ("[(Strict, Type)]",["(Strict, Type) (aka StrictType)"]),+     ("[Char] (aka String)",["Char"]),+     ("[Clause]",["Clause"]),+     ("[Con]",["Con"]),+     ("[Dec]",["Dec"]),+     ("[Exp]",["Exp"]),+     ("[FunDep]",["FunDep"]),+     ("[Match]",["Match"]),+     ("[Name]",["Name"]),+     ("[Pat]",["Pat"]),+     ("[Pred] (aka Cxt)",["Pred"]),+     ("[Role]",["Role"]),+     ("[RuleBndr]",["RuleBndr"]),+     ("[Stmt]",["Stmt"]),+     ("[TySynEqn]",["TySynEqn"]),+     ("[TyVarBndr]",["TyVarBndr"]),+     ("[Type]",["Type (aka Kind)"]),+     ("[Word8]",["Word8"]),+     ("[[Stmt]]",["[Stmt]"])+#endif+    ]++arity0SubtypesOfDec :: Set String+arity0SubtypesOfDec =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+     "(Guard, Exp)","(Name, Exp) (aka FieldExp)","(Name, Pat) (aka FieldPat)","(Name, Strict, Type) (aka VarStrictType)","(Strict, Type) (aka StrictType)","AnnTarget","BigNat","Body","ByteArray#","Callconv","Char","Char#","Clause","Con","Dec","Exp","FamFlavour","Fixity","FixityDirection","Foreign","FunDep","Guard","Inline","Int","Int#","Integer","Lit","Match","Maybe Exp","Maybe Inline","Maybe Type","ModName","Name","NameFlavour","NameSpace","OccName","Pat","Phases","PkgName","Pragma","Range","Ratio Integer (aka Rational)","Role","RuleBndr","RuleMatch","Safety","Stmt","Strict","TyLit","TySynEqn","TyVarBndr","Type (aka Kind, aka Pred)","Word#","Word8","[(Guard, Exp)]","[(Name, Exp)]","[(Name, Pat)]","[(Name, Strict, Type)]","[(Strict, Type)]","[Char] (aka String)","[Clause]","[Con]","[Dec]","[Exp]","[FunDep]","[Match]","[Name]","[Pat]","[Role]","[RuleBndr]","[Stmt]","[TySynEqn]","[TyVarBndr]","[Type] (aka Cxt)","[Word8]","[[Stmt]]"+#else+     "(Guard, Exp)","(Name, Exp) (aka FieldExp)","(Name, Pat) (aka FieldPat)","(Name, Strict, Type) (aka VarStrictType)","(Strict, Type) (aka StrictType)","AnnTarget","Body","ByteArray#","Callconv","Char","Char#","Clause","Con","Dec","Exp","FamFlavour","Fixity","FixityDirection","Foreign","FunDep","Guard","Inline","Int","Int#","Integer","Lit","Match","Maybe Exp","Maybe Inline","Maybe Type","ModName","Name","NameFlavour","NameSpace","OccName","Pat","Phases","PkgName","Pragma","Pred","Range","Ratio Integer (aka Rational)","Role","RuleBndr","RuleMatch","Safety","Stmt","Strict","TyLit","TySynEqn","TyVarBndr","Type (aka Kind)","Word#","Word8","[(Guard, Exp)]","[(Name, Exp)]","[(Name, Pat)]","[(Name, Strict, Type)]","[(Strict, Type)]","[Char] (aka String)","[Clause]","[Con]","[Dec]","[Exp]","[FunDep]","[Match]","[Name]","[Pat]","[Pred] (aka Cxt)","[Role]","[RuleBndr]","[Stmt]","[TySynEqn]","[TyVarBndr]","[Type]","[Word8]","[[Stmt]]"+#endif+    ]++subtypesOfDec :: Set String+subtypesOfDec =+    union+       arity0SubtypesOfDec+       (Set.fromList+           [ "(,)"+           , "(,) Guard"+           , "(,) Name"+           , "(,) Strict"+           , "(,,)"+           , "(,,) Name"+           , "(,,) Name Strict"+           , "Maybe"+           , "Ratio"+           , "[]"+           , "a"+           ])++simpleSubtypesOfDec :: Set String+simpleSubtypesOfDec =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+              "BigNat",+              "Type (aka Kind, aka Pred)",+              "[Type] (aka Cxt)",+#else+              "Pred",+              "[Pred] (aka Cxt)",+              "Type (aka Kind)",+              "[Type]",+#endif+              "(,)",+              "(,) Guard",+              "(,) Name",+              "(,) Strict",+              "(,,)",+              "(,,) Name",+              "(,,) Name Strict",+              "(Guard, Exp)",+              "(Name, Exp) (aka FieldExp)",+              "(Name, Pat) (aka FieldPat)",+              "(Name, Strict, Type) (aka VarStrictType)",+              "(Strict, Type) (aka StrictType)",+              "AnnTarget",+              "Body",+              "ByteArray#",+              "Callconv",+              "Char",+              "Char#",+              "Clause",+              "Con",+              "Dec",+              "Exp",+              "FamFlavour",+              "Fixity",+              "FixityDirection",+              "Foreign",+              "FunDep",+              "Guard",+              "Inline",+              "Int",+              "Int#",+              "Integer",+              "Lit",+              "Match",+              "Maybe",+              "Maybe Exp",+              "Maybe Inline",+              "Maybe Type",+              "ModName",+              "Name",+              "NameFlavour",+              "NameSpace",+              "OccName",+              "Pat",+              "Phases",+              "PkgName",+              "Pragma",+              "Range",+              "Ratio",+              "Ratio Integer (aka Rational)",+              "Role",+              "RuleBndr",+              "RuleMatch",+              "Safety",+              "Stmt",+              "Strict",+              "TyLit",+              "TySynEqn",+              "TyVarBndr",+              "Word#",+              "Word8",+              "[(Guard, Exp)]",+              "[(Name, Exp)]",+              "[(Name, Pat)]",+              "[(Name, Strict, Type)]",+              "[(Strict, Type)]",+              "[Char] (aka String)",+              "[Clause]",+              "[Con]",+              "[Dec]",+              "[Exp]",+              "[FunDep]",+              "[Match]",+              "[Name]",+              "[Pat]",+              "[Role]",+              "[RuleBndr]",+              "[Stmt]",+              "[TySynEqn]",+              "[TyVarBndr]",+              "[Word8]",+              "[[Stmt]]",+              "[]",+              "a"+    ]++bitsInstances :: Set String+bitsInstances =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+      "instance Bits CChar","instance Bits CInt","instance Bits CIntMax","instance Bits CIntPtr","instance Bits CLLong","instance Bits CLong","instance Bits CPtrdiff","instance Bits CSChar","instance Bits CShort","instance Bits CSigAtomic","instance Bits CSize","instance Bits CUChar","instance Bits CUInt","instance Bits CUIntMax","instance Bits CUIntPtr","instance Bits CULLong","instance Bits CULong","instance Bits CUShort","instance Bits CWchar",+#endif+      "instance Bits Bool","instance Bits Int","instance Bits Integer","instance Bits Word","instance Bits Word16","instance Bits Word32","instance Bits Word64","instance Bits Word8",+      -- These come and go depending on the version of something.+      "instance Bits Int16","instance Bits Int32","instance Bits Int64","instance Bits Int8","instance Bits Natural"+    ]++enumInstances :: Set String+enumInstances =+  Set.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+      "instance Enum (Fixed a)","instance Enum (Proxy s)","instance Enum (f a) => Enum (Alt f a)","instance Enum CChar","instance Enum CClock","instance Enum CDouble","instance Enum CFloat","instance Enum CInt","instance Enum CIntMax","instance Enum CIntPtr","instance Enum CLLong","instance Enum CLong","instance Enum CPtrdiff","instance Enum CSChar","instance Enum CSUSeconds","instance Enum CShort","instance Enum CSigAtomic","instance Enum CSize","instance Enum CTime","instance Enum CUChar","instance Enum CUInt","instance Enum CUIntMax","instance Enum CUIntPtr","instance Enum CULLong","instance Enum CULong","instance Enum CUSeconds","instance Enum CUShort","instance Enum CWchar","instance Enum Day","instance Enum NominalDiffTime",+#endif+      "instance Enum ()","instance Enum Bool","instance Enum Char","instance Enum Double","instance Enum Float","instance Enum Int","instance Enum Int16","instance Enum Int32","instance Enum Int64","instance Enum Int8","instance Enum Integer","instance Enum Natural","instance Enum Ordering","instance Enum Word","instance Enum Word16","instance Enum Word32","instance Enum Word64","instance Enum Word8","instance Integral a => Enum (Ratio a)"+    ]++arrayInstances :: Set String+arrayInstances =+  Set.fromList+    ["instance IArray UArray (FunPtr a)","instance IArray UArray (Ptr a)","instance IArray UArray (StablePtr a)","instance IArray UArray Bool","instance IArray UArray Char","instance IArray UArray Double","instance IArray UArray Float","instance IArray UArray Int","instance IArray UArray Int16","instance IArray UArray Int32","instance IArray UArray Int64","instance IArray UArray Int8","instance IArray UArray Word","instance IArray UArray Word16","instance IArray UArray Word32","instance IArray UArray Word64","instance IArray UArray Word8"]++decTypeSynonyms :: Map (E Type) (Set Name)+decTypeSynonyms =+  Map.fromList+    [+#if MIN_VERSION_template_haskell(2,10,0)+     (E (AppT (AppT (AppT (TupleT 3) (ConT ''Name)) (ConT ''Strict)) (ConT ''Type)), Set.fromList [''VarStrictType]),+     (E (AppT (AppT (TupleT 2) (ConT ''Name)) (ConT ''Exp)),                         Set.fromList [''FieldExp]),+     (E (AppT (AppT (TupleT 2) (ConT ''Name)) (ConT ''Pat)),                         Set.fromList [''FieldPat]),+     (E (AppT (AppT (TupleT 2) (ConT ''Strict)) (ConT ''Type)),                      Set.fromList [''StrictType]),+     (E (AppT (ConT ''Ratio) (ConT ''Integer)),                                      Set.fromList [''Rational]),+     (E (AppT ListT (ConT ''Char)),                                                  Set.fromList [''String]),+     (E (AppT ListT (ConT ''Type)),                                                  Set.fromList [''Cxt]),+     (E (ConT ''Type),                                                               Set.fromList [''Kind,''Pred])+#else+     (E (AppT (AppT (AppT (TupleT 3) (ConT ''Name)) (ConT ''Strict)) (ConT ''Type)), Set.fromList [''VarStrictType]),+     (E (AppT (AppT (TupleT 2) (ConT ''Name)) (ConT ''Exp)),                         Set.fromList [''FieldExp]),+     (E (AppT (AppT (TupleT 2) (ConT ''Name)) (ConT ''Pat)),                         Set.fromList [''FieldPat]),+     (E (AppT (AppT (TupleT 2) (ConT ''Strict)) (ConT ''Type)),                      Set.fromList [''StrictType]),+     (E (AppT (ConT ''Ratio) (ConT ''Integer)),                                      Set.fromList [''Rational]),+     (E (AppT ListT (ConT ''Char)),                                                  Set.fromList [''String]),+     (E (AppT ListT (ConT ''Pred)),                                                  Set.fromList [''Cxt]),+     (E (ConT ''Type),                                                               Set.fromList [''Kind])+#endif+    ]

@@ -0,0 +1,55 @@+name:               th-typegraph+version:            0.14+cabal-version:      >= 1.10+build-type:         Simple+license:            BSD3+category:           Template Haskell+author:             David Fox+copyright:          (c) David Fox+maintainer:         David Fox <dsf@seereason.com>+homepage:           https://github.com/seereason/th-typegraph+bug-reports:        https://github.com/seereason/th-typegraph/issues+stability:          experimental+synopsis:           Graph of the subtype relation+description:        Build a graph whose nodes are Types and whose edges represent+                    the subtype relation: Char is a subtype of Maybe Char, Int is+                    a subtype of (Int, Double), and so on.+extra-source-files: test/Common.hs test/Tests.hs test/TypeGraph.hs test/Values.hs++library+  build-depends:+    base >= 4.2 && < 5,+    containers,+    data-default,+    haskell-src-exts,+    lens,+    mtl,+    syb,+    template-haskell >= 2.9,+    th-desugar,+    th-orphans >= 0.10.0+  ghc-options:      -Wall+  exposed-modules:  Language.Haskell.TH.TypeGraph+                    Language.Haskell.TH.TypeGraph.Core+                    Language.Haskell.TH.TypeGraph.Edges+                    Language.Haskell.TH.TypeGraph.Expand+                    Language.Haskell.TH.TypeGraph.Graph+                    Language.Haskell.TH.TypeGraph.Hints+                    Language.Haskell.TH.TypeGraph.Info+                    Language.Haskell.TH.TypeGraph.Monad+                    Language.Haskell.TH.TypeGraph.Unsafe+                    Language.Haskell.TH.TypeGraph.Vertex+  default-language: Haskell2010++test-suite th-typegraph-tests+  type:             exitcode-stdio-1.0+  hs-source-dirs:   test+  main-is:          Tests.hs+  build-depends:    array, base, bytestring, containers, deepseq, ghc-prim,+                    hspec, hspec-core, lens, mtl, syb, template-haskell, text,+                    th-typegraph, th-desugar, th-orphans, th-reify-many+  default-language: Haskell2010++source-repository head+  type:     git+  location: git://github.com/seereason/th-typegraph.git