-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Graph of the subtype relation
--   
--   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.
@package th-typegraph
@version 0.21

module Language.Haskell.TH.TypeGraph.Prelude

-- | Pretty print a <a>Ppr</a> value on a single line with each block of
--   white space (newlines, tabs, etc.) converted to a single space.
pprint' :: Ppr a => a -> [Char]
unlifted :: (IsUnlifted t, Quasi m) => t -> m Bool
constructorName :: Con -> Name
declarationName :: Dec -> Maybe Name
declarationType :: Dec -> Maybe Type
class HasSet a m
getSet :: HasSet a m => m (Set a)
modifySet :: HasSet a m => (Set a -> Set a) -> m ()
unReify :: Data a => a -> a
unReifyName :: Name -> Name

-- | Return a key's list of adjacent keys
adjacent' :: (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex) -> key -> [key]

-- | Return a key's list of reachable keys
reachable' :: (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex) -> key -> [key]
instance Language.Haskell.TH.Ppr.Ppr ()
instance Language.Haskell.TH.TypeGraph.Prelude.IsUnlifted Language.Haskell.TH.Syntax.Dec
instance Language.Haskell.TH.TypeGraph.Prelude.IsUnlifted Language.Haskell.TH.Syntax.Con
instance Language.Haskell.TH.TypeGraph.Prelude.IsUnlifted Language.Haskell.TH.Syntax.Type
instance Language.Haskell.TH.TypeGraph.Prelude.IsUnlifted Language.Haskell.TH.Syntax.Info
instance Language.Haskell.TH.Syntax.Lift a => Language.Haskell.TH.Syntax.Lift (Data.Set.Base.Set a)
instance (Language.Haskell.TH.Syntax.Lift a, Language.Haskell.TH.Syntax.Lift b) => Language.Haskell.TH.Syntax.Lift (Data.Map.Base.Map a b)

module Language.Haskell.TH.TypeGraph.Free

-- | Return the names of the type variables that are free in x. I.e., type
--   variables that appear in the type expression but are not bound by an
--   enclosing forall or by the type parameters of a Dec.
freeTypeVars :: (FreeTypeVars t, Quasi m) => t -> m (Set Name)

-- | Compute the arity of a type - the number of type parameters that must
--   be applied to it in order to obtain a concrete type. I'm not quite
--   sure I understand the relationship between this and
--   <a>freeTypeVars</a>.
typeArity :: Quasi m => Type -> m Int
instance Language.Haskell.TH.TypeGraph.Free.FreeTypeVars a => Language.Haskell.TH.TypeGraph.Free.FreeTypeVars [a]
instance Language.Haskell.TH.TypeGraph.Free.FreeTypeVars Language.Haskell.TH.Syntax.Type
instance Language.Haskell.TH.TypeGraph.Free.FreeTypeVars Language.Haskell.TH.Syntax.Con
instance Language.Haskell.TH.TypeGraph.Free.FreeTypeVars (Language.Haskell.TH.Syntax.Strict, Language.Haskell.TH.Syntax.Type)
instance Language.Haskell.TH.TypeGraph.Free.FreeTypeVars (Language.Haskell.TH.Syntax.Name, Language.Haskell.TH.Syntax.Strict, Language.Haskell.TH.Syntax.Type)
instance GHC.Show.Show Language.Haskell.TH.TypeGraph.Free.St


