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


-- | Support functions to work with type representations.
--   
--   Support functions to work with type representations, as exported from
--   <a>Type.Reflection</a>. Of particular interest is a facility to
--   translate <a>TypeRep</a>s into strings, with customizability around
--   whether the rendered strings are fully qualified.
@package type-reflection
@version 1.0


-- | Provides utilities for manipulating a <a>TypeRep</a> of compile-time
--   lists.
module Type.Reflection.List

-- | Turn a representation of a list into a list of representations.
typeRepList :: forall {k} (xs :: [k]). TypeRep xs -> NP TypeRep xs

-- | Given a representation of a list, get a representation of the kind of
--   the list's elements.
typeRepListKind :: TypeRep @[k] xs -> TypeRep k


-- | This module provides three different ways of serializing a
--   <a>TypeRep</a> into a <a>Text</a>: qualifying no names, qualifying all
--   names, or package-qualifying all names. In order to support meaningful
--   notions of equality on these string representations (for e.g. using
--   them as keys in a map), <tt>newtype</tt>s are provided for each
--   format.
module Type.Reflection.Name

-- | A rendering of a type where no components have module or package
--   qualifications. Data constructors used in types are preceded with a
--   <tt>'</tt>, and infix operator types are printed without parentheses.
--   Uses <a>defaultRenderTypeRep</a> to render types; see that function
--   for further details.
newtype Unqualified
MkUnqualified :: Text -> Unqualified

-- | Extract the contents of an <a>Unqualified</a> rendering
getUnqualified :: Unqualified -> Text

-- | Convert a <a>TypeRep</a> into an <a>Unqualified</a> representation
showUnqualified :: TypeRep t -> Unqualified

-- | A rendering of a type where all components have module qualifications.
--   Data constructors used in types are preceded first with their module
--   qualification, and then with a <tt>'</tt>, and infix operator types
--   are printed without parentheses. So we have <tt>Data.Proxy.'Proxy</tt>
--   for the <tt>Proxy</tt> constructor. Uses <a>defaultRenderTypeRep</a>
--   to render types; see that function for further details.j
--   
--   Note that module qualifications arise from the module that defines a
--   type, even if this is a hidden or internal module. This fact means
--   that internal-structure changes in your libraries may affect how your
--   types are rendered, including changes in e.g. <tt>base</tt>.
newtype Qualified
MkQualified :: Text -> Qualified

-- | Extract the contents of a <a>Qualified</a> rendering
getQualified :: Qualified -> Text

-- | Convert a <a>TypeRep</a> into a <a>Qualified</a> representation
showQualified :: TypeRep t -> Qualified

-- | A rendering of a type where all components have package and module
--   qualifications Data constructors used in types are preceded first with
--   their package qualification, and then their module qualification, and
--   then with a <tt>'</tt>, and infix operator types are printed without
--   parentheses. So we have <tt>base.Data.Proxy.'Proxy</tt> for the
--   <tt>Proxy</tt> constructor. Uses <a>defaultRenderTypeRep</a> to render
--   types; see that function for further details.
--   
--   Note that module qualifications arise from the module that defines a
--   type, even if this is a hidden or internal module. This fact means
--   that internal-structure changes in your libraries may affect how your
--   types are rendered, including changes in e.g. <tt>base</tt>.
newtype PackageQualified
MkPackageQualified :: Text -> PackageQualified

-- | Extract the contents of a <a>PackageQualified</a> name
getPackageQualified :: PackageQualified -> Text

-- | Convert a <a>TypeRep</a> into a <a>PackageQualified</a> representation
showPackageQualified :: TypeRep t -> PackageQualified