-- | The <a>Expanded</a> class helps keep track of which <a>Type</a> values
--   have been fully expanded to a canonical form. This lets us use the
--   <a>Eq</a> and <a>Ord</a> relationships on <a>Type</a> and <a>Pred</a>
--   values when reasoning about instance context. What the
--   <a>expandType</a> function does is use the function from
--   <tt>th-desugar</tt> to replace occurrences of <tt>ConT name</tt> with
--   the associated <a>Type</a> if <tt>name</tt> is a declared type synonym
--   <tt>TySynD name _ typ</tt>. For convenience, a wrapper type <a>E</a>
--   is provided, along with the <a>Expanded</a> instances <tt>E Type</tt>
--   and <tt>E Pred</tt>. Now the <a>expandType</a> and <a>expandPred</a>
--   functions can be used to return values of type <tt>E Type</tt> and
--   <tt>E Pred</tt> respectively.
--   
--   Instances <tt>Expanded Type Type</tt> and <tt>Expanded Pred Pred</tt>
--   are provided in <a>Language.Haskell.TH.Context.Unsafe</a>, for when
--   less type safety is required.
module Language.Haskell.TH.TypeGraph.Expand

-- | 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
markExpanded :: Expanded un ex => un -> ex
runExpanded' :: Expanded un ex => ex -> un
runExpanded :: Expanded a (E a) => E a -> a

-- | Apply the th-desugar expand function to a <a>Type</a> and mark it as
--   expanded.
expandType :: (DsMonad m, Expanded Type e) => Type -> m e

-- | Apply the th-desugar expand function to a <a>Pred</a> and mark it as
--   expanded. Note that the definition of <a>Pred</a> changed in
--   template-haskell-2.10.0.0.
expandPred :: (DsMonad m, Expanded Pred e) => Pred -> m e

-- | Expand a list of <a>Type</a> and build an expanded <tt>ClassP</tt>
--   <a>Pred</a>.
expandClassP :: (DsMonad m, Expanded Pred e) => Name -> [Type] -> m e

-- | A concrete type for which Expanded instances are declared below.
newtype E a
E :: a -> E a
instance GHC.Show.Show a => GHC.Show.Show (Language.Haskell.TH.TypeGraph.Expand.E a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Language.Haskell.TH.TypeGraph.Expand.E a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Haskell.TH.TypeGraph.Expand.E a)
instance Language.Haskell.TH.TypeGraph.Expand.Expanded Language.Haskell.TH.Syntax.Type (Language.Haskell.TH.TypeGraph.Expand.E Language.Haskell.TH.Syntax.Type)
instance Language.Haskell.TH.Ppr.Ppr a => Language.Haskell.TH.Ppr.Ppr (Language.Haskell.TH.TypeGraph.Expand.E a)
instance Language.Haskell.TH.Syntax.Lift (Language.Haskell.TH.TypeGraph.Expand.E Language.Haskell.TH.Syntax.Type)


-- | A fold on the shape of a record.
module Language.Haskell.TH.TypeGraph.Shape
type Field = (Name, Name, Either Int Name)
constructorFields :: Name -> Con -> [Field]
data FieldType
Positional :: Int -> StrictType -> FieldType
Named :: VarStrictType -> FieldType
constructorFieldTypes :: Con -> [FieldType]
fPos :: FieldType -> Either Int Name
fName :: FieldType -> Either Int Name
fType :: FieldType -> Type

-- | 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) -> (Con -> [FieldType] -> m r) -> ([Con] -> m r) -> (Con -> FieldType -> m r) -> [Con] -> m r
instance Data.Data.Data Language.Haskell.TH.TypeGraph.Shape.FieldType
instance GHC.Show.Show Language.Haskell.TH.TypeGraph.Shape.FieldType
instance GHC.Classes.Ord Language.Haskell.TH.TypeGraph.Shape.FieldType
instance GHC.Classes.Eq Language.Haskell.TH.TypeGraph.Shape.FieldType
instance Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.TypeGraph.Shape.Field
instance Language.Haskell.TH.Ppr.Ppr (GHC.Base.Maybe Language.Haskell.TH.TypeGraph.Shape.Field, Language.Haskell.TH.TypeGraph.Expand.E Language.Haskell.TH.Syntax.Type)
instance Language.Haskell.TH.Ppr.Ppr (GHC.Base.Maybe Language.Haskell.TH.TypeGraph.Shape.Field, Language.Haskell.TH.Syntax.Type)
instance Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.TypeGraph.Shape.FieldType

module Language.Haskell.TH.TypeGraph.Vertex
class TypeGraphVertex v

-- | Return the set of <a>Name</a> 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 v => v -> Set Name
bestType :: TypeGraphVertex v => v -> Type

-- | For simple type graphs always set _field and _synonyms to Nothing.
data TGV
TGV :: Maybe Field -> TGVSimple -> TGV

-- | The record field which contains this type
[_field] :: TGV -> Maybe Field
[_vsimple] :: TGV -> TGVSimple
field :: Lens' TGV (Maybe Field)
vsimple :: Lens' TGV TGVSimple

-- | For simple type graphs always set _field and _synonyms to Nothing.
data TGVSimple
TGVSimple :: Set Name -> E Type -> TGVSimple

-- | All the type synonyms that expand to this type
[_syns] :: TGVSimple -> Set Name

-- | The fully expanded type
[_etype] :: TGVSimple -> E Type
syns :: Lens' TGVSimple (Set Name)
etype :: Lens' TGVSimple (E Type)
simpleVertex :: TGV -> TGVSimple
instance Language.Haskell.TH.TypeGraph.Vertex.TypeGraphVertex Language.Haskell.TH.TypeGraph.Vertex.TGV
instance Language.Haskell.TH.TypeGraph.Vertex.TypeGraphVertex Language.Haskell.TH.TypeGraph.Vertex.TGVSimple
instance Language.Haskell.TH.Syntax.Lift Language.Haskell.TH.TypeGraph.Vertex.TGV
instance Language.Haskell.TH.Syntax.Lift Language.Haskell.TH.TypeGraph.Vertex.TGVSimple
instance GHC.Show.Show Language.Haskell.TH.TypeGraph.Vertex.TGV
instance GHC.Classes.Ord Language.Haskell.TH.TypeGraph.Vertex.TGV
instance GHC.Classes.Eq Language.Haskell.TH.TypeGraph.Vertex.TGV
instance GHC.Show.Show Language.Haskell.TH.TypeGraph.Vertex.TGVSimple
instance GHC.Classes.Ord Language.Haskell.TH.TypeGraph.Vertex.TGVSimple
instance GHC.Classes.Eq Language.Haskell.TH.TypeGraph.Vertex.TGVSimple
instance Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.TypeGraph.Vertex.TGVSimple
instance Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.TypeGraph.Vertex.TGV

module Language.Haskell.TH.TypeGraph.Info

-- | Information collected about the graph implied by the structure of one
--   or more <a>Type</a> values.
data TypeInfo
startTypes :: Lens' TypeInfo [Type]
fields :: Lens' TypeInfo (Map (E Type) (Set (Name, Name, Either Int Name)))
infoMap :: Lens' TypeInfo (Map Name Info)
synonyms :: Lens' TypeInfo (Map (E Type) (Set Name))
typeSet :: Lens' TypeInfo (Set Type)

-- | Build a TypeInfo value by scanning the supplied types
makeTypeInfo :: DsMonad m => [Type] -> m TypeInfo

-- | Build a vertex from the given <a>Type</a> and optional <a>Field</a>.
--   vertex :: forall m. (DsMonad m, MonadReader TypeInfo m) =&gt; Maybe
--   Field -&gt; E Type -&gt; m TypeGraphVertex vertex fld etyp = maybe
--   (typeVertex etyp) (fieldVertex etyp) fld
--   
--   Build a non-field vertex
typeVertex :: MonadReader TypeInfo m => E Type -> m TGVSimple
typeVertex' :: MonadReader TypeInfo m => E Type -> m TGV

-- | Build a vertex associated with a field
fieldVertex :: MonadReader TypeInfo m => Field -> E Type -> m TGV