-- | The <a>TypeText</a> class describes how a <a>TyCon</a> is rendered
--   into a textual representation, and it is used to render a
--   <a>TypeRep</a> by <a>renderTypeRep</a>. The <a>IsString</a> superclass
--   is needed to insert connectives like spaces, dots, and parentheses,
--   and the <a>Monoid</a> superclass is needed to stitch these pieces
--   together.
--   
--   Only <a>renderTyCon</a> is needed for instances; if
--   <a>renderTypeRep</a> is omitted, then the default rendering, via
--   <a>defaultRenderTypeRep</a> is used. See that function for more
--   details.
--   
--   The only consistency law for <a>TypeText</a> is this, holding for all
--   <tt>tr</tt> of type <a>TypeRep</a> :
--   
--   <pre>
--   case tr of Con' tc [] -&gt; renderTypeRep tr == renderTyCon tc
--              _ -&gt; True
--   </pre>
--   
--   In other words, rendering a <a>TypeRep</a> consisting only of a
--   <a>TyCon</a> is the same as rendering the <a>TyCon</a> itself. If the
--   <a>TypeRep</a> is not a plain <a>TyCon</a> (with no kind arguments),
--   then there are no applicable laws. Note that the law uses <a>==</a>,
--   even though <a>Eq</a> is not a superclass of <a>TypeText</a>.
class (IsString tt, Monoid tt, Ord tt) => TypeText tt
renderTyCon :: TypeText tt => TyCon -> tt
renderTypeRep :: TypeText tt => TypeRep t -> tt

-- | Render a <a>TypeRep</a> into an instance of <a>TypeText</a>. This
--   follows the following rules for how to render a type:
--   
--   <ul>
--   <li>Function types are rendered infix. If a function takes another
--   function as an argument, the argument function is rendered in
--   parentheses (as required by the right-associative <tt>-&gt;</tt>
--   operator).</li>
--   <li>All other type constructors are rendered prefix, including the
--   list constructor <tt>[]</tt> and the tuple constructors e.g.
--   <tt>(,,)</tt>, along with any other type operators.</li>
--   <li>All kind arguments to type constructors are rendered, with @
--   prefixes. Any non-atomic (that is, not simply a type constructor with
--   no kind arguments) kinds are enclosed in parentheses.</li>
--   <li>Non-atomic arguments are enclosed in parentheses.</li>
--   <li>Type synonyms are always expanded. This means that we get <tt>[]
--   Char</tt>, not <tt>String</tt>, and we get <tt>TYPE ('BoxedRep
--   'Lifted)</tt>, not <tt>Type</tt>.</li>
--   </ul>
defaultRenderTypeRep :: forall tn outer_t. TypeText tn => TypeRep outer_t -> tn
instance Data.String.IsString Type.Reflection.Name.Unqualified
instance GHC.Base.Monoid Type.Reflection.Name.Unqualified
instance GHC.Base.Semigroup Type.Reflection.Name.Unqualified
instance Data.Hashable.Class.Hashable Type.Reflection.Name.Unqualified
instance GHC.Show.Show Type.Reflection.Name.Unqualified
instance GHC.Classes.Ord Type.Reflection.Name.Unqualified
instance GHC.Classes.Eq Type.Reflection.Name.Unqualified
instance Data.String.IsString Type.Reflection.Name.Qualified
instance GHC.Base.Monoid Type.Reflection.Name.Qualified
instance GHC.Base.Semigroup Type.Reflection.Name.Qualified
instance Data.Hashable.Class.Hashable Type.Reflection.Name.Qualified
instance GHC.Show.Show Type.Reflection.Name.Qualified
instance GHC.Classes.Ord Type.Reflection.Name.Qualified
instance GHC.Classes.Eq Type.Reflection.Name.Qualified
instance Data.String.IsString Type.Reflection.Name.PackageQualified
instance GHC.Base.Monoid Type.Reflection.Name.PackageQualified
instance GHC.Base.Semigroup Type.Reflection.Name.PackageQualified
instance Data.Hashable.Class.Hashable Type.Reflection.Name.PackageQualified
instance GHC.Show.Show Type.Reflection.Name.PackageQualified
instance GHC.Classes.Ord Type.Reflection.Name.PackageQualified
instance GHC.Classes.Eq Type.Reflection.Name.PackageQualified
instance Type.Reflection.Name.TypeText Type.Reflection.Name.PackageQualified
instance Type.Reflection.Name.TypeText Type.Reflection.Name.Qualified
instance Type.Reflection.Name.TypeText Type.Reflection.Name.Unqualified