-- | Find the vertices that involve a particular type - if the field is
--   specified it return s singleton, otherwise it returns a set containing
--   a vertex one for the type on its own, and one for each field
--   containing that type.
fieldVertices :: MonadReader TypeInfo m => TGVSimple -> m (Set TGV)
allVertices :: (Functor m, DsMonad m, MonadReader TypeInfo m) => Maybe Field -> E Type -> m (Set TGV)
instance Language.Haskell.TH.Syntax.Lift Language.Haskell.TH.TypeGraph.Info.TypeInfo
instance GHC.Classes.Ord Language.Haskell.TH.TypeGraph.Info.TypeInfo
instance GHC.Classes.Eq Language.Haskell.TH.TypeGraph.Info.TypeInfo
instance GHC.Show.Show Language.Haskell.TH.TypeGraph.Info.TypeInfo
instance Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.TypeGraph.Info.TypeInfo


-- | 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.
module Language.Haskell.TH.TypeGraph.Unsafe
instance Language.Haskell.TH.TypeGraph.Expand.Expanded Language.Haskell.TH.Syntax.Type Language.Haskell.TH.Syntax.Type


-- | Operations involving the edges of the graph (before it is a graph.)
module Language.Haskell.TH.TypeGraph.Edges
type GraphEdges node key = Map key (node, Set key)

-- | 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.
typeGraphEdges :: (DsMonad m, Functor m, Default node, MonadReader TypeInfo m) => m (GraphEdges node TGV)

-- | Isolate and remove matching nodes
cut :: (Eq a, Ord a) => (a -> Bool) -> GraphEdges node a -> GraphEdges node a

-- | Monadic predicate version of <a>cut</a>.
cutM :: (Functor m, Monad m, Eq a, Ord a) => (a -> m Bool) -> GraphEdges node a -> m (GraphEdges node a)
cutEdges :: (Eq a, Ord a) => (a -> a -> Bool) -> GraphEdges node a -> (GraphEdges node a)
cutEdgesM :: (Monad m, Eq a, Ord a) => (a -> a -> m Bool) -> GraphEdges node a -> m (GraphEdges node a)

-- | Remove all the in- and out-edges of matching nodes
isolate :: (Eq a, Ord a) => (a -> Bool) -> GraphEdges node a -> GraphEdges node a

-- | Monadic predicate version of <a>isolate</a>.
isolateM :: (Functor m, Monad m, Eq a, Ord a) => (a -> m Bool) -> GraphEdges node a -> m (GraphEdges node a)

-- | Replace the out set of selected nodes
link :: (Eq a, Ord a) => (a -> Maybe (Set a)) -> GraphEdges node a -> GraphEdges node a
linkM :: (Eq a, Ord a, Monad m) => (a -> m (Maybe (Set a))) -> GraphEdges node a -> m (GraphEdges node a)

-- | Remove matching nodes and extend each of their in-edges to each of
--   their out-edges.
dissolve :: (Eq a, Ord a) => (a -> Bool) -> GraphEdges node a -> GraphEdges node a

-- | Monadic predicate version of <a>dissolve</a>.
dissolveM :: (Functor m, Monad m, Eq a, Ord a) => (a -> m Bool) -> GraphEdges node a -> m (GraphEdges node a)

-- | 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 :: Monoid node => GraphEdges node TGV -> GraphEdges node TGVSimple
instance Language.Haskell.TH.Ppr.Ppr key => Language.Haskell.TH.Ppr.Ppr (Language.Haskell.TH.TypeGraph.Edges.GraphEdges node key)


-- | The HasStack monad used in MIMO to construct lenses that look deep
--   into a record type. However, it does not involve the Path type
--   mechanism, and is unaware of View instances and other things that
--   modify the type graph. Lets see how it adapts.
module Language.Haskell.TH.TypeGraph.Stack
class Monad m => HasStack m
withStack :: HasStack m => ([StackElement] -> m a) -> m a
push :: HasStack m => FieldType -> Con -> Dec -> m a -> m a

-- | The information required to extact a field value from a value. We keep
--   a stack of these as we traverse a declaration. Generally, we only need
--   the field names.
data StackElement
StackElement :: FieldType -> Con -> Dec -> StackElement
prettyStack :: [StackElement] -> String

-- | Push the stack and process the field.
foldField :: HasStack m => (FieldType -> m r) -> Dec -> Con -> FieldType -> m r
type StackT m = ReaderT [StackElement] m
execStackT :: Monad m => StackT m a -> m a

-- | Re-implementation of stack accessor in terms of stackLens
stackAccessor :: (Quasi m, HasStack m) => ExpQ -> Type -> m Exp

-- | Generate lenses to access the fields of the row types. Like
--   Control.Lens.TH.makeLenses, but makes lenses for every field, and
--   instead of removing the prefix '_' to form the lens name it adds the
--   prefix "lens" and capitalizes the first letter of the field. The only
--   reason for this function is backwards compatibility, the fields should
--   be changed so they begin with _ and the regular makeLenses should be
--   used.
makeLenses' :: [Name] -> Q [Dec]
traceIndented :: HasStack m => String -> m ()
instance Data.Data.Data Language.Haskell.TH.TypeGraph.Stack.StackElement
instance GHC.Show.Show Language.Haskell.TH.TypeGraph.Stack.StackElement
instance GHC.Classes.Eq Language.Haskell.TH.TypeGraph.Stack.StackElement
instance (Language.Haskell.TH.Syntax.Quasi m, GHC.Base.Monoid w) => Language.Haskell.TH.TypeGraph.Stack.HasStack (Control.Monad.Trans.RWS.Lazy.RWST [Language.Haskell.TH.TypeGraph.Stack.StackElement] w s m)
instance Language.Haskell.TH.TypeGraph.Stack.HasStack m => Language.Haskell.TH.TypeGraph.Stack.HasStack (Control.Monad.Trans.State.Lazy.StateT s m)
instance Language.Haskell.TH.Syntax.Quasi m => Language.Haskell.TH.TypeGraph.Stack.HasStack (Control.Monad.Trans.Reader.ReaderT [Language.Haskell.TH.TypeGraph.Stack.StackElement] m)
instance (Language.Haskell.TH.TypeGraph.Stack.HasStack m, GHC.Base.Monoid w) => Language.Haskell.TH.TypeGraph.Stack.HasStack (Control.Monad.Trans.Writer.Lazy.WriterT w m)


-- | Abstract operations on Maps containing graph edges.
module Language.Haskell.TH.TypeGraph.Graph
data TypeGraph
TypeGraph :: TypeInfo -> GraphEdges () TGV -> (Graph, Vertex -> ((), TGV, [TGV]), TGV -> Maybe Vertex) -> (Graph, Vertex -> ((), TGVSimple, [TGVSimple]), TGVSimple -> Maybe Vertex) -> [StackElement] -> TypeGraph
[_typeInfo] :: TypeGraph -> TypeInfo
[_edges] :: TypeGraph -> GraphEdges () TGV
[_graph] :: TypeGraph -> (Graph, Vertex -> ((), TGV, [TGV]), TGV -> Maybe Vertex)
[_gsimple] :: TypeGraph -> (Graph, Vertex -> ((), TGVSimple, [TGVSimple]), TGVSimple -> Maybe Vertex)
[_stack] :: TypeGraph -> [StackElement]
typeInfo :: Lens' TypeGraph TypeInfo
edges :: Lens' TypeGraph (GraphEdges () TGV)
graph :: Lens' TypeGraph (Graph, Vertex -> ((), TGV, [TGV]), TGV -> Maybe Vertex)
gsimple :: Lens' TypeGraph (Graph, Vertex -> ((), TGVSimple, [TGVSimple]), TGVSimple -> Maybe Vertex)
data TypeGraph
TypeGraph :: TypeInfo -> GraphEdges () TGV -> (Graph, Vertex -> ((), TGV, [TGV]), TGV -> Maybe Vertex) -> (Graph, Vertex -> ((), TGVSimple, [TGVSimple]), TGVSimple -> Maybe Vertex) -> [StackElement] -> TypeGraph
[_typeInfo] :: TypeGraph -> TypeInfo
[_edges] :: TypeGraph -> GraphEdges () TGV
[_graph] :: TypeGraph -> (Graph, Vertex -> ((), TGV, [TGV]), TGV -> Maybe Vertex)
[_gsimple] :: TypeGraph -> (Graph, Vertex -> ((), TGVSimple, [TGVSimple]), TGVSimple -> Maybe Vertex)
[_stack] :: TypeGraph -> [StackElement]

-- | 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 :: (Ord key) => GraphEdges node key -> (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex)
allPathKeys :: (DsMonad m, MonadReader TypeGraph m) => m (Set (TGV, TGV))
allPathStarts :: (DsMonad m, MonadReader TypeGraph m) => m (Set TGV)
reachableFrom :: (DsMonad m, MonadReader TypeGraph m) => TGV -> m (Set TGV)
reachableFromSimple :: (DsMonad m, MonadReader TypeGraph m) => TGVSimple -> m (Set TGVSimple)

-- | Can we reach the goal type from the start type in this key?
goalReachableFull :: (Functor m, DsMonad m, MonadReader TypeGraph m) => TGV -> TGV -> m Bool
goalReachableSimple :: (Functor m, DsMonad m, MonadReader TypeGraph m) => TGVSimple -> TGVSimple -> m Bool
goalReachableSimple' :: (Functor m, DsMonad m, MonadReader TypeGraph m) => TGV -> TGV -> m Bool
makeTypeGraph :: (DsMonad m) => ReaderT TypeInfo m (GraphEdges () TGV) -> TypeInfo -> m TypeGraph

-- | When a VertexStatus value is associated with a Type it describes
--   alterations in the type graph from the usual default.
data VertexStatus typ

-- | normal case
Vertex :: VertexStatus typ

-- | out degree zero - don't create any outgoing edges
Sink :: VertexStatus typ

-- | replace all outgoing edges with an edge to an alternate type
Divert :: typ -> VertexStatus typ

-- | add an extra outgoing edge to the given type
Extra :: typ -> VertexStatus typ

-- | Return the set of edges implied by the subtype relationship among a
--   set of types. This is just the nodes of the type graph. The type
--   aliases are expanded by the th-desugar package to make them suitable
--   for use as map keys.
typeGraphEdges' :: (DsMonad m, MonadReader TypeGraph m, HasSet TGV m) => (TGV -> m (Set TGV)) -> [Type] -> m (GraphEdges () TGV)

-- | Return the set of adjacent vertices according to the default type
--   graph - i.e. the one determined only by the type definitions, not by
--   any additional hinting function.
adjacent :: (MonadReader TypeGraph m, DsMonad m) => TGV -> m (Set TGV)

-- | Return the TGV associated with a particular type, with no field
--   specified.
typeGraphVertex :: (MonadReader TypeGraph m, DsMonad m) => Type -> m TGV

-- | Return the TGV associated with a particular type and field.
typeGraphVertexOfField :: (MonadReader TypeGraph m, DsMonad m) => (Name, Name, Either Int Name) -> Type -> m TGV
instance GHC.Show.Show typ => GHC.Show.Show (Language.Haskell.TH.TypeGraph.Graph.VertexStatus typ)
instance GHC.Base.Monad m => Language.Haskell.TH.TypeGraph.Stack.HasStack (Control.Monad.Trans.Reader.ReaderT Language.Haskell.TH.TypeGraph.Graph.TypeGraph m)
instance Data.Default.Class.Default (Language.Haskell.TH.TypeGraph.Graph.VertexStatus typ)
instance Language.Haskell.TH.Ppr.Ppr Data.Graph.Vertex