    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveFoldable #-}
    {-# LANGUAGE DeriveTraversable #-}
    {-# LANGUAGE DeriveFunctor #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE CPP #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Language.Haskell.Exts.Syntax
    -- Copyright   :  (c) Niklas Broberg 2004-2009,
    --                (c) The GHC Team, 1997-2000
    -- License     :  BSD-style (see the file LICENSE.txt)
    --
    -- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
    -- Stability   :  stable
    -- Portability :  portable
    --
    -- A suite of datatypes describing the (semi-concrete) abstract syntax of Haskell 98
    -- <http://www.haskell.org/onlinereport/> plus registered extensions, including:
    --
    --   * multi-parameter type classes with functional dependencies (MultiParamTypeClasses, FunctionalDependencies)
    --
    --   * parameters of type class assertions are unrestricted (FlexibleContexts)
    --
    --   * 'forall' types as universal and existential quantification (RankNTypes, ExistentialQuantification, etc)
    --
    --   * pattern guards (PatternGuards)
    --
    --   * implicit parameters (ImplicitParameters)
    --
    --   * generalised algebraic data types (GADTs)
    --
    --   * template haskell (TemplateHaskell)
    --
    --   * empty data type declarations (EmptyDataDecls)
    --
    --   * unboxed tuples (UnboxedTuples)
    --
    --   * regular patterns (RegularPatterns)
    --
    --   * HSP-style XML expressions and patterns (XmlSyntax)
    --
    -- All nodes in the syntax tree are annotated with something of a user-definable data type.
    -- When parsing, this annotation will contain information about the source location that the
    -- particular node comes from.
    --
    -----------------------------------------------------------------------------

    module Language.Haskell.Exts.Syntax (
        -- * Modules
        Module(..), ModuleHead(..), WarningText(..), ExportSpecList(..), ExportSpec(..),
        EWildcard(..),
        ImportDecl(..), ImportSpecList(..), ImportSpec(..), Assoc(..), Namespace(..),
        -- * Declarations
        Decl(..), DeclHead(..), InstRule(..), InstHead(..), Binds(..), IPBind(..), PatternSynDirection(..),
        InjectivityInfo(..), ResultSig(..),
        -- ** Type classes and instances
        ClassDecl(..), InstDecl(..), Deriving(..), DerivStrategy(..),
        -- ** Data type declarations
        DataOrNew(..), ConDecl(..), FieldDecl(..), QualConDecl(..), GadtDecl(..), BangType(..),
        Unpackedness(..),
        -- ** Function bindings
        Match(..), Rhs(..), GuardedRhs(..),
        -- * Class Assertions and Contexts
        Context(..), FunDep(..), Asst(..),
        -- * Types
        Type(..), Boxed(..), Kind, TyVarBind(..), Promoted(..),
        TypeEqn (..),
        -- * Expressions
        Exp(..), Stmt(..), QualStmt(..), FieldUpdate(..),
        Alt(..), XAttr(..),
        -- * Patterns
        Pat(..), PatField(..), PXAttr(..), RPat(..), RPatOp(..),
        -- * Literals
        Literal(..), Sign(..),
        -- * Variables, Constructors and Operators
        ModuleName(..), QName(..), Name(..), QOp(..), Op(..),
        SpecialCon(..), CName(..), IPName(..), XName(..), Role(..),
        MaybePromotedName(..),

        -- * Template Haskell
        Bracket(..), Splice(..),

        -- * FFI
        Safety(..), CallConv(..),

        -- * Pragmas
        ModulePragma(..), Tool(..), Overlap(..),
        Rule(..), RuleVar(..), Activation(..),
        Annotation(..), BooleanFormula(..),

        -- * Builtin names

        -- ** Modules
        prelude_mod, main_mod,
        -- ** Main function of a program
        main_name,
        -- ** Constructors
        unit_con_name, tuple_con_name, list_con_name, list_cons_name, unboxed_singleton_con_name,
        unit_con, tuple_con, unboxed_singleton_con,
        -- ** Special identifiers
        as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name,
        export_name, safe_name, unsafe_name, interruptible_name, threadsafe_name,
        stdcall_name, ccall_name, cplusplus_name, dotnet_name, jvm_name, js_name,
        javascript_name, capi_name, forall_name, family_name, role_name, hole_name,
        stock_name, anyclass_name, via_name,
        -- ** Type constructors
        unit_tycon_name, fun_tycon_name, list_tycon_name, tuple_tycon_name, unboxed_singleton_tycon_name,
        unit_tycon, fun_tycon, list_tycon, tuple_tycon, unboxed_singleton_tycon,

        -- * Source coordinates
        -- SrcLoc(..),

        -- * Annotated trees
        Annotated(..), (=~=),
      ) where

    import Prelude hiding (id)

    import Data.Data
    import GHC.Generics (Generic)
    #if __GLASGOW_HASKELL__ < 710
    import Data.Foldable (Foldable)
    import Data.Traversable (Traversable)
    #endif

    -- | The name of a Haskell module.
    data ModuleName l = ModuleName l String
      deriving (ModuleName l -> ModuleName l -> Bool
    (ModuleName l -> ModuleName l -> Bool)
    -> (ModuleName l -> ModuleName l -> Bool) -> Eq (ModuleName l)
    forall l. Eq l => ModuleName l -> ModuleName l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ModuleName l -> ModuleName l -> Bool
    == :: ModuleName l -> ModuleName l -> Bool
    $c/= :: forall l. Eq l => ModuleName l -> ModuleName l -> Bool
    /= :: ModuleName l -> ModuleName l -> Bool
    Eq,Eq (ModuleName l)
    Eq (ModuleName l) =>
    (ModuleName l -> ModuleName l -> Ordering)
    -> (ModuleName l -> ModuleName l -> Bool)
    -> (ModuleName l -> ModuleName l -> Bool)
    -> (ModuleName l -> ModuleName l -> Bool)
    -> (ModuleName l -> ModuleName l -> Bool)
    -> (ModuleName l -> ModuleName l -> ModuleName l)
    -> (ModuleName l -> ModuleName l -> ModuleName l)
    -> Ord (ModuleName l)
    ModuleName l -> ModuleName l -> Bool
    ModuleName l -> ModuleName l -> Ordering
    ModuleName l -> ModuleName l -> ModuleName l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ModuleName l)
    forall l. Ord l => ModuleName l -> ModuleName l -> Bool
    forall l. Ord l => ModuleName l -> ModuleName l -> Ordering
    forall l. Ord l => ModuleName l -> ModuleName l -> ModuleName l
    $ccompare :: forall l. Ord l => ModuleName l -> ModuleName l -> Ordering
    compare :: ModuleName l -> ModuleName l -> Ordering
    $c< :: forall l. Ord l => ModuleName l -> ModuleName l -> Bool
    < :: ModuleName l -> ModuleName l -> Bool
    $c<= :: forall l. Ord l => ModuleName l -> ModuleName l -> Bool
    <= :: ModuleName l -> ModuleName l -> Bool
    $c> :: forall l. Ord l => ModuleName l -> ModuleName l -> Bool
    > :: ModuleName l -> ModuleName l -> Bool
    $c>= :: forall l. Ord l => ModuleName l -> ModuleName l -> Bool
    >= :: ModuleName l -> ModuleName l -> Bool
    $cmax :: forall l. Ord l => ModuleName l -> ModuleName l -> ModuleName l
    max :: ModuleName l -> ModuleName l -> ModuleName l
    $cmin :: forall l. Ord l => ModuleName l -> ModuleName l -> ModuleName l
    min :: ModuleName l -> ModuleName l -> ModuleName l
    Ord,Int -> ModuleName l -> ShowS
    [ModuleName l] -> ShowS
    ModuleName l -> String
    (Int -> ModuleName l -> ShowS)
    -> (ModuleName l -> String)
    -> ([ModuleName l] -> ShowS)
    -> Show (ModuleName l)
    forall l. Show l => Int -> ModuleName l -> ShowS
    forall l. Show l => [ModuleName l] -> ShowS
    forall l. Show l => ModuleName l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ModuleName l -> ShowS
    showsPrec :: Int -> ModuleName l -> ShowS
    $cshow :: forall l. Show l => ModuleName l -> String
    show :: ModuleName l -> String
    $cshowList :: forall l. Show l => [ModuleName l] -> ShowS
    showList :: [ModuleName l] -> ShowS
    Show,Typeable,Typeable (ModuleName l)
    Typeable (ModuleName l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ModuleName l))
    -> (ModuleName l -> Constr)
    -> (ModuleName l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ModuleName l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ModuleName l)))
    -> ((forall b. Data b => b -> b) -> ModuleName l -> ModuleName l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ModuleName l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ModuleName l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l))
    -> Data (ModuleName l)
    ModuleName l -> Constr
    ModuleName l -> DataType
    (forall b. Data b => b -> b) -> ModuleName l -> ModuleName l
    forall l. Data l => Typeable (ModuleName l)
    forall l. Data l => ModuleName l -> Constr
    forall l. Data l => ModuleName l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ModuleName l -> ModuleName l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ModuleName l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ModuleName l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleName l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleName l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleName l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ModuleName l -> u
    forall u. (forall d. Data d => d -> u) -> ModuleName l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleName l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleName l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleName l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleName l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleName l)
    $ctoConstr :: forall l. Data l => ModuleName l -> Constr
    toConstr :: ModuleName l -> Constr
    $cdataTypeOf :: forall l. Data l => ModuleName l -> DataType
    dataTypeOf :: ModuleName l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleName l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleName l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleName l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleName l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ModuleName l -> ModuleName l
    gmapT :: (forall b. Data b => b -> b) -> ModuleName l -> ModuleName l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ModuleName l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleName l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ModuleName l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleName l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l)
    Data,(forall m. Monoid m => ModuleName m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ModuleName a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ModuleName a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ModuleName a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ModuleName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ModuleName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ModuleName a -> b)
    -> (forall a. (a -> a -> a) -> ModuleName a -> a)
    -> (forall a. (a -> a -> a) -> ModuleName a -> a)
    -> (forall a. ModuleName a -> [a])
    -> (forall a. ModuleName a -> Bool)
    -> (forall a. ModuleName a -> Int)
    -> (forall a. Eq a => a -> ModuleName a -> Bool)
    -> (forall a. Ord a => ModuleName a -> a)
    -> (forall a. Ord a => ModuleName a -> a)
    -> (forall a. Num a => ModuleName a -> a)
    -> (forall a. Num a => ModuleName a -> a)
    -> Foldable ModuleName
    forall a. Eq a => a -> ModuleName a -> Bool
    forall a. Num a => ModuleName a -> a
    forall a. Ord a => ModuleName a -> a
    forall m. Monoid m => ModuleName m -> m
    forall a. ModuleName a -> Bool
    forall a. ModuleName a -> Int
    forall a. ModuleName a -> [a]
    forall a. (a -> a -> a) -> ModuleName a -> a
    forall m a. Monoid m => (a -> m) -> ModuleName a -> m
    forall b a. (b -> a -> b) -> b -> ModuleName a -> b
    forall a b. (a -> b -> b) -> b -> ModuleName a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ModuleName m -> m
    fold :: forall m. Monoid m => ModuleName m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ModuleName a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ModuleName a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ModuleName a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ModuleName a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ModuleName a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ModuleName a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ModuleName a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ModuleName a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ModuleName a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ModuleName a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ModuleName a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ModuleName a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ModuleName a -> a
    foldr1 :: forall a. (a -> a -> a) -> ModuleName a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ModuleName a -> a
    foldl1 :: forall a. (a -> a -> a) -> ModuleName a -> a
    $ctoList :: forall a. ModuleName a -> [a]
    toList :: forall a. ModuleName a -> [a]
    $cnull :: forall a. ModuleName a -> Bool
    null :: forall a. ModuleName a -> Bool
    $clength :: forall a. ModuleName a -> Int
    length :: forall a. ModuleName a -> Int
    $celem :: forall a. Eq a => a -> ModuleName a -> Bool
    elem :: forall a. Eq a => a -> ModuleName a -> Bool
    $cmaximum :: forall a. Ord a => ModuleName a -> a
    maximum :: forall a. Ord a => ModuleName a -> a
    $cminimum :: forall a. Ord a => ModuleName a -> a
    minimum :: forall a. Ord a => ModuleName a -> a
    $csum :: forall a. Num a => ModuleName a -> a
    sum :: forall a. Num a => ModuleName a -> a
    $cproduct :: forall a. Num a => ModuleName a -> a
    product :: forall a. Num a => ModuleName a -> a
    Foldable,Functor ModuleName
    Foldable ModuleName
    (Functor ModuleName, Foldable ModuleName) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ModuleName a -> f (ModuleName b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ModuleName (f a) -> f (ModuleName a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ModuleName a -> m (ModuleName b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ModuleName (m a) -> m (ModuleName a))
    -> Traversable ModuleName
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ModuleName (m a) -> m (ModuleName a)
    forall (f :: * -> *) a.
    Applicative f =>
    ModuleName (f a) -> f (ModuleName a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModuleName a -> m (ModuleName b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModuleName a -> f (ModuleName b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModuleName a -> f (ModuleName b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModuleName a -> f (ModuleName b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ModuleName (f a) -> f (ModuleName a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ModuleName (f a) -> f (ModuleName a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModuleName a -> m (ModuleName b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModuleName a -> m (ModuleName b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ModuleName (m a) -> m (ModuleName a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ModuleName (m a) -> m (ModuleName a)
    Traversable,(forall a b. (a -> b) -> ModuleName a -> ModuleName b)
    -> (forall a b. a -> ModuleName b -> ModuleName a)
    -> Functor ModuleName
    forall a b. a -> ModuleName b -> ModuleName a
    forall a b. (a -> b) -> ModuleName a -> ModuleName b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ModuleName a -> ModuleName b
    fmap :: forall a b. (a -> b) -> ModuleName a -> ModuleName b
    $c<$ :: forall a b. a -> ModuleName b -> ModuleName a
    <$ :: forall a b. a -> ModuleName b -> ModuleName a
    Functor,(forall x. ModuleName l -> Rep (ModuleName l) x)
    -> (forall x. Rep (ModuleName l) x -> ModuleName l)
    -> Generic (ModuleName l)
    forall x. Rep (ModuleName l) x -> ModuleName l
    forall x. ModuleName l -> Rep (ModuleName l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ModuleName l) x -> ModuleName l
    forall l x. ModuleName l -> Rep (ModuleName l) x
    $cfrom :: forall l x. ModuleName l -> Rep (ModuleName l) x
    from :: forall x. ModuleName l -> Rep (ModuleName l) x
    $cto :: forall l x. Rep (ModuleName l) x -> ModuleName l
    to :: forall x. Rep (ModuleName l) x -> ModuleName l
    Generic)

    -- | Constructors with special syntax.
    -- These names are never qualified, and always refer to builtin type or
    -- data constructors.
    data SpecialCon l
        = UnitCon l             -- ^ unit type and data constructor @()@
        | ListCon l             -- ^ list type and data constructor @[]@
        | FunCon  l             -- ^ function type constructor @->@
        | TupleCon l Boxed Int  -- ^ /n/-ary tuple type and data
                                --   constructors @(,)@ etc, possibly boxed @(\#,\#)@
        | Cons l                -- ^ list data constructor @(:)@
        | UnboxedSingleCon l    -- ^ unboxed singleton tuple constructor @(\# \#)@
        | ExprHole l            -- ^ An expression hole _
      deriving (SpecialCon l -> SpecialCon l -> Bool
    (SpecialCon l -> SpecialCon l -> Bool)
    -> (SpecialCon l -> SpecialCon l -> Bool) -> Eq (SpecialCon l)
    forall l. Eq l => SpecialCon l -> SpecialCon l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => SpecialCon l -> SpecialCon l -> Bool
    == :: SpecialCon l -> SpecialCon l -> Bool
    $c/= :: forall l. Eq l => SpecialCon l -> SpecialCon l -> Bool
    /= :: SpecialCon l -> SpecialCon l -> Bool
    Eq,Eq (SpecialCon l)
    Eq (SpecialCon l) =>
    (SpecialCon l -> SpecialCon l -> Ordering)
    -> (SpecialCon l -> SpecialCon l -> Bool)
    -> (SpecialCon l -> SpecialCon l -> Bool)
    -> (SpecialCon l -> SpecialCon l -> Bool)
    -> (SpecialCon l -> SpecialCon l -> Bool)
    -> (SpecialCon l -> SpecialCon l -> SpecialCon l)
    -> (SpecialCon l -> SpecialCon l -> SpecialCon l)
    -> Ord (SpecialCon l)
    SpecialCon l -> SpecialCon l -> Bool
    SpecialCon l -> SpecialCon l -> Ordering
    SpecialCon l -> SpecialCon l -> SpecialCon l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (SpecialCon l)
    forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
    forall l. Ord l => SpecialCon l -> SpecialCon l -> Ordering
    forall l. Ord l => SpecialCon l -> SpecialCon l -> SpecialCon l
    $ccompare :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Ordering
    compare :: SpecialCon l -> SpecialCon l -> Ordering
    $c< :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
    < :: SpecialCon l -> SpecialCon l -> Bool
    $c<= :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
    <= :: SpecialCon l -> SpecialCon l -> Bool
    $c> :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
    > :: SpecialCon l -> SpecialCon l -> Bool
    $c>= :: forall l. Ord l => SpecialCon l -> SpecialCon l -> Bool
    >= :: SpecialCon l -> SpecialCon l -> Bool
    $cmax :: forall l. Ord l => SpecialCon l -> SpecialCon l -> SpecialCon l
    max :: SpecialCon l -> SpecialCon l -> SpecialCon l
    $cmin :: forall l. Ord l => SpecialCon l -> SpecialCon l -> SpecialCon l
    min :: SpecialCon l -> SpecialCon l -> SpecialCon l
    Ord,Int -> SpecialCon l -> ShowS
    [SpecialCon l] -> ShowS
    SpecialCon l -> String
    (Int -> SpecialCon l -> ShowS)
    -> (SpecialCon l -> String)
    -> ([SpecialCon l] -> ShowS)
    -> Show (SpecialCon l)
    forall l. Show l => Int -> SpecialCon l -> ShowS
    forall l. Show l => [SpecialCon l] -> ShowS
    forall l. Show l => SpecialCon l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> SpecialCon l -> ShowS
    showsPrec :: Int -> SpecialCon l -> ShowS
    $cshow :: forall l. Show l => SpecialCon l -> String
    show :: SpecialCon l -> String
    $cshowList :: forall l. Show l => [SpecialCon l] -> ShowS
    showList :: [SpecialCon l] -> ShowS
    Show,Typeable,Typeable (SpecialCon l)
    Typeable (SpecialCon l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (SpecialCon l))
    -> (SpecialCon l -> Constr)
    -> (SpecialCon l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (SpecialCon l)))
    -> ((forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> SpecialCon l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l))
    -> Data (SpecialCon l)
    SpecialCon l -> Constr
    SpecialCon l -> DataType
    (forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l
    forall l. Data l => Typeable (SpecialCon l)
    forall l. Data l => SpecialCon l -> Constr
    forall l. Data l => SpecialCon l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> SpecialCon l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SpecialCon l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SpecialCon l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u
    forall u. (forall d. Data d => d -> u) -> SpecialCon l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SpecialCon l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SpecialCon l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SpecialCon l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SpecialCon l)
    $ctoConstr :: forall l. Data l => SpecialCon l -> Constr
    toConstr :: SpecialCon l -> Constr
    $cdataTypeOf :: forall l. Data l => SpecialCon l -> DataType
    dataTypeOf :: SpecialCon l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SpecialCon l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SpecialCon l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l
    gmapT :: (forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> SpecialCon l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> SpecialCon l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l)
    Data,(forall m. Monoid m => SpecialCon m -> m)
    -> (forall m a. Monoid m => (a -> m) -> SpecialCon a -> m)
    -> (forall m a. Monoid m => (a -> m) -> SpecialCon a -> m)
    -> (forall a b. (a -> b -> b) -> b -> SpecialCon a -> b)
    -> (forall a b. (a -> b -> b) -> b -> SpecialCon a -> b)
    -> (forall b a. (b -> a -> b) -> b -> SpecialCon a -> b)
    -> (forall b a. (b -> a -> b) -> b -> SpecialCon a -> b)
    -> (forall a. (a -> a -> a) -> SpecialCon a -> a)
    -> (forall a. (a -> a -> a) -> SpecialCon a -> a)
    -> (forall a. SpecialCon a -> [a])
    -> (forall a. SpecialCon a -> Bool)
    -> (forall a. SpecialCon a -> Int)
    -> (forall a. Eq a => a -> SpecialCon a -> Bool)
    -> (forall a. Ord a => SpecialCon a -> a)
    -> (forall a. Ord a => SpecialCon a -> a)
    -> (forall a. Num a => SpecialCon a -> a)
    -> (forall a. Num a => SpecialCon a -> a)
    -> Foldable SpecialCon
    forall a. Eq a => a -> SpecialCon a -> Bool
    forall a. Num a => SpecialCon a -> a
    forall a. Ord a => SpecialCon a -> a
    forall m. Monoid m => SpecialCon m -> m
    forall a. SpecialCon a -> Bool
    forall a. SpecialCon a -> Int
    forall a. SpecialCon a -> [a]
    forall a. (a -> a -> a) -> SpecialCon a -> a
    forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
    forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
    forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => SpecialCon m -> m
    fold :: forall m. Monoid m => SpecialCon m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> SpecialCon a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> SpecialCon a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> SpecialCon a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> SpecialCon a -> a
    foldr1 :: forall a. (a -> a -> a) -> SpecialCon a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> SpecialCon a -> a
    foldl1 :: forall a. (a -> a -> a) -> SpecialCon a -> a
    $ctoList :: forall a. SpecialCon a -> [a]
    toList :: forall a. SpecialCon a -> [a]
    $cnull :: forall a. SpecialCon a -> Bool
    null :: forall a. SpecialCon a -> Bool
    $clength :: forall a. SpecialCon a -> Int
    length :: forall a. SpecialCon a -> Int
    $celem :: forall a. Eq a => a -> SpecialCon a -> Bool
    elem :: forall a. Eq a => a -> SpecialCon a -> Bool
    $cmaximum :: forall a. Ord a => SpecialCon a -> a
    maximum :: forall a. Ord a => SpecialCon a -> a
    $cminimum :: forall a. Ord a => SpecialCon a -> a
    minimum :: forall a. Ord a => SpecialCon a -> a
    $csum :: forall a. Num a => SpecialCon a -> a
    sum :: forall a. Num a => SpecialCon a -> a
    $cproduct :: forall a. Num a => SpecialCon a -> a
    product :: forall a. Num a => SpecialCon a -> a
    Foldable,Functor SpecialCon
    Foldable SpecialCon
    (Functor SpecialCon, Foldable SpecialCon) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> SpecialCon a -> f (SpecialCon b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        SpecialCon (f a) -> f (SpecialCon a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> SpecialCon a -> m (SpecialCon b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        SpecialCon (m a) -> m (SpecialCon a))
    -> Traversable SpecialCon
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    SpecialCon (m a) -> m (SpecialCon a)
    forall (f :: * -> *) a.
    Applicative f =>
    SpecialCon (f a) -> f (SpecialCon a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SpecialCon a -> m (SpecialCon b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SpecialCon a -> f (SpecialCon b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SpecialCon a -> f (SpecialCon b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SpecialCon a -> f (SpecialCon b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    SpecialCon (f a) -> f (SpecialCon a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    SpecialCon (f a) -> f (SpecialCon a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SpecialCon a -> m (SpecialCon b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SpecialCon a -> m (SpecialCon b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    SpecialCon (m a) -> m (SpecialCon a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    SpecialCon (m a) -> m (SpecialCon a)
    Traversable,(forall a b. (a -> b) -> SpecialCon a -> SpecialCon b)
    -> (forall a b. a -> SpecialCon b -> SpecialCon a)
    -> Functor SpecialCon
    forall a b. a -> SpecialCon b -> SpecialCon a
    forall a b. (a -> b) -> SpecialCon a -> SpecialCon b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> SpecialCon a -> SpecialCon b
    fmap :: forall a b. (a -> b) -> SpecialCon a -> SpecialCon b
    $c<$ :: forall a b. a -> SpecialCon b -> SpecialCon a
    <$ :: forall a b. a -> SpecialCon b -> SpecialCon a
    Functor,(forall x. SpecialCon l -> Rep (SpecialCon l) x)
    -> (forall x. Rep (SpecialCon l) x -> SpecialCon l)
    -> Generic (SpecialCon l)
    forall x. Rep (SpecialCon l) x -> SpecialCon l
    forall x. SpecialCon l -> Rep (SpecialCon l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (SpecialCon l) x -> SpecialCon l
    forall l x. SpecialCon l -> Rep (SpecialCon l) x
    $cfrom :: forall l x. SpecialCon l -> Rep (SpecialCon l) x
    from :: forall x. SpecialCon l -> Rep (SpecialCon l) x
    $cto :: forall l x. Rep (SpecialCon l) x -> SpecialCon l
    to :: forall x. Rep (SpecialCon l) x -> SpecialCon l
    Generic)

    -- | This type is used to represent qualified variables, and also
    -- qualified constructors.
    data QName l
        = Qual    l (ModuleName l) (Name l) -- ^ name qualified with a module name
        | UnQual  l                (Name l) -- ^ unqualified local name
        | Special l (SpecialCon l)          -- ^ built-in constructor with special syntax
      deriving (QName l -> QName l -> Bool
    (QName l -> QName l -> Bool)
    -> (QName l -> QName l -> Bool) -> Eq (QName l)
    forall l. Eq l => QName l -> QName l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => QName l -> QName l -> Bool
    == :: QName l -> QName l -> Bool
    $c/= :: forall l. Eq l => QName l -> QName l -> Bool
    /= :: QName l -> QName l -> Bool
    Eq,Eq (QName l)
    Eq (QName l) =>
    (QName l -> QName l -> Ordering)
    -> (QName l -> QName l -> Bool)
    -> (QName l -> QName l -> Bool)
    -> (QName l -> QName l -> Bool)
    -> (QName l -> QName l -> Bool)
    -> (QName l -> QName l -> QName l)
    -> (QName l -> QName l -> QName l)
    -> Ord (QName l)
    QName l -> QName l -> Bool
    QName l -> QName l -> Ordering
    QName l -> QName l -> QName l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (QName l)
    forall l. Ord l => QName l -> QName l -> Bool
    forall l. Ord l => QName l -> QName l -> Ordering
    forall l. Ord l => QName l -> QName l -> QName l
    $ccompare :: forall l. Ord l => QName l -> QName l -> Ordering
    compare :: QName l -> QName l -> Ordering
    $c< :: forall l. Ord l => QName l -> QName l -> Bool
    < :: QName l -> QName l -> Bool
    $c<= :: forall l. Ord l => QName l -> QName l -> Bool
    <= :: QName l -> QName l -> Bool
    $c> :: forall l. Ord l => QName l -> QName l -> Bool
    > :: QName l -> QName l -> Bool
    $c>= :: forall l. Ord l => QName l -> QName l -> Bool
    >= :: QName l -> QName l -> Bool
    $cmax :: forall l. Ord l => QName l -> QName l -> QName l
    max :: QName l -> QName l -> QName l
    $cmin :: forall l. Ord l => QName l -> QName l -> QName l
    min :: QName l -> QName l -> QName l
    Ord,Int -> QName l -> ShowS
    [QName l] -> ShowS
    QName l -> String
    (Int -> QName l -> ShowS)
    -> (QName l -> String) -> ([QName l] -> ShowS) -> Show (QName l)
    forall l. Show l => Int -> QName l -> ShowS
    forall l. Show l => [QName l] -> ShowS
    forall l. Show l => QName l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> QName l -> ShowS
    showsPrec :: Int -> QName l -> ShowS
    $cshow :: forall l. Show l => QName l -> String
    show :: QName l -> String
    $cshowList :: forall l. Show l => [QName l] -> ShowS
    showList :: [QName l] -> ShowS
    Show,Typeable,Typeable (QName l)
    Typeable (QName l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> QName l -> c (QName l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (QName l))
    -> (QName l -> Constr)
    -> (QName l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (QName l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l)))
    -> ((forall b. Data b => b -> b) -> QName l -> QName l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> QName l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> QName l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> QName l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> QName l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> QName l -> m (QName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QName l -> m (QName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QName l -> m (QName l))
    -> Data (QName l)
    QName l -> Constr
    QName l -> DataType
    (forall b. Data b => b -> b) -> QName l -> QName l
    forall l. Data l => Typeable (QName l)
    forall l. Data l => QName l -> Constr
    forall l. Data l => QName l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> QName l -> QName l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> QName l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> QName l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QName l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QName l -> c (QName l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (QName l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> QName l -> u
    forall u. (forall d. Data d => d -> u) -> QName l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QName l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QName l -> c (QName l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QName l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QName l -> c (QName l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QName l -> c (QName l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QName l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QName l)
    $ctoConstr :: forall l. Data l => QName l -> Constr
    toConstr :: QName l -> Constr
    $cdataTypeOf :: forall l. Data l => QName l -> DataType
    dataTypeOf :: QName l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (QName l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QName l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> QName l -> QName l
    gmapT :: (forall b. Data b => b -> b) -> QName l -> QName l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QName l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> QName l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> QName l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> QName l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QName l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName l -> m (QName l)
    Data,(forall m. Monoid m => QName m -> m)
    -> (forall m a. Monoid m => (a -> m) -> QName a -> m)
    -> (forall m a. Monoid m => (a -> m) -> QName a -> m)
    -> (forall a b. (a -> b -> b) -> b -> QName a -> b)
    -> (forall a b. (a -> b -> b) -> b -> QName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> QName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> QName a -> b)
    -> (forall a. (a -> a -> a) -> QName a -> a)
    -> (forall a. (a -> a -> a) -> QName a -> a)
    -> (forall a. QName a -> [a])
    -> (forall a. QName a -> Bool)
    -> (forall a. QName a -> Int)
    -> (forall a. Eq a => a -> QName a -> Bool)
    -> (forall a. Ord a => QName a -> a)
    -> (forall a. Ord a => QName a -> a)
    -> (forall a. Num a => QName a -> a)
    -> (forall a. Num a => QName a -> a)
    -> Foldable QName
    forall a. Eq a => a -> QName a -> Bool
    forall a. Num a => QName a -> a
    forall a. Ord a => QName a -> a
    forall m. Monoid m => QName m -> m
    forall a. QName a -> Bool
    forall a. QName a -> Int
    forall a. QName a -> [a]
    forall a. (a -> a -> a) -> QName a -> a
    forall m a. Monoid m => (a -> m) -> QName a -> m
    forall b a. (b -> a -> b) -> b -> QName a -> b
    forall a b. (a -> b -> b) -> b -> QName a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => QName m -> m
    fold :: forall m. Monoid m => QName m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> QName a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> QName a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> QName a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> QName a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> QName a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> QName a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> QName a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> QName a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> QName a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> QName a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> QName a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> QName a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> QName a -> a
    foldr1 :: forall a. (a -> a -> a) -> QName a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> QName a -> a
    foldl1 :: forall a. (a -> a -> a) -> QName a -> a
    $ctoList :: forall a. QName a -> [a]
    toList :: forall a. QName a -> [a]
    $cnull :: forall a. QName a -> Bool
    null :: forall a. QName a -> Bool
    $clength :: forall a. QName a -> Int
    length :: forall a. QName a -> Int
    $celem :: forall a. Eq a => a -> QName a -> Bool
    elem :: forall a. Eq a => a -> QName a -> Bool
    $cmaximum :: forall a. Ord a => QName a -> a
    maximum :: forall a. Ord a => QName a -> a
    $cminimum :: forall a. Ord a => QName a -> a
    minimum :: forall a. Ord a => QName a -> a
    $csum :: forall a. Num a => QName a -> a
    sum :: forall a. Num a => QName a -> a
    $cproduct :: forall a. Num a => QName a -> a
    product :: forall a. Num a => QName a -> a
    Foldable,Functor QName
    Foldable QName
    (Functor QName, Foldable QName) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> QName a -> f (QName b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        QName (f a) -> f (QName a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> QName a -> m (QName b))
    -> (forall (m :: * -> *) a. Monad m => QName (m a) -> m (QName a))
    -> Traversable QName
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => QName (m a) -> m (QName a)
    forall (f :: * -> *) a. Applicative f => QName (f a) -> f (QName a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QName a -> m (QName b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QName a -> f (QName b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QName a -> f (QName b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QName a -> f (QName b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => QName (f a) -> f (QName a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => QName (f a) -> f (QName a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QName a -> m (QName b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QName a -> m (QName b)
    $csequence :: forall (m :: * -> *) a. Monad m => QName (m a) -> m (QName a)
    sequence :: forall (m :: * -> *) a. Monad m => QName (m a) -> m (QName a)
    Traversable,(forall a b. (a -> b) -> QName a -> QName b)
    -> (forall a b. a -> QName b -> QName a) -> Functor QName
    forall a b. a -> QName b -> QName a
    forall a b. (a -> b) -> QName a -> QName b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> QName a -> QName b
    fmap :: forall a b. (a -> b) -> QName a -> QName b
    $c<$ :: forall a b. a -> QName b -> QName a
    <$ :: forall a b. a -> QName b -> QName a
    Functor,(forall x. QName l -> Rep (QName l) x)
    -> (forall x. Rep (QName l) x -> QName l) -> Generic (QName l)
    forall x. Rep (QName l) x -> QName l
    forall x. QName l -> Rep (QName l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (QName l) x -> QName l
    forall l x. QName l -> Rep (QName l) x
    $cfrom :: forall l x. QName l -> Rep (QName l) x
    from :: forall x. QName l -> Rep (QName l) x
    $cto :: forall l x. Rep (QName l) x -> QName l
    to :: forall x. Rep (QName l) x -> QName l
    Generic)

    -- | This type is used to represent variables, and also constructors.
    data Name l
        = Ident  l String   -- ^ /varid/ or /conid/.
        | Symbol l String   -- ^ /varsym/ or /consym/
      deriving (Name l -> Name l -> Bool
    (Name l -> Name l -> Bool)
    -> (Name l -> Name l -> Bool) -> Eq (Name l)
    forall l. Eq l => Name l -> Name l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Name l -> Name l -> Bool
    == :: Name l -> Name l -> Bool
    $c/= :: forall l. Eq l => Name l -> Name l -> Bool
    /= :: Name l -> Name l -> Bool
    Eq,Eq (Name l)
    Eq (Name l) =>
    (Name l -> Name l -> Ordering)
    -> (Name l -> Name l -> Bool)
    -> (Name l -> Name l -> Bool)
    -> (Name l -> Name l -> Bool)
    -> (Name l -> Name l -> Bool)
    -> (Name l -> Name l -> Name l)
    -> (Name l -> Name l -> Name l)
    -> Ord (Name l)
    Name l -> Name l -> Bool
    Name l -> Name l -> Ordering
    Name l -> Name l -> Name l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Name l)
    forall l. Ord l => Name l -> Name l -> Bool
    forall l. Ord l => Name l -> Name l -> Ordering
    forall l. Ord l => Name l -> Name l -> Name l
    $ccompare :: forall l. Ord l => Name l -> Name l -> Ordering
    compare :: Name l -> Name l -> Ordering
    $c< :: forall l. Ord l => Name l -> Name l -> Bool
    < :: Name l -> Name l -> Bool
    $c<= :: forall l. Ord l => Name l -> Name l -> Bool
    <= :: Name l -> Name l -> Bool
    $c> :: forall l. Ord l => Name l -> Name l -> Bool
    > :: Name l -> Name l -> Bool
    $c>= :: forall l. Ord l => Name l -> Name l -> Bool
    >= :: Name l -> Name l -> Bool
    $cmax :: forall l. Ord l => Name l -> Name l -> Name l
    max :: Name l -> Name l -> Name l
    $cmin :: forall l. Ord l => Name l -> Name l -> Name l
    min :: Name l -> Name l -> Name l
    Ord,Int -> Name l -> ShowS
    [Name l] -> ShowS
    Name l -> String
    (Int -> Name l -> ShowS)
    -> (Name l -> String) -> ([Name l] -> ShowS) -> Show (Name l)
    forall l. Show l => Int -> Name l -> ShowS
    forall l. Show l => [Name l] -> ShowS
    forall l. Show l => Name l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Name l -> ShowS
    showsPrec :: Int -> Name l -> ShowS
    $cshow :: forall l. Show l => Name l -> String
    show :: Name l -> String
    $cshowList :: forall l. Show l => [Name l] -> ShowS
    showList :: [Name l] -> ShowS
    Show,Typeable,Typeable (Name l)
    Typeable (Name l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Name l -> c (Name l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Name l))
    -> (Name l -> Constr)
    -> (Name l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Name l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l)))
    -> ((forall b. Data b => b -> b) -> Name l -> Name l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Name l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Name l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Name l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Name l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Name l -> m (Name l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Name l -> m (Name l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Name l -> m (Name l))
    -> Data (Name l)
    Name l -> Constr
    Name l -> DataType
    (forall b. Data b => b -> b) -> Name l -> Name l
    forall l. Data l => Typeable (Name l)
    forall l. Data l => Name l -> Constr
    forall l. Data l => Name l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Name l -> Name l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Name l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Name l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Name l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name l -> c (Name l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Name l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Name l -> u
    forall u. (forall d. Data d => d -> u) -> Name l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Name l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name l -> c (Name l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Name l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name l -> c (Name l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name l -> c (Name l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Name l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Name l)
    $ctoConstr :: forall l. Data l => Name l -> Constr
    toConstr :: Name l -> Constr
    $cdataTypeOf :: forall l. Data l => Name l -> DataType
    dataTypeOf :: Name l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Name l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Name l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Name l -> Name l
    gmapT :: (forall b. Data b => b -> b) -> Name l -> Name l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Name l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Name l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Name l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name l -> m (Name l)
    Data,(forall m. Monoid m => Name m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Name a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Name a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Name a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Name a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Name a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Name a -> b)
    -> (forall a. (a -> a -> a) -> Name a -> a)
    -> (forall a. (a -> a -> a) -> Name a -> a)
    -> (forall a. Name a -> [a])
    -> (forall a. Name a -> Bool)
    -> (forall a. Name a -> Int)
    -> (forall a. Eq a => a -> Name a -> Bool)
    -> (forall a. Ord a => Name a -> a)
    -> (forall a. Ord a => Name a -> a)
    -> (forall a. Num a => Name a -> a)
    -> (forall a. Num a => Name a -> a)
    -> Foldable Name
    forall a. Eq a => a -> Name a -> Bool
    forall a. Num a => Name a -> a
    forall a. Ord a => Name a -> a
    forall m. Monoid m => Name m -> m
    forall a. Name a -> Bool
    forall a. Name a -> Int
    forall a. Name a -> [a]
    forall a. (a -> a -> a) -> Name a -> a
    forall m a. Monoid m => (a -> m) -> Name a -> m
    forall b a. (b -> a -> b) -> b -> Name a -> b
    forall a b. (a -> b -> b) -> b -> Name a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Name m -> m
    fold :: forall m. Monoid m => Name m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Name a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Name a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Name a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Name a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Name a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Name a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Name a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Name a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Name a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Name a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Name a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Name a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Name a -> a
    foldr1 :: forall a. (a -> a -> a) -> Name a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Name a -> a
    foldl1 :: forall a. (a -> a -> a) -> Name a -> a
    $ctoList :: forall a. Name a -> [a]
    toList :: forall a. Name a -> [a]
    $cnull :: forall a. Name a -> Bool
    null :: forall a. Name a -> Bool
    $clength :: forall a. Name a -> Int
    length :: forall a. Name a -> Int
    $celem :: forall a. Eq a => a -> Name a -> Bool
    elem :: forall a. Eq a => a -> Name a -> Bool
    $cmaximum :: forall a. Ord a => Name a -> a
    maximum :: forall a. Ord a => Name a -> a
    $cminimum :: forall a. Ord a => Name a -> a
    minimum :: forall a. Ord a => Name a -> a
    $csum :: forall a. Num a => Name a -> a
    sum :: forall a. Num a => Name a -> a
    $cproduct :: forall a. Num a => Name a -> a
    product :: forall a. Num a => Name a -> a
    Foldable,Functor Name
    Foldable Name
    (Functor Name, Foldable Name) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Name a -> f (Name b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Name (f a) -> f (Name a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Name a -> m (Name b))
    -> (forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a))
    -> Traversable Name
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a)
    forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Name a -> m (Name b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Name a -> f (Name b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Name a -> f (Name b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Name a -> f (Name b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Name a -> m (Name b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Name a -> m (Name b)
    $csequence :: forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a)
    sequence :: forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a)
    Traversable,(forall a b. (a -> b) -> Name a -> Name b)
    -> (forall a b. a -> Name b -> Name a) -> Functor Name
    forall a b. a -> Name b -> Name a
    forall a b. (a -> b) -> Name a -> Name b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Name a -> Name b
    fmap :: forall a b. (a -> b) -> Name a -> Name b
    $c<$ :: forall a b. a -> Name b -> Name a
    <$ :: forall a b. a -> Name b -> Name a
    Functor,(forall x. Name l -> Rep (Name l) x)
    -> (forall x. Rep (Name l) x -> Name l) -> Generic (Name l)
    forall x. Rep (Name l) x -> Name l
    forall x. Name l -> Rep (Name l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Name l) x -> Name l
    forall l x. Name l -> Rep (Name l) x
    $cfrom :: forall l x. Name l -> Rep (Name l) x
    from :: forall x. Name l -> Rep (Name l) x
    $cto :: forall l x. Rep (Name l) x -> Name l
    to :: forall x. Rep (Name l) x -> Name l
    Generic)

    -- | An implicit parameter name.
    data IPName l
        = IPDup l String -- ^ ?/ident/, non-linear implicit parameter
        | IPLin l String -- ^ %/ident/, linear implicit parameter
      deriving (IPName l -> IPName l -> Bool
    (IPName l -> IPName l -> Bool)
    -> (IPName l -> IPName l -> Bool) -> Eq (IPName l)
    forall l. Eq l => IPName l -> IPName l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => IPName l -> IPName l -> Bool
    == :: IPName l -> IPName l -> Bool
    $c/= :: forall l. Eq l => IPName l -> IPName l -> Bool
    /= :: IPName l -> IPName l -> Bool
    Eq,Eq (IPName l)
    Eq (IPName l) =>
    (IPName l -> IPName l -> Ordering)
    -> (IPName l -> IPName l -> Bool)
    -> (IPName l -> IPName l -> Bool)
    -> (IPName l -> IPName l -> Bool)
    -> (IPName l -> IPName l -> Bool)
    -> (IPName l -> IPName l -> IPName l)
    -> (IPName l -> IPName l -> IPName l)
    -> Ord (IPName l)
    IPName l -> IPName l -> Bool
    IPName l -> IPName l -> Ordering
    IPName l -> IPName l -> IPName l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (IPName l)
    forall l. Ord l => IPName l -> IPName l -> Bool
    forall l. Ord l => IPName l -> IPName l -> Ordering
    forall l. Ord l => IPName l -> IPName l -> IPName l
    $ccompare :: forall l. Ord l => IPName l -> IPName l -> Ordering
    compare :: IPName l -> IPName l -> Ordering
    $c< :: forall l. Ord l => IPName l -> IPName l -> Bool
    < :: IPName l -> IPName l -> Bool
    $c<= :: forall l. Ord l => IPName l -> IPName l -> Bool
    <= :: IPName l -> IPName l -> Bool
    $c> :: forall l. Ord l => IPName l -> IPName l -> Bool
    > :: IPName l -> IPName l -> Bool
    $c>= :: forall l. Ord l => IPName l -> IPName l -> Bool
    >= :: IPName l -> IPName l -> Bool
    $cmax :: forall l. Ord l => IPName l -> IPName l -> IPName l
    max :: IPName l -> IPName l -> IPName l
    $cmin :: forall l. Ord l => IPName l -> IPName l -> IPName l
    min :: IPName l -> IPName l -> IPName l
    Ord,Int -> IPName l -> ShowS
    [IPName l] -> ShowS
    IPName l -> String
    (Int -> IPName l -> ShowS)
    -> (IPName l -> String) -> ([IPName l] -> ShowS) -> Show (IPName l)
    forall l. Show l => Int -> IPName l -> ShowS
    forall l. Show l => [IPName l] -> ShowS
    forall l. Show l => IPName l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> IPName l -> ShowS
    showsPrec :: Int -> IPName l -> ShowS
    $cshow :: forall l. Show l => IPName l -> String
    show :: IPName l -> String
    $cshowList :: forall l. Show l => [IPName l] -> ShowS
    showList :: [IPName l] -> ShowS
    Show,Typeable,Typeable (IPName l)
    Typeable (IPName l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> IPName l -> c (IPName l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (IPName l))
    -> (IPName l -> Constr)
    -> (IPName l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (IPName l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (IPName l)))
    -> ((forall b. Data b => b -> b) -> IPName l -> IPName l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> IPName l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> IPName l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> IPName l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> IPName l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> IPName l -> m (IPName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> IPName l -> m (IPName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> IPName l -> m (IPName l))
    -> Data (IPName l)
    IPName l -> Constr
    IPName l -> DataType
    (forall b. Data b => b -> b) -> IPName l -> IPName l
    forall l. Data l => Typeable (IPName l)
    forall l. Data l => IPName l -> Constr
    forall l. Data l => IPName l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> IPName l -> IPName l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> IPName l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> IPName l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPName l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPName l -> c (IPName l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPName l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> IPName l -> u
    forall u. (forall d. Data d => d -> u) -> IPName l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPName l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPName l -> c (IPName l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPName l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPName l -> c (IPName l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPName l -> c (IPName l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPName l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPName l)
    $ctoConstr :: forall l. Data l => IPName l -> Constr
    toConstr :: IPName l -> Constr
    $cdataTypeOf :: forall l. Data l => IPName l -> DataType
    dataTypeOf :: IPName l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPName l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPName l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> IPName l -> IPName l
    gmapT :: (forall b. Data b => b -> b) -> IPName l -> IPName l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPName l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> IPName l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> IPName l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> IPName l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPName l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPName l -> m (IPName l)
    Data,(forall m. Monoid m => IPName m -> m)
    -> (forall m a. Monoid m => (a -> m) -> IPName a -> m)
    -> (forall m a. Monoid m => (a -> m) -> IPName a -> m)
    -> (forall a b. (a -> b -> b) -> b -> IPName a -> b)
    -> (forall a b. (a -> b -> b) -> b -> IPName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> IPName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> IPName a -> b)
    -> (forall a. (a -> a -> a) -> IPName a -> a)
    -> (forall a. (a -> a -> a) -> IPName a -> a)
    -> (forall a. IPName a -> [a])
    -> (forall a. IPName a -> Bool)
    -> (forall a. IPName a -> Int)
    -> (forall a. Eq a => a -> IPName a -> Bool)
    -> (forall a. Ord a => IPName a -> a)
    -> (forall a. Ord a => IPName a -> a)
    -> (forall a. Num a => IPName a -> a)
    -> (forall a. Num a => IPName a -> a)
    -> Foldable IPName
    forall a. Eq a => a -> IPName a -> Bool
    forall a. Num a => IPName a -> a
    forall a. Ord a => IPName a -> a
    forall m. Monoid m => IPName m -> m
    forall a. IPName a -> Bool
    forall a. IPName a -> Int
    forall a. IPName a -> [a]
    forall a. (a -> a -> a) -> IPName a -> a
    forall m a. Monoid m => (a -> m) -> IPName a -> m
    forall b a. (b -> a -> b) -> b -> IPName a -> b
    forall a b. (a -> b -> b) -> b -> IPName a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => IPName m -> m
    fold :: forall m. Monoid m => IPName m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> IPName a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> IPName a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> IPName a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> IPName a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> IPName a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> IPName a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> IPName a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> IPName a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> IPName a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> IPName a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> IPName a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> IPName a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> IPName a -> a
    foldr1 :: forall a. (a -> a -> a) -> IPName a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> IPName a -> a
    foldl1 :: forall a. (a -> a -> a) -> IPName a -> a
    $ctoList :: forall a. IPName a -> [a]
    toList :: forall a. IPName a -> [a]
    $cnull :: forall a. IPName a -> Bool
    null :: forall a. IPName a -> Bool
    $clength :: forall a. IPName a -> Int
    length :: forall a. IPName a -> Int
    $celem :: forall a. Eq a => a -> IPName a -> Bool
    elem :: forall a. Eq a => a -> IPName a -> Bool
    $cmaximum :: forall a. Ord a => IPName a -> a
    maximum :: forall a. Ord a => IPName a -> a
    $cminimum :: forall a. Ord a => IPName a -> a
    minimum :: forall a. Ord a => IPName a -> a
    $csum :: forall a. Num a => IPName a -> a
    sum :: forall a. Num a => IPName a -> a
    $cproduct :: forall a. Num a => IPName a -> a
    product :: forall a. Num a => IPName a -> a
    Foldable,Functor IPName
    Foldable IPName
    (Functor IPName, Foldable IPName) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> IPName a -> f (IPName b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        IPName (f a) -> f (IPName a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> IPName a -> m (IPName b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        IPName (m a) -> m (IPName a))
    -> Traversable IPName
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => IPName (m a) -> m (IPName a)
    forall (f :: * -> *) a.
    Applicative f =>
    IPName (f a) -> f (IPName a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPName a -> m (IPName b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPName a -> f (IPName b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPName a -> f (IPName b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPName a -> f (IPName b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    IPName (f a) -> f (IPName a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    IPName (f a) -> f (IPName a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPName a -> m (IPName b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPName a -> m (IPName b)
    $csequence :: forall (m :: * -> *) a. Monad m => IPName (m a) -> m (IPName a)
    sequence :: forall (m :: * -> *) a. Monad m => IPName (m a) -> m (IPName a)
    Traversable,(forall a b. (a -> b) -> IPName a -> IPName b)
    -> (forall a b. a -> IPName b -> IPName a) -> Functor IPName
    forall a b. a -> IPName b -> IPName a
    forall a b. (a -> b) -> IPName a -> IPName b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> IPName a -> IPName b
    fmap :: forall a b. (a -> b) -> IPName a -> IPName b
    $c<$ :: forall a b. a -> IPName b -> IPName a
    <$ :: forall a b. a -> IPName b -> IPName a
    Functor,(forall x. IPName l -> Rep (IPName l) x)
    -> (forall x. Rep (IPName l) x -> IPName l) -> Generic (IPName l)
    forall x. Rep (IPName l) x -> IPName l
    forall x. IPName l -> Rep (IPName l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (IPName l) x -> IPName l
    forall l x. IPName l -> Rep (IPName l) x
    $cfrom :: forall l x. IPName l -> Rep (IPName l) x
    from :: forall x. IPName l -> Rep (IPName l) x
    $cto :: forall l x. Rep (IPName l) x -> IPName l
    to :: forall x. Rep (IPName l) x -> IPName l
    Generic)

    -- | Possibly qualified infix operators (/qop/), appearing in expressions.
    data QOp l
        = QVarOp l (QName l) -- ^ variable operator (/qvarop/)
        | QConOp l (QName l) -- ^ constructor operator (/qconop/)
      deriving (QOp l -> QOp l -> Bool
    (QOp l -> QOp l -> Bool) -> (QOp l -> QOp l -> Bool) -> Eq (QOp l)
    forall l. Eq l => QOp l -> QOp l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => QOp l -> QOp l -> Bool
    == :: QOp l -> QOp l -> Bool
    $c/= :: forall l. Eq l => QOp l -> QOp l -> Bool
    /= :: QOp l -> QOp l -> Bool
    Eq,Eq (QOp l)
    Eq (QOp l) =>
    (QOp l -> QOp l -> Ordering)
    -> (QOp l -> QOp l -> Bool)
    -> (QOp l -> QOp l -> Bool)
    -> (QOp l -> QOp l -> Bool)
    -> (QOp l -> QOp l -> Bool)
    -> (QOp l -> QOp l -> QOp l)
    -> (QOp l -> QOp l -> QOp l)
    -> Ord (QOp l)
    QOp l -> QOp l -> Bool
    QOp l -> QOp l -> Ordering
    QOp l -> QOp l -> QOp l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (QOp l)
    forall l. Ord l => QOp l -> QOp l -> Bool
    forall l. Ord l => QOp l -> QOp l -> Ordering
    forall l. Ord l => QOp l -> QOp l -> QOp l
    $ccompare :: forall l. Ord l => QOp l -> QOp l -> Ordering
    compare :: QOp l -> QOp l -> Ordering
    $c< :: forall l. Ord l => QOp l -> QOp l -> Bool
    < :: QOp l -> QOp l -> Bool
    $c<= :: forall l. Ord l => QOp l -> QOp l -> Bool
    <= :: QOp l -> QOp l -> Bool
    $c> :: forall l. Ord l => QOp l -> QOp l -> Bool
    > :: QOp l -> QOp l -> Bool
    $c>= :: forall l. Ord l => QOp l -> QOp l -> Bool
    >= :: QOp l -> QOp l -> Bool
    $cmax :: forall l. Ord l => QOp l -> QOp l -> QOp l
    max :: QOp l -> QOp l -> QOp l
    $cmin :: forall l. Ord l => QOp l -> QOp l -> QOp l
    min :: QOp l -> QOp l -> QOp l
    Ord,Int -> QOp l -> ShowS
    [QOp l] -> ShowS
    QOp l -> String
    (Int -> QOp l -> ShowS)
    -> (QOp l -> String) -> ([QOp l] -> ShowS) -> Show (QOp l)
    forall l. Show l => Int -> QOp l -> ShowS
    forall l. Show l => [QOp l] -> ShowS
    forall l. Show l => QOp l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> QOp l -> ShowS
    showsPrec :: Int -> QOp l -> ShowS
    $cshow :: forall l. Show l => QOp l -> String
    show :: QOp l -> String
    $cshowList :: forall l. Show l => [QOp l] -> ShowS
    showList :: [QOp l] -> ShowS
    Show,Typeable,Typeable (QOp l)
    Typeable (QOp l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> QOp l -> c (QOp l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (QOp l))
    -> (QOp l -> Constr)
    -> (QOp l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (QOp l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l)))
    -> ((forall b. Data b => b -> b) -> QOp l -> QOp l)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> QOp l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> QOp l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> QOp l -> m (QOp l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QOp l -> m (QOp l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QOp l -> m (QOp l))
    -> Data (QOp l)
    QOp l -> Constr
    QOp l -> DataType
    (forall b. Data b => b -> b) -> QOp l -> QOp l
    forall l. Data l => Typeable (QOp l)
    forall l. Data l => QOp l -> Constr
    forall l. Data l => QOp l -> DataType
    forall l. Data l => (forall b. Data b => b -> b) -> QOp l -> QOp l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> QOp l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> QOp l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QOp l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QOp l -> c (QOp l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (QOp l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> QOp l -> u
    forall u. (forall d. Data d => d -> u) -> QOp l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QOp l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QOp l -> c (QOp l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QOp l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QOp l -> c (QOp l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QOp l -> c (QOp l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QOp l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QOp l)
    $ctoConstr :: forall l. Data l => QOp l -> Constr
    toConstr :: QOp l -> Constr
    $cdataTypeOf :: forall l. Data l => QOp l -> DataType
    dataTypeOf :: QOp l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (QOp l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QOp l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l))
    $cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> QOp l -> QOp l
    gmapT :: (forall b. Data b => b -> b) -> QOp l -> QOp l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> QOp l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> QOp l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> QOp l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QOp l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QOp l -> m (QOp l)
    Data,(forall m. Monoid m => QOp m -> m)
    -> (forall m a. Monoid m => (a -> m) -> QOp a -> m)
    -> (forall m a. Monoid m => (a -> m) -> QOp a -> m)
    -> (forall a b. (a -> b -> b) -> b -> QOp a -> b)
    -> (forall a b. (a -> b -> b) -> b -> QOp a -> b)
    -> (forall b a. (b -> a -> b) -> b -> QOp a -> b)
    -> (forall b a. (b -> a -> b) -> b -> QOp a -> b)
    -> (forall a. (a -> a -> a) -> QOp a -> a)
    -> (forall a. (a -> a -> a) -> QOp a -> a)
    -> (forall a. QOp a -> [a])
    -> (forall a. QOp a -> Bool)
    -> (forall a. QOp a -> Int)
    -> (forall a. Eq a => a -> QOp a -> Bool)
    -> (forall a. Ord a => QOp a -> a)
    -> (forall a. Ord a => QOp a -> a)
    -> (forall a. Num a => QOp a -> a)
    -> (forall a. Num a => QOp a -> a)
    -> Foldable QOp
    forall a. Eq a => a -> QOp a -> Bool
    forall a. Num a => QOp a -> a
    forall a. Ord a => QOp a -> a
    forall m. Monoid m => QOp m -> m
    forall a. QOp a -> Bool
    forall a. QOp a -> Int
    forall a. QOp a -> [a]
    forall a. (a -> a -> a) -> QOp a -> a
    forall m a. Monoid m => (a -> m) -> QOp a -> m
    forall b a. (b -> a -> b) -> b -> QOp a -> b
    forall a b. (a -> b -> b) -> b -> QOp a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => QOp m -> m
    fold :: forall m. Monoid m => QOp m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> QOp a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> QOp a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> QOp a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> QOp a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> QOp a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> QOp a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> QOp a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> QOp a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> QOp a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> QOp a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> QOp a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> QOp a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> QOp a -> a
    foldr1 :: forall a. (a -> a -> a) -> QOp a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> QOp a -> a
    foldl1 :: forall a. (a -> a -> a) -> QOp a -> a
    $ctoList :: forall a. QOp a -> [a]
    toList :: forall a. QOp a -> [a]
    $cnull :: forall a. QOp a -> Bool
    null :: forall a. QOp a -> Bool
    $clength :: forall a. QOp a -> Int
    length :: forall a. QOp a -> Int
    $celem :: forall a. Eq a => a -> QOp a -> Bool
    elem :: forall a. Eq a => a -> QOp a -> Bool
    $cmaximum :: forall a. Ord a => QOp a -> a
    maximum :: forall a. Ord a => QOp a -> a
    $cminimum :: forall a. Ord a => QOp a -> a
    minimum :: forall a. Ord a => QOp a -> a
    $csum :: forall a. Num a => QOp a -> a
    sum :: forall a. Num a => QOp a -> a
    $cproduct :: forall a. Num a => QOp a -> a
    product :: forall a. Num a => QOp a -> a
    Foldable,Functor QOp
    Foldable QOp
    (Functor QOp, Foldable QOp) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> QOp a -> f (QOp b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        QOp (f a) -> f (QOp a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> QOp a -> m (QOp b))
    -> (forall (m :: * -> *) a. Monad m => QOp (m a) -> m (QOp a))
    -> Traversable QOp
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => QOp (m a) -> m (QOp a)
    forall (f :: * -> *) a. Applicative f => QOp (f a) -> f (QOp a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QOp a -> m (QOp b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QOp a -> f (QOp b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QOp a -> f (QOp b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QOp a -> f (QOp b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => QOp (f a) -> f (QOp a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => QOp (f a) -> f (QOp a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QOp a -> m (QOp b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QOp a -> m (QOp b)
    $csequence :: forall (m :: * -> *) a. Monad m => QOp (m a) -> m (QOp a)
    sequence :: forall (m :: * -> *) a. Monad m => QOp (m a) -> m (QOp a)
    Traversable,(forall a b. (a -> b) -> QOp a -> QOp b)
    -> (forall a b. a -> QOp b -> QOp a) -> Functor QOp
    forall a b. a -> QOp b -> QOp a
    forall a b. (a -> b) -> QOp a -> QOp b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> QOp a -> QOp b
    fmap :: forall a b. (a -> b) -> QOp a -> QOp b
    $c<$ :: forall a b. a -> QOp b -> QOp a
    <$ :: forall a b. a -> QOp b -> QOp a
    Functor,(forall x. QOp l -> Rep (QOp l) x)
    -> (forall x. Rep (QOp l) x -> QOp l) -> Generic (QOp l)
    forall x. Rep (QOp l) x -> QOp l
    forall x. QOp l -> Rep (QOp l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (QOp l) x -> QOp l
    forall l x. QOp l -> Rep (QOp l) x
    $cfrom :: forall l x. QOp l -> Rep (QOp l) x
    from :: forall x. QOp l -> Rep (QOp l) x
    $cto :: forall l x. Rep (QOp l) x -> QOp l
    to :: forall x. Rep (QOp l) x -> QOp l
    Generic)

    -- | Operators appearing in @infix@ declarations are never qualified.
    data Op l
        = VarOp l (Name l)    -- ^ variable operator (/varop/)
        | ConOp l (Name l)    -- ^ constructor operator (/conop/)
      deriving (Op l -> Op l -> Bool
    (Op l -> Op l -> Bool) -> (Op l -> Op l -> Bool) -> Eq (Op l)
    forall l. Eq l => Op l -> Op l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Op l -> Op l -> Bool
    == :: Op l -> Op l -> Bool
    $c/= :: forall l. Eq l => Op l -> Op l -> Bool
    /= :: Op l -> Op l -> Bool
    Eq,Eq (Op l)
    Eq (Op l) =>
    (Op l -> Op l -> Ordering)
    -> (Op l -> Op l -> Bool)
    -> (Op l -> Op l -> Bool)
    -> (Op l -> Op l -> Bool)
    -> (Op l -> Op l -> Bool)
    -> (Op l -> Op l -> Op l)
    -> (Op l -> Op l -> Op l)
    -> Ord (Op l)
    Op l -> Op l -> Bool
    Op l -> Op l -> Ordering
    Op l -> Op l -> Op l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Op l)
    forall l. Ord l => Op l -> Op l -> Bool
    forall l. Ord l => Op l -> Op l -> Ordering
    forall l. Ord l => Op l -> Op l -> Op l
    $ccompare :: forall l. Ord l => Op l -> Op l -> Ordering
    compare :: Op l -> Op l -> Ordering
    $c< :: forall l. Ord l => Op l -> Op l -> Bool
    < :: Op l -> Op l -> Bool
    $c<= :: forall l. Ord l => Op l -> Op l -> Bool
    <= :: Op l -> Op l -> Bool
    $c> :: forall l. Ord l => Op l -> Op l -> Bool
    > :: Op l -> Op l -> Bool
    $c>= :: forall l. Ord l => Op l -> Op l -> Bool
    >= :: Op l -> Op l -> Bool
    $cmax :: forall l. Ord l => Op l -> Op l -> Op l
    max :: Op l -> Op l -> Op l
    $cmin :: forall l. Ord l => Op l -> Op l -> Op l
    min :: Op l -> Op l -> Op l
    Ord,Int -> Op l -> ShowS
    [Op l] -> ShowS
    Op l -> String
    (Int -> Op l -> ShowS)
    -> (Op l -> String) -> ([Op l] -> ShowS) -> Show (Op l)
    forall l. Show l => Int -> Op l -> ShowS
    forall l. Show l => [Op l] -> ShowS
    forall l. Show l => Op l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Op l -> ShowS
    showsPrec :: Int -> Op l -> ShowS
    $cshow :: forall l. Show l => Op l -> String
    show :: Op l -> String
    $cshowList :: forall l. Show l => [Op l] -> ShowS
    showList :: [Op l] -> ShowS
    Show,Typeable,Typeable (Op l)
    Typeable (Op l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Op l -> c (Op l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Op l))
    -> (Op l -> Constr)
    -> (Op l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Op l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l)))
    -> ((forall b. Data b => b -> b) -> Op l -> Op l)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Op l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Op l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Op l -> m (Op l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Op l -> m (Op l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Op l -> m (Op l))
    -> Data (Op l)
    Op l -> Constr
    Op l -> DataType
    (forall b. Data b => b -> b) -> Op l -> Op l
    forall l. Data l => Typeable (Op l)
    forall l. Data l => Op l -> Constr
    forall l. Data l => Op l -> DataType
    forall l. Data l => (forall b. Data b => b -> b) -> Op l -> Op l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Op l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Op l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Op l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Op l -> c (Op l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Op l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Op l -> u
    forall u. (forall d. Data d => d -> u) -> Op l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Op l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Op l -> c (Op l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Op l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Op l -> c (Op l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Op l -> c (Op l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Op l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Op l)
    $ctoConstr :: forall l. Data l => Op l -> Constr
    toConstr :: Op l -> Constr
    $cdataTypeOf :: forall l. Data l => Op l -> DataType
    dataTypeOf :: Op l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Op l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Op l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l))
    $cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Op l -> Op l
    gmapT :: (forall b. Data b => b -> b) -> Op l -> Op l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Op l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Op l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Op l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Op l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Op l -> m (Op l)
    Data,(forall m. Monoid m => Op m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Op a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Op a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Op a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Op a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Op a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Op a -> b)
    -> (forall a. (a -> a -> a) -> Op a -> a)
    -> (forall a. (a -> a -> a) -> Op a -> a)
    -> (forall a. Op a -> [a])
    -> (forall a. Op a -> Bool)
    -> (forall a. Op a -> Int)
    -> (forall a. Eq a => a -> Op a -> Bool)
    -> (forall a. Ord a => Op a -> a)
    -> (forall a. Ord a => Op a -> a)
    -> (forall a. Num a => Op a -> a)
    -> (forall a. Num a => Op a -> a)
    -> Foldable Op
    forall a. Eq a => a -> Op a -> Bool
    forall a. Num a => Op a -> a
    forall a. Ord a => Op a -> a
    forall m. Monoid m => Op m -> m
    forall a. Op a -> Bool
    forall a. Op a -> Int
    forall a. Op a -> [a]
    forall a. (a -> a -> a) -> Op a -> a
    forall m a. Monoid m => (a -> m) -> Op a -> m
    forall b a. (b -> a -> b) -> b -> Op a -> b
    forall a b. (a -> b -> b) -> b -> Op a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Op m -> m
    fold :: forall m. Monoid m => Op m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Op a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Op a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Op a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Op a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Op a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Op a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Op a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Op a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Op a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Op a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Op a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Op a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Op a -> a
    foldr1 :: forall a. (a -> a -> a) -> Op a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Op a -> a
    foldl1 :: forall a. (a -> a -> a) -> Op a -> a
    $ctoList :: forall a. Op a -> [a]
    toList :: forall a. Op a -> [a]
    $cnull :: forall a. Op a -> Bool
    null :: forall a. Op a -> Bool
    $clength :: forall a. Op a -> Int
    length :: forall a. Op a -> Int
    $celem :: forall a. Eq a => a -> Op a -> Bool
    elem :: forall a. Eq a => a -> Op a -> Bool
    $cmaximum :: forall a. Ord a => Op a -> a
    maximum :: forall a. Ord a => Op a -> a
    $cminimum :: forall a. Ord a => Op a -> a
    minimum :: forall a. Ord a => Op a -> a
    $csum :: forall a. Num a => Op a -> a
    sum :: forall a. Num a => Op a -> a
    $cproduct :: forall a. Num a => Op a -> a
    product :: forall a. Num a => Op a -> a
    Foldable,Functor Op
    Foldable Op
    (Functor Op, Foldable Op) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Op a -> f (Op b))
    -> (forall (f :: * -> *) a. Applicative f => Op (f a) -> f (Op a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Op a -> m (Op b))
    -> (forall (m :: * -> *) a. Monad m => Op (m a) -> m (Op a))
    -> Traversable Op
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Op (m a) -> m (Op a)
    forall (f :: * -> *) a. Applicative f => Op (f a) -> f (Op a)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> Op a -> m (Op b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Op a -> f (Op b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Op a -> f (Op b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Op a -> f (Op b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Op (f a) -> f (Op a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Op (f a) -> f (Op a)
    $cmapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Op a -> m (Op b)
    mapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Op a -> m (Op b)
    $csequence :: forall (m :: * -> *) a. Monad m => Op (m a) -> m (Op a)
    sequence :: forall (m :: * -> *) a. Monad m => Op (m a) -> m (Op a)
    Traversable,(forall a b. (a -> b) -> Op a -> Op b)
    -> (forall a b. a -> Op b -> Op a) -> Functor Op
    forall a b. a -> Op b -> Op a
    forall a b. (a -> b) -> Op a -> Op b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Op a -> Op b
    fmap :: forall a b. (a -> b) -> Op a -> Op b
    $c<$ :: forall a b. a -> Op b -> Op a
    <$ :: forall a b. a -> Op b -> Op a
    Functor,(forall x. Op l -> Rep (Op l) x)
    -> (forall x. Rep (Op l) x -> Op l) -> Generic (Op l)
    forall x. Rep (Op l) x -> Op l
    forall x. Op l -> Rep (Op l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Op l) x -> Op l
    forall l x. Op l -> Rep (Op l) x
    $cfrom :: forall l x. Op l -> Rep (Op l) x
    from :: forall x. Op l -> Rep (Op l) x
    $cto :: forall l x. Rep (Op l) x -> Op l
    to :: forall x. Rep (Op l) x -> Op l
    Generic)

    -- | A name (/cname/) of a component of a class or data type in an @import@
    -- or export specification.
    data CName l
        = VarName l (Name l) -- ^ name of a method or field
        | ConName l (Name l) -- ^ name of a data constructor
      deriving (CName l -> CName l -> Bool
    (CName l -> CName l -> Bool)
    -> (CName l -> CName l -> Bool) -> Eq (CName l)
    forall l. Eq l => CName l -> CName l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => CName l -> CName l -> Bool
    == :: CName l -> CName l -> Bool
    $c/= :: forall l. Eq l => CName l -> CName l -> Bool
    /= :: CName l -> CName l -> Bool
    Eq,Eq (CName l)
    Eq (CName l) =>
    (CName l -> CName l -> Ordering)
    -> (CName l -> CName l -> Bool)
    -> (CName l -> CName l -> Bool)
    -> (CName l -> CName l -> Bool)
    -> (CName l -> CName l -> Bool)
    -> (CName l -> CName l -> CName l)
    -> (CName l -> CName l -> CName l)
    -> Ord (CName l)
    CName l -> CName l -> Bool
    CName l -> CName l -> Ordering
    CName l -> CName l -> CName l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (CName l)
    forall l. Ord l => CName l -> CName l -> Bool
    forall l. Ord l => CName l -> CName l -> Ordering
    forall l. Ord l => CName l -> CName l -> CName l
    $ccompare :: forall l. Ord l => CName l -> CName l -> Ordering
    compare :: CName l -> CName l -> Ordering
    $c< :: forall l. Ord l => CName l -> CName l -> Bool
    < :: CName l -> CName l -> Bool
    $c<= :: forall l. Ord l => CName l -> CName l -> Bool
    <= :: CName l -> CName l -> Bool
    $c> :: forall l. Ord l => CName l -> CName l -> Bool
    > :: CName l -> CName l -> Bool
    $c>= :: forall l. Ord l => CName l -> CName l -> Bool
    >= :: CName l -> CName l -> Bool
    $cmax :: forall l. Ord l => CName l -> CName l -> CName l
    max :: CName l -> CName l -> CName l
    $cmin :: forall l. Ord l => CName l -> CName l -> CName l
    min :: CName l -> CName l -> CName l
    Ord,Int -> CName l -> ShowS
    [CName l] -> ShowS
    CName l -> String
    (Int -> CName l -> ShowS)
    -> (CName l -> String) -> ([CName l] -> ShowS) -> Show (CName l)
    forall l. Show l => Int -> CName l -> ShowS
    forall l. Show l => [CName l] -> ShowS
    forall l. Show l => CName l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> CName l -> ShowS
    showsPrec :: Int -> CName l -> ShowS
    $cshow :: forall l. Show l => CName l -> String
    show :: CName l -> String
    $cshowList :: forall l. Show l => [CName l] -> ShowS
    showList :: [CName l] -> ShowS
    Show,Typeable,Typeable (CName l)
    Typeable (CName l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> CName l -> c (CName l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (CName l))
    -> (CName l -> Constr)
    -> (CName l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (CName l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l)))
    -> ((forall b. Data b => b -> b) -> CName l -> CName l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CName l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CName l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CName l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> CName l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CName l -> m (CName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CName l -> m (CName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CName l -> m (CName l))
    -> Data (CName l)
    CName l -> Constr
    CName l -> DataType
    (forall b. Data b => b -> b) -> CName l -> CName l
    forall l. Data l => Typeable (CName l)
    forall l. Data l => CName l -> Constr
    forall l. Data l => CName l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> CName l -> CName l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> CName l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> CName l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CName l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CName l -> c (CName l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (CName l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> CName l -> u
    forall u. (forall d. Data d => d -> u) -> CName l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CName l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CName l -> c (CName l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CName l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CName l -> c (CName l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CName l -> c (CName l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CName l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CName l)
    $ctoConstr :: forall l. Data l => CName l -> Constr
    toConstr :: CName l -> Constr
    $cdataTypeOf :: forall l. Data l => CName l -> DataType
    dataTypeOf :: CName l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (CName l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CName l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> CName l -> CName l
    gmapT :: (forall b. Data b => b -> b) -> CName l -> CName l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CName l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> CName l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CName l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> CName l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CName l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CName l -> m (CName l)
    Data,(forall m. Monoid m => CName m -> m)
    -> (forall m a. Monoid m => (a -> m) -> CName a -> m)
    -> (forall m a. Monoid m => (a -> m) -> CName a -> m)
    -> (forall a b. (a -> b -> b) -> b -> CName a -> b)
    -> (forall a b. (a -> b -> b) -> b -> CName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> CName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> CName a -> b)
    -> (forall a. (a -> a -> a) -> CName a -> a)
    -> (forall a. (a -> a -> a) -> CName a -> a)
    -> (forall a. CName a -> [a])
    -> (forall a. CName a -> Bool)
    -> (forall a. CName a -> Int)
    -> (forall a. Eq a => a -> CName a -> Bool)
    -> (forall a. Ord a => CName a -> a)
    -> (forall a. Ord a => CName a -> a)
    -> (forall a. Num a => CName a -> a)
    -> (forall a. Num a => CName a -> a)
    -> Foldable CName
    forall a. Eq a => a -> CName a -> Bool
    forall a. Num a => CName a -> a
    forall a. Ord a => CName a -> a
    forall m. Monoid m => CName m -> m
    forall a. CName a -> Bool
    forall a. CName a -> Int
    forall a. CName a -> [a]
    forall a. (a -> a -> a) -> CName a -> a
    forall m a. Monoid m => (a -> m) -> CName a -> m
    forall b a. (b -> a -> b) -> b -> CName a -> b
    forall a b. (a -> b -> b) -> b -> CName a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => CName m -> m
    fold :: forall m. Monoid m => CName m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> CName a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> CName a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> CName a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> CName a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> CName a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> CName a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> CName a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> CName a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> CName a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> CName a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> CName a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> CName a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> CName a -> a
    foldr1 :: forall a. (a -> a -> a) -> CName a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> CName a -> a
    foldl1 :: forall a. (a -> a -> a) -> CName a -> a
    $ctoList :: forall a. CName a -> [a]
    toList :: forall a. CName a -> [a]
    $cnull :: forall a. CName a -> Bool
    null :: forall a. CName a -> Bool
    $clength :: forall a. CName a -> Int
    length :: forall a. CName a -> Int
    $celem :: forall a. Eq a => a -> CName a -> Bool
    elem :: forall a. Eq a => a -> CName a -> Bool
    $cmaximum :: forall a. Ord a => CName a -> a
    maximum :: forall a. Ord a => CName a -> a
    $cminimum :: forall a. Ord a => CName a -> a
    minimum :: forall a. Ord a => CName a -> a
    $csum :: forall a. Num a => CName a -> a
    sum :: forall a. Num a => CName a -> a
    $cproduct :: forall a. Num a => CName a -> a
    product :: forall a. Num a => CName a -> a
    Foldable,Functor CName
    Foldable CName
    (Functor CName, Foldable CName) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> CName a -> f (CName b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        CName (f a) -> f (CName a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> CName a -> m (CName b))
    -> (forall (m :: * -> *) a. Monad m => CName (m a) -> m (CName a))
    -> Traversable CName
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => CName (m a) -> m (CName a)
    forall (f :: * -> *) a. Applicative f => CName (f a) -> f (CName a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CName a -> m (CName b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CName a -> f (CName b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CName a -> f (CName b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CName a -> f (CName b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => CName (f a) -> f (CName a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => CName (f a) -> f (CName a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CName a -> m (CName b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CName a -> m (CName b)
    $csequence :: forall (m :: * -> *) a. Monad m => CName (m a) -> m (CName a)
    sequence :: forall (m :: * -> *) a. Monad m => CName (m a) -> m (CName a)
    Traversable,(forall a b. (a -> b) -> CName a -> CName b)
    -> (forall a b. a -> CName b -> CName a) -> Functor CName
    forall a b. a -> CName b -> CName a
    forall a b. (a -> b) -> CName a -> CName b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> CName a -> CName b
    fmap :: forall a b. (a -> b) -> CName a -> CName b
    $c<$ :: forall a b. a -> CName b -> CName a
    <$ :: forall a b. a -> CName b -> CName a
    Functor,(forall x. CName l -> Rep (CName l) x)
    -> (forall x. Rep (CName l) x -> CName l) -> Generic (CName l)
    forall x. Rep (CName l) x -> CName l
    forall x. CName l -> Rep (CName l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (CName l) x -> CName l
    forall l x. CName l -> Rep (CName l) x
    $cfrom :: forall l x. CName l -> Rep (CName l) x
    from :: forall x. CName l -> Rep (CName l) x
    $cto :: forall l x. Rep (CName l) x -> CName l
    to :: forall x. Rep (CName l) x -> CName l
    Generic)

    -- | A complete Haskell source module.
    data Module l
        = Module l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]
        -- ^ an ordinary Haskell module
        | XmlPage l (ModuleName l) [ModulePragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
        -- ^ a module consisting of a single XML document. The ModuleName never appears in the source
        --   but is needed for semantic purposes, it will be the same as the file name.
        | XmlHybrid l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]
                    (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
        -- ^ a hybrid module combining an XML document with an ordinary module
      deriving (Module l -> Module l -> Bool
    (Module l -> Module l -> Bool)
    -> (Module l -> Module l -> Bool) -> Eq (Module l)
    forall l. Eq l => Module l -> Module l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Module l -> Module l -> Bool
    == :: Module l -> Module l -> Bool
    $c/= :: forall l. Eq l => Module l -> Module l -> Bool
    /= :: Module l -> Module l -> Bool
    Eq,Eq (Module l)
    Eq (Module l) =>
    (Module l -> Module l -> Ordering)
    -> (Module l -> Module l -> Bool)
    -> (Module l -> Module l -> Bool)
    -> (Module l -> Module l -> Bool)
    -> (Module l -> Module l -> Bool)
    -> (Module l -> Module l -> Module l)
    -> (Module l -> Module l -> Module l)
    -> Ord (Module l)
    Module l -> Module l -> Bool
    Module l -> Module l -> Ordering
    Module l -> Module l -> Module l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Module l)
    forall l. Ord l => Module l -> Module l -> Bool
    forall l. Ord l => Module l -> Module l -> Ordering
    forall l. Ord l => Module l -> Module l -> Module l
    $ccompare :: forall l. Ord l => Module l -> Module l -> Ordering
    compare :: Module l -> Module l -> Ordering
    $c< :: forall l. Ord l => Module l -> Module l -> Bool
    < :: Module l -> Module l -> Bool
    $c<= :: forall l. Ord l => Module l -> Module l -> Bool
    <= :: Module l -> Module l -> Bool
    $c> :: forall l. Ord l => Module l -> Module l -> Bool
    > :: Module l -> Module l -> Bool
    $c>= :: forall l. Ord l => Module l -> Module l -> Bool
    >= :: Module l -> Module l -> Bool
    $cmax :: forall l. Ord l => Module l -> Module l -> Module l
    max :: Module l -> Module l -> Module l
    $cmin :: forall l. Ord l => Module l -> Module l -> Module l
    min :: Module l -> Module l -> Module l
    Ord,Int -> Module l -> ShowS
    [Module l] -> ShowS
    Module l -> String
    (Int -> Module l -> ShowS)
    -> (Module l -> String) -> ([Module l] -> ShowS) -> Show (Module l)
    forall l. Show l => Int -> Module l -> ShowS
    forall l. Show l => [Module l] -> ShowS
    forall l. Show l => Module l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Module l -> ShowS
    showsPrec :: Int -> Module l -> ShowS
    $cshow :: forall l. Show l => Module l -> String
    show :: Module l -> String
    $cshowList :: forall l. Show l => [Module l] -> ShowS
    showList :: [Module l] -> ShowS
    Show,Typeable,Typeable (Module l)
    Typeable (Module l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Module l -> c (Module l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Module l))
    -> (Module l -> Constr)
    -> (Module l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Module l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Module l)))
    -> ((forall b. Data b => b -> b) -> Module l -> Module l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Module l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Module l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Module l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Module l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Module l -> m (Module l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Module l -> m (Module l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Module l -> m (Module l))
    -> Data (Module l)
    Module l -> Constr
    Module l -> DataType
    (forall b. Data b => b -> b) -> Module l -> Module l
    forall l. Data l => Typeable (Module l)
    forall l. Data l => Module l -> Constr
    forall l. Data l => Module l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Module l -> Module l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Module l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Module l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Module l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module l -> c (Module l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Module l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Module l -> u
    forall u. (forall d. Data d => d -> u) -> Module l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Module l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module l -> c (Module l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Module l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module l -> c (Module l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module l -> c (Module l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Module l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Module l)
    $ctoConstr :: forall l. Data l => Module l -> Constr
    toConstr :: Module l -> Constr
    $cdataTypeOf :: forall l. Data l => Module l -> DataType
    dataTypeOf :: Module l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Module l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Module l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Module l -> Module l
    gmapT :: (forall b. Data b => b -> b) -> Module l -> Module l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Module l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Module l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Module l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Module l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module l -> m (Module l)
    Data,(forall m. Monoid m => Module m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Module a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Module a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Module a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Module a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Module a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Module a -> b)
    -> (forall a. (a -> a -> a) -> Module a -> a)
    -> (forall a. (a -> a -> a) -> Module a -> a)
    -> (forall a. Module a -> [a])
    -> (forall a. Module a -> Bool)
    -> (forall a. Module a -> Int)
    -> (forall a. Eq a => a -> Module a -> Bool)
    -> (forall a. Ord a => Module a -> a)
    -> (forall a. Ord a => Module a -> a)
    -> (forall a. Num a => Module a -> a)
    -> (forall a. Num a => Module a -> a)
    -> Foldable Module
    forall a. Eq a => a -> Module a -> Bool
    forall a. Num a => Module a -> a
    forall a. Ord a => Module a -> a
    forall m. Monoid m => Module m -> m
    forall a. Module a -> Bool
    forall a. Module a -> Int
    forall a. Module a -> [a]
    forall a. (a -> a -> a) -> Module a -> a
    forall m a. Monoid m => (a -> m) -> Module a -> m
    forall b a. (b -> a -> b) -> b -> Module a -> b
    forall a b. (a -> b -> b) -> b -> Module a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Module m -> m
    fold :: forall m. Monoid m => Module m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Module a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Module a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Module a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Module a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Module a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Module a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Module a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Module a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Module a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Module a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Module a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Module a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Module a -> a
    foldr1 :: forall a. (a -> a -> a) -> Module a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Module a -> a
    foldl1 :: forall a. (a -> a -> a) -> Module a -> a
    $ctoList :: forall a. Module a -> [a]
    toList :: forall a. Module a -> [a]
    $cnull :: forall a. Module a -> Bool
    null :: forall a. Module a -> Bool
    $clength :: forall a. Module a -> Int
    length :: forall a. Module a -> Int
    $celem :: forall a. Eq a => a -> Module a -> Bool
    elem :: forall a. Eq a => a -> Module a -> Bool
    $cmaximum :: forall a. Ord a => Module a -> a
    maximum :: forall a. Ord a => Module a -> a
    $cminimum :: forall a. Ord a => Module a -> a
    minimum :: forall a. Ord a => Module a -> a
    $csum :: forall a. Num a => Module a -> a
    sum :: forall a. Num a => Module a -> a
    $cproduct :: forall a. Num a => Module a -> a
    product :: forall a. Num a => Module a -> a
    Foldable,Functor Module
    Foldable Module
    (Functor Module, Foldable Module) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Module a -> f (Module b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Module (f a) -> f (Module a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Module a -> m (Module b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Module (m a) -> m (Module a))
    -> Traversable Module
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
    forall (f :: * -> *) a.
    Applicative f =>
    Module (f a) -> f (Module a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Module a -> m (Module b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Module a -> f (Module b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Module a -> f (Module b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Module a -> f (Module b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Module (f a) -> f (Module a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Module (f a) -> f (Module a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Module a -> m (Module b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Module a -> m (Module b)
    $csequence :: forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
    sequence :: forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
    Traversable,(forall a b. (a -> b) -> Module a -> Module b)
    -> (forall a b. a -> Module b -> Module a) -> Functor Module
    forall a b. a -> Module b -> Module a
    forall a b. (a -> b) -> Module a -> Module b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Module a -> Module b
    fmap :: forall a b. (a -> b) -> Module a -> Module b
    $c<$ :: forall a b. a -> Module b -> Module a
    <$ :: forall a b. a -> Module b -> Module a
    Functor,(forall x. Module l -> Rep (Module l) x)
    -> (forall x. Rep (Module l) x -> Module l) -> Generic (Module l)
    forall x. Rep (Module l) x -> Module l
    forall x. Module l -> Rep (Module l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Module l) x -> Module l
    forall l x. Module l -> Rep (Module l) x
    $cfrom :: forall l x. Module l -> Rep (Module l) x
    from :: forall x. Module l -> Rep (Module l) x
    $cto :: forall l x. Rep (Module l) x -> Module l
    to :: forall x. Rep (Module l) x -> Module l
    Generic)

    -- | The head of a module, including the name and export specification.
    data ModuleHead l = ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l))
      deriving (ModuleHead l -> ModuleHead l -> Bool
    (ModuleHead l -> ModuleHead l -> Bool)
    -> (ModuleHead l -> ModuleHead l -> Bool) -> Eq (ModuleHead l)
    forall l. Eq l => ModuleHead l -> ModuleHead l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ModuleHead l -> ModuleHead l -> Bool
    == :: ModuleHead l -> ModuleHead l -> Bool
    $c/= :: forall l. Eq l => ModuleHead l -> ModuleHead l -> Bool
    /= :: ModuleHead l -> ModuleHead l -> Bool
    Eq,Eq (ModuleHead l)
    Eq (ModuleHead l) =>
    (ModuleHead l -> ModuleHead l -> Ordering)
    -> (ModuleHead l -> ModuleHead l -> Bool)
    -> (ModuleHead l -> ModuleHead l -> Bool)
    -> (ModuleHead l -> ModuleHead l -> Bool)
    -> (ModuleHead l -> ModuleHead l -> Bool)
    -> (ModuleHead l -> ModuleHead l -> ModuleHead l)
    -> (ModuleHead l -> ModuleHead l -> ModuleHead l)
    -> Ord (ModuleHead l)
    ModuleHead l -> ModuleHead l -> Bool
    ModuleHead l -> ModuleHead l -> Ordering
    ModuleHead l -> ModuleHead l -> ModuleHead l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ModuleHead l)
    forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
    forall l. Ord l => ModuleHead l -> ModuleHead l -> Ordering
    forall l. Ord l => ModuleHead l -> ModuleHead l -> ModuleHead l
    $ccompare :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Ordering
    compare :: ModuleHead l -> ModuleHead l -> Ordering
    $c< :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
    < :: ModuleHead l -> ModuleHead l -> Bool
    $c<= :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
    <= :: ModuleHead l -> ModuleHead l -> Bool
    $c> :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
    > :: ModuleHead l -> ModuleHead l -> Bool
    $c>= :: forall l. Ord l => ModuleHead l -> ModuleHead l -> Bool
    >= :: ModuleHead l -> ModuleHead l -> Bool
    $cmax :: forall l. Ord l => ModuleHead l -> ModuleHead l -> ModuleHead l
    max :: ModuleHead l -> ModuleHead l -> ModuleHead l
    $cmin :: forall l. Ord l => ModuleHead l -> ModuleHead l -> ModuleHead l
    min :: ModuleHead l -> ModuleHead l -> ModuleHead l
    Ord,Int -> ModuleHead l -> ShowS
    [ModuleHead l] -> ShowS
    ModuleHead l -> String
    (Int -> ModuleHead l -> ShowS)
    -> (ModuleHead l -> String)
    -> ([ModuleHead l] -> ShowS)
    -> Show (ModuleHead l)
    forall l. Show l => Int -> ModuleHead l -> ShowS
    forall l. Show l => [ModuleHead l] -> ShowS
    forall l. Show l => ModuleHead l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ModuleHead l -> ShowS
    showsPrec :: Int -> ModuleHead l -> ShowS
    $cshow :: forall l. Show l => ModuleHead l -> String
    show :: ModuleHead l -> String
    $cshowList :: forall l. Show l => [ModuleHead l] -> ShowS
    showList :: [ModuleHead l] -> ShowS
    Show,Typeable,Typeable (ModuleHead l)
    Typeable (ModuleHead l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ModuleHead l))
    -> (ModuleHead l -> Constr)
    -> (ModuleHead l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ModuleHead l)))
    -> ((forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ModuleHead l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l))
    -> Data (ModuleHead l)
    ModuleHead l -> Constr
    ModuleHead l -> DataType
    (forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l
    forall l. Data l => Typeable (ModuleHead l)
    forall l. Data l => ModuleHead l -> Constr
    forall l. Data l => ModuleHead l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ModuleHead l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleHead l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleHead l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u
    forall u. (forall d. Data d => d -> u) -> ModuleHead l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleHead l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleHead l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleHead l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModuleHead l)
    $ctoConstr :: forall l. Data l => ModuleHead l -> Constr
    toConstr :: ModuleHead l -> Constr
    $cdataTypeOf :: forall l. Data l => ModuleHead l -> DataType
    dataTypeOf :: ModuleHead l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleHead l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModuleHead l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l
    gmapT :: (forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ModuleHead l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleHead l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l)
    Data,(forall m. Monoid m => ModuleHead m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ModuleHead a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ModuleHead a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ModuleHead a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ModuleHead a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ModuleHead a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ModuleHead a -> b)
    -> (forall a. (a -> a -> a) -> ModuleHead a -> a)
    -> (forall a. (a -> a -> a) -> ModuleHead a -> a)
    -> (forall a. ModuleHead a -> [a])
    -> (forall a. ModuleHead a -> Bool)
    -> (forall a. ModuleHead a -> Int)
    -> (forall a. Eq a => a -> ModuleHead a -> Bool)
    -> (forall a. Ord a => ModuleHead a -> a)
    -> (forall a. Ord a => ModuleHead a -> a)
    -> (forall a. Num a => ModuleHead a -> a)
    -> (forall a. Num a => ModuleHead a -> a)
    -> Foldable ModuleHead
    forall a. Eq a => a -> ModuleHead a -> Bool
    forall a. Num a => ModuleHead a -> a
    forall a. Ord a => ModuleHead a -> a
    forall m. Monoid m => ModuleHead m -> m
    forall a. ModuleHead a -> Bool
    forall a. ModuleHead a -> Int
    forall a. ModuleHead a -> [a]
    forall a. (a -> a -> a) -> ModuleHead a -> a
    forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
    forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
    forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ModuleHead m -> m
    fold :: forall m. Monoid m => ModuleHead m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ModuleHead a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ModuleHead a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ModuleHead a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ModuleHead a -> a
    foldr1 :: forall a. (a -> a -> a) -> ModuleHead a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ModuleHead a -> a
    foldl1 :: forall a. (a -> a -> a) -> ModuleHead a -> a
    $ctoList :: forall a. ModuleHead a -> [a]
    toList :: forall a. ModuleHead a -> [a]
    $cnull :: forall a. ModuleHead a -> Bool
    null :: forall a. ModuleHead a -> Bool
    $clength :: forall a. ModuleHead a -> Int
    length :: forall a. ModuleHead a -> Int
    $celem :: forall a. Eq a => a -> ModuleHead a -> Bool
    elem :: forall a. Eq a => a -> ModuleHead a -> Bool
    $cmaximum :: forall a. Ord a => ModuleHead a -> a
    maximum :: forall a. Ord a => ModuleHead a -> a
    $cminimum :: forall a. Ord a => ModuleHead a -> a
    minimum :: forall a. Ord a => ModuleHead a -> a
    $csum :: forall a. Num a => ModuleHead a -> a
    sum :: forall a. Num a => ModuleHead a -> a
    $cproduct :: forall a. Num a => ModuleHead a -> a
    product :: forall a. Num a => ModuleHead a -> a
    Foldable,Functor ModuleHead
    Foldable ModuleHead
    (Functor ModuleHead, Foldable ModuleHead) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ModuleHead a -> f (ModuleHead b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ModuleHead (f a) -> f (ModuleHead a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ModuleHead a -> m (ModuleHead b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ModuleHead (m a) -> m (ModuleHead a))
    -> Traversable ModuleHead
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ModuleHead (m a) -> m (ModuleHead a)
    forall (f :: * -> *) a.
    Applicative f =>
    ModuleHead (f a) -> f (ModuleHead a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModuleHead a -> m (ModuleHead b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModuleHead a -> f (ModuleHead b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModuleHead a -> f (ModuleHead b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModuleHead a -> f (ModuleHead b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ModuleHead (f a) -> f (ModuleHead a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ModuleHead (f a) -> f (ModuleHead a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModuleHead a -> m (ModuleHead b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModuleHead a -> m (ModuleHead b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ModuleHead (m a) -> m (ModuleHead a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ModuleHead (m a) -> m (ModuleHead a)
    Traversable,(forall a b. (a -> b) -> ModuleHead a -> ModuleHead b)
    -> (forall a b. a -> ModuleHead b -> ModuleHead a)
    -> Functor ModuleHead
    forall a b. a -> ModuleHead b -> ModuleHead a
    forall a b. (a -> b) -> ModuleHead a -> ModuleHead b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ModuleHead a -> ModuleHead b
    fmap :: forall a b. (a -> b) -> ModuleHead a -> ModuleHead b
    $c<$ :: forall a b. a -> ModuleHead b -> ModuleHead a
    <$ :: forall a b. a -> ModuleHead b -> ModuleHead a
    Functor,(forall x. ModuleHead l -> Rep (ModuleHead l) x)
    -> (forall x. Rep (ModuleHead l) x -> ModuleHead l)
    -> Generic (ModuleHead l)
    forall x. Rep (ModuleHead l) x -> ModuleHead l
    forall x. ModuleHead l -> Rep (ModuleHead l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ModuleHead l) x -> ModuleHead l
    forall l x. ModuleHead l -> Rep (ModuleHead l) x
    $cfrom :: forall l x. ModuleHead l -> Rep (ModuleHead l) x
    from :: forall x. ModuleHead l -> Rep (ModuleHead l) x
    $cto :: forall l x. Rep (ModuleHead l) x -> ModuleHead l
    to :: forall x. Rep (ModuleHead l) x -> ModuleHead l
    Generic)

    -- | An explicit export specification.
    data ExportSpecList l
        = ExportSpecList l [ExportSpec l]
      deriving (ExportSpecList l -> ExportSpecList l -> Bool
    (ExportSpecList l -> ExportSpecList l -> Bool)
    -> (ExportSpecList l -> ExportSpecList l -> Bool)
    -> Eq (ExportSpecList l)
    forall l. Eq l => ExportSpecList l -> ExportSpecList l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ExportSpecList l -> ExportSpecList l -> Bool
    == :: ExportSpecList l -> ExportSpecList l -> Bool
    $c/= :: forall l. Eq l => ExportSpecList l -> ExportSpecList l -> Bool
    /= :: ExportSpecList l -> ExportSpecList l -> Bool
    Eq,Eq (ExportSpecList l)
    Eq (ExportSpecList l) =>
    (ExportSpecList l -> ExportSpecList l -> Ordering)
    -> (ExportSpecList l -> ExportSpecList l -> Bool)
    -> (ExportSpecList l -> ExportSpecList l -> Bool)
    -> (ExportSpecList l -> ExportSpecList l -> Bool)
    -> (ExportSpecList l -> ExportSpecList l -> Bool)
    -> (ExportSpecList l -> ExportSpecList l -> ExportSpecList l)
    -> (ExportSpecList l -> ExportSpecList l -> ExportSpecList l)
    -> Ord (ExportSpecList l)
    ExportSpecList l -> ExportSpecList l -> Bool
    ExportSpecList l -> ExportSpecList l -> Ordering
    ExportSpecList l -> ExportSpecList l -> ExportSpecList l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ExportSpecList l)
    forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
    forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Ordering
    forall l.
    Ord l =>
    ExportSpecList l -> ExportSpecList l -> ExportSpecList l
    $ccompare :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Ordering
    compare :: ExportSpecList l -> ExportSpecList l -> Ordering
    $c< :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
    < :: ExportSpecList l -> ExportSpecList l -> Bool
    $c<= :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
    <= :: ExportSpecList l -> ExportSpecList l -> Bool
    $c> :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
    > :: ExportSpecList l -> ExportSpecList l -> Bool
    $c>= :: forall l. Ord l => ExportSpecList l -> ExportSpecList l -> Bool
    >= :: ExportSpecList l -> ExportSpecList l -> Bool
    $cmax :: forall l.
    Ord l =>
    ExportSpecList l -> ExportSpecList l -> ExportSpecList l
    max :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l
    $cmin :: forall l.
    Ord l =>
    ExportSpecList l -> ExportSpecList l -> ExportSpecList l
    min :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l
    Ord,Int -> ExportSpecList l -> ShowS
    [ExportSpecList l] -> ShowS
    ExportSpecList l -> String
    (Int -> ExportSpecList l -> ShowS)
    -> (ExportSpecList l -> String)
    -> ([ExportSpecList l] -> ShowS)
    -> Show (ExportSpecList l)
    forall l. Show l => Int -> ExportSpecList l -> ShowS
    forall l. Show l => [ExportSpecList l] -> ShowS
    forall l. Show l => ExportSpecList l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ExportSpecList l -> ShowS
    showsPrec :: Int -> ExportSpecList l -> ShowS
    $cshow :: forall l. Show l => ExportSpecList l -> String
    show :: ExportSpecList l -> String
    $cshowList :: forall l. Show l => [ExportSpecList l] -> ShowS
    showList :: [ExportSpecList l] -> ShowS
    Show,Typeable,Typeable (ExportSpecList l)
    Typeable (ExportSpecList l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> ExportSpecList l
     -> c (ExportSpecList l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l))
    -> (ExportSpecList l -> Constr)
    -> (ExportSpecList l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ExportSpecList l)))
    -> ((forall b. Data b => b -> b)
        -> ExportSpecList l -> ExportSpecList l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> ExportSpecList l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> ExportSpecList l -> m (ExportSpecList l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ExportSpecList l -> m (ExportSpecList l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ExportSpecList l -> m (ExportSpecList l))
    -> Data (ExportSpecList l)
    ExportSpecList l -> Constr
    ExportSpecList l -> DataType
    (forall b. Data b => b -> b)
    -> ExportSpecList l -> ExportSpecList l
    forall l. Data l => Typeable (ExportSpecList l)
    forall l. Data l => ExportSpecList l -> Constr
    forall l. Data l => ExportSpecList l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> ExportSpecList l -> ExportSpecList l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ExportSpecList l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpecList l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u
    forall u. (forall d. Data d => d -> u) -> ExportSpecList l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpecList l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l)
    $ctoConstr :: forall l. Data l => ExportSpecList l -> Constr
    toConstr :: ExportSpecList l -> Constr
    $cdataTypeOf :: forall l. Data l => ExportSpecList l -> DataType
    dataTypeOf :: ExportSpecList l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpecList l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpecList l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> ExportSpecList l -> ExportSpecList l
    gmapT :: (forall b. Data b => b -> b)
    -> ExportSpecList l -> ExportSpecList l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ExportSpecList l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ExportSpecList l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExportSpecList l -> m (ExportSpecList l)
    Data,(forall m. Monoid m => ExportSpecList m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b)
    -> (forall a. (a -> a -> a) -> ExportSpecList a -> a)
    -> (forall a. (a -> a -> a) -> ExportSpecList a -> a)
    -> (forall a. ExportSpecList a -> [a])
    -> (forall a. ExportSpecList a -> Bool)
    -> (forall a. ExportSpecList a -> Int)
    -> (forall a. Eq a => a -> ExportSpecList a -> Bool)
    -> (forall a. Ord a => ExportSpecList a -> a)
    -> (forall a. Ord a => ExportSpecList a -> a)
    -> (forall a. Num a => ExportSpecList a -> a)
    -> (forall a. Num a => ExportSpecList a -> a)
    -> Foldable ExportSpecList
    forall a. Eq a => a -> ExportSpecList a -> Bool
    forall a. Num a => ExportSpecList a -> a
    forall a. Ord a => ExportSpecList a -> a
    forall m. Monoid m => ExportSpecList m -> m
    forall a. ExportSpecList a -> Bool
    forall a. ExportSpecList a -> Int
    forall a. ExportSpecList a -> [a]
    forall a. (a -> a -> a) -> ExportSpecList a -> a
    forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
    forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
    forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ExportSpecList m -> m
    fold :: forall m. Monoid m => ExportSpecList m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ExportSpecList a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ExportSpecList a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ExportSpecList a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ExportSpecList a -> a
    foldr1 :: forall a. (a -> a -> a) -> ExportSpecList a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ExportSpecList a -> a
    foldl1 :: forall a. (a -> a -> a) -> ExportSpecList a -> a
    $ctoList :: forall a. ExportSpecList a -> [a]
    toList :: forall a. ExportSpecList a -> [a]
    $cnull :: forall a. ExportSpecList a -> Bool
    null :: forall a. ExportSpecList a -> Bool
    $clength :: forall a. ExportSpecList a -> Int
    length :: forall a. ExportSpecList a -> Int
    $celem :: forall a. Eq a => a -> ExportSpecList a -> Bool
    elem :: forall a. Eq a => a -> ExportSpecList a -> Bool
    $cmaximum :: forall a. Ord a => ExportSpecList a -> a
    maximum :: forall a. Ord a => ExportSpecList a -> a
    $cminimum :: forall a. Ord a => ExportSpecList a -> a
    minimum :: forall a. Ord a => ExportSpecList a -> a
    $csum :: forall a. Num a => ExportSpecList a -> a
    sum :: forall a. Num a => ExportSpecList a -> a
    $cproduct :: forall a. Num a => ExportSpecList a -> a
    product :: forall a. Num a => ExportSpecList a -> a
    Foldable,Functor ExportSpecList
    Foldable ExportSpecList
    (Functor ExportSpecList, Foldable ExportSpecList) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ExportSpecList a -> f (ExportSpecList b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ExportSpecList (f a) -> f (ExportSpecList a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ExportSpecList a -> m (ExportSpecList b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ExportSpecList (m a) -> m (ExportSpecList a))
    -> Traversable ExportSpecList
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ExportSpecList (m a) -> m (ExportSpecList a)
    forall (f :: * -> *) a.
    Applicative f =>
    ExportSpecList (f a) -> f (ExportSpecList a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExportSpecList a -> m (ExportSpecList b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ExportSpecList a -> f (ExportSpecList b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ExportSpecList a -> f (ExportSpecList b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ExportSpecList a -> f (ExportSpecList b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ExportSpecList (f a) -> f (ExportSpecList a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ExportSpecList (f a) -> f (ExportSpecList a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExportSpecList a -> m (ExportSpecList b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExportSpecList a -> m (ExportSpecList b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ExportSpecList (m a) -> m (ExportSpecList a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ExportSpecList (m a) -> m (ExportSpecList a)
    Traversable,(forall a b. (a -> b) -> ExportSpecList a -> ExportSpecList b)
    -> (forall a b. a -> ExportSpecList b -> ExportSpecList a)
    -> Functor ExportSpecList
    forall a b. a -> ExportSpecList b -> ExportSpecList a
    forall a b. (a -> b) -> ExportSpecList a -> ExportSpecList b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ExportSpecList a -> ExportSpecList b
    fmap :: forall a b. (a -> b) -> ExportSpecList a -> ExportSpecList b
    $c<$ :: forall a b. a -> ExportSpecList b -> ExportSpecList a
    <$ :: forall a b. a -> ExportSpecList b -> ExportSpecList a
    Functor,(forall x. ExportSpecList l -> Rep (ExportSpecList l) x)
    -> (forall x. Rep (ExportSpecList l) x -> ExportSpecList l)
    -> Generic (ExportSpecList l)
    forall x. Rep (ExportSpecList l) x -> ExportSpecList l
    forall x. ExportSpecList l -> Rep (ExportSpecList l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ExportSpecList l) x -> ExportSpecList l
    forall l x. ExportSpecList l -> Rep (ExportSpecList l) x
    $cfrom :: forall l x. ExportSpecList l -> Rep (ExportSpecList l) x
    from :: forall x. ExportSpecList l -> Rep (ExportSpecList l) x
    $cto :: forall l x. Rep (ExportSpecList l) x -> ExportSpecList l
    to :: forall x. Rep (ExportSpecList l) x -> ExportSpecList l
    Generic)

    -- | An item in a module's export specification.
    data ExportSpec l
         = EVar l (QName l)                 -- ^ variable.
         | EAbs l (Namespace l) (QName l)   -- ^ @T@:
                                            --   a class or datatype exported abstractly,
                                            --   or a type synonym.
         | EThingWith l (EWildcard l) (QName l) [CName l] -- ^ @T(C_1,...,C_n)@:
                                            --   a class exported with some of its methods, or
                                            --   a datatype exported with some of its constructors.
         | EModuleContents l (ModuleName l) -- ^ @module M@:
                                            --   re-export a module.
      deriving (ExportSpec l -> ExportSpec l -> Bool
    (ExportSpec l -> ExportSpec l -> Bool)
    -> (ExportSpec l -> ExportSpec l -> Bool) -> Eq (ExportSpec l)
    forall l. Eq l => ExportSpec l -> ExportSpec l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ExportSpec l -> ExportSpec l -> Bool
    == :: ExportSpec l -> ExportSpec l -> Bool
    $c/= :: forall l. Eq l => ExportSpec l -> ExportSpec l -> Bool
    /= :: ExportSpec l -> ExportSpec l -> Bool
    Eq,Eq (ExportSpec l)
    Eq (ExportSpec l) =>
    (ExportSpec l -> ExportSpec l -> Ordering)
    -> (ExportSpec l -> ExportSpec l -> Bool)
    -> (ExportSpec l -> ExportSpec l -> Bool)
    -> (ExportSpec l -> ExportSpec l -> Bool)
    -> (ExportSpec l -> ExportSpec l -> Bool)
    -> (ExportSpec l -> ExportSpec l -> ExportSpec l)
    -> (ExportSpec l -> ExportSpec l -> ExportSpec l)
    -> Ord (ExportSpec l)
    ExportSpec l -> ExportSpec l -> Bool
    ExportSpec l -> ExportSpec l -> Ordering
    ExportSpec l -> ExportSpec l -> ExportSpec l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ExportSpec l)
    forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
    forall l. Ord l => ExportSpec l -> ExportSpec l -> Ordering
    forall l. Ord l => ExportSpec l -> ExportSpec l -> ExportSpec l
    $ccompare :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Ordering
    compare :: ExportSpec l -> ExportSpec l -> Ordering
    $c< :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
    < :: ExportSpec l -> ExportSpec l -> Bool
    $c<= :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
    <= :: ExportSpec l -> ExportSpec l -> Bool
    $c> :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
    > :: ExportSpec l -> ExportSpec l -> Bool
    $c>= :: forall l. Ord l => ExportSpec l -> ExportSpec l -> Bool
    >= :: ExportSpec l -> ExportSpec l -> Bool
    $cmax :: forall l. Ord l => ExportSpec l -> ExportSpec l -> ExportSpec l
    max :: ExportSpec l -> ExportSpec l -> ExportSpec l
    $cmin :: forall l. Ord l => ExportSpec l -> ExportSpec l -> ExportSpec l
    min :: ExportSpec l -> ExportSpec l -> ExportSpec l
    Ord,Int -> ExportSpec l -> ShowS
    [ExportSpec l] -> ShowS
    ExportSpec l -> String
    (Int -> ExportSpec l -> ShowS)
    -> (ExportSpec l -> String)
    -> ([ExportSpec l] -> ShowS)
    -> Show (ExportSpec l)
    forall l. Show l => Int -> ExportSpec l -> ShowS
    forall l. Show l => [ExportSpec l] -> ShowS
    forall l. Show l => ExportSpec l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ExportSpec l -> ShowS
    showsPrec :: Int -> ExportSpec l -> ShowS
    $cshow :: forall l. Show l => ExportSpec l -> String
    show :: ExportSpec l -> String
    $cshowList :: forall l. Show l => [ExportSpec l] -> ShowS
    showList :: [ExportSpec l] -> ShowS
    Show,Typeable,Typeable (ExportSpec l)
    Typeable (ExportSpec l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ExportSpec l))
    -> (ExportSpec l -> Constr)
    -> (ExportSpec l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ExportSpec l)))
    -> ((forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ExportSpec l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l))
    -> Data (ExportSpec l)
    ExportSpec l -> Constr
    ExportSpec l -> DataType
    (forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l
    forall l. Data l => Typeable (ExportSpec l)
    forall l. Data l => ExportSpec l -> Constr
    forall l. Data l => ExportSpec l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ExportSpec l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpec l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpec l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u
    forall u. (forall d. Data d => d -> u) -> ExportSpec l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpec l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpec l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpec l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExportSpec l)
    $ctoConstr :: forall l. Data l => ExportSpec l -> Constr
    toConstr :: ExportSpec l -> Constr
    $cdataTypeOf :: forall l. Data l => ExportSpec l -> DataType
    dataTypeOf :: ExportSpec l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpec l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExportSpec l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l
    gmapT :: (forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ExportSpec l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ExportSpec l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l)
    Data,(forall m. Monoid m => ExportSpec m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ExportSpec a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ExportSpec a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ExportSpec a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ExportSpec a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ExportSpec a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ExportSpec a -> b)
    -> (forall a. (a -> a -> a) -> ExportSpec a -> a)
    -> (forall a. (a -> a -> a) -> ExportSpec a -> a)
    -> (forall a. ExportSpec a -> [a])
    -> (forall a. ExportSpec a -> Bool)
    -> (forall a. ExportSpec a -> Int)
    -> (forall a. Eq a => a -> ExportSpec a -> Bool)
    -> (forall a. Ord a => ExportSpec a -> a)
    -> (forall a. Ord a => ExportSpec a -> a)
    -> (forall a. Num a => ExportSpec a -> a)
    -> (forall a. Num a => ExportSpec a -> a)
    -> Foldable ExportSpec
    forall a. Eq a => a -> ExportSpec a -> Bool
    forall a. Num a => ExportSpec a -> a
    forall a. Ord a => ExportSpec a -> a
    forall m. Monoid m => ExportSpec m -> m
    forall a. ExportSpec a -> Bool
    forall a. ExportSpec a -> Int
    forall a. ExportSpec a -> [a]
    forall a. (a -> a -> a) -> ExportSpec a -> a
    forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
    forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
    forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ExportSpec m -> m
    fold :: forall m. Monoid m => ExportSpec m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ExportSpec a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ExportSpec a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ExportSpec a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ExportSpec a -> a
    foldr1 :: forall a. (a -> a -> a) -> ExportSpec a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ExportSpec a -> a
    foldl1 :: forall a. (a -> a -> a) -> ExportSpec a -> a
    $ctoList :: forall a. ExportSpec a -> [a]
    toList :: forall a. ExportSpec a -> [a]
    $cnull :: forall a. ExportSpec a -> Bool
    null :: forall a. ExportSpec a -> Bool
    $clength :: forall a. ExportSpec a -> Int
    length :: forall a. ExportSpec a -> Int
    $celem :: forall a. Eq a => a -> ExportSpec a -> Bool
    elem :: forall a. Eq a => a -> ExportSpec a -> Bool
    $cmaximum :: forall a. Ord a => ExportSpec a -> a
    maximum :: forall a. Ord a => ExportSpec a -> a
    $cminimum :: forall a. Ord a => ExportSpec a -> a
    minimum :: forall a. Ord a => ExportSpec a -> a
    $csum :: forall a. Num a => ExportSpec a -> a
    sum :: forall a. Num a => ExportSpec a -> a
    $cproduct :: forall a. Num a => ExportSpec a -> a
    product :: forall a. Num a => ExportSpec a -> a
    Foldable,Functor ExportSpec
    Foldable ExportSpec
    (Functor ExportSpec, Foldable ExportSpec) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ExportSpec a -> f (ExportSpec b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ExportSpec (f a) -> f (ExportSpec a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ExportSpec a -> m (ExportSpec b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ExportSpec (m a) -> m (ExportSpec a))
    -> Traversable ExportSpec
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ExportSpec (m a) -> m (ExportSpec a)
    forall (f :: * -> *) a.
    Applicative f =>
    ExportSpec (f a) -> f (ExportSpec a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExportSpec a -> m (ExportSpec b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ExportSpec a -> f (ExportSpec b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ExportSpec a -> f (ExportSpec b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ExportSpec a -> f (ExportSpec b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ExportSpec (f a) -> f (ExportSpec a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ExportSpec (f a) -> f (ExportSpec a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExportSpec a -> m (ExportSpec b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExportSpec a -> m (ExportSpec b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ExportSpec (m a) -> m (ExportSpec a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ExportSpec (m a) -> m (ExportSpec a)
    Traversable,(forall a b. (a -> b) -> ExportSpec a -> ExportSpec b)
    -> (forall a b. a -> ExportSpec b -> ExportSpec a)
    -> Functor ExportSpec
    forall a b. a -> ExportSpec b -> ExportSpec a
    forall a b. (a -> b) -> ExportSpec a -> ExportSpec b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ExportSpec a -> ExportSpec b
    fmap :: forall a b. (a -> b) -> ExportSpec a -> ExportSpec b
    $c<$ :: forall a b. a -> ExportSpec b -> ExportSpec a
    <$ :: forall a b. a -> ExportSpec b -> ExportSpec a
    Functor,(forall x. ExportSpec l -> Rep (ExportSpec l) x)
    -> (forall x. Rep (ExportSpec l) x -> ExportSpec l)
    -> Generic (ExportSpec l)
    forall x. Rep (ExportSpec l) x -> ExportSpec l
    forall x. ExportSpec l -> Rep (ExportSpec l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ExportSpec l) x -> ExportSpec l
    forall l x. ExportSpec l -> Rep (ExportSpec l) x
    $cfrom :: forall l x. ExportSpec l -> Rep (ExportSpec l) x
    from :: forall x. ExportSpec l -> Rep (ExportSpec l) x
    $cto :: forall l x. Rep (ExportSpec l) x -> ExportSpec l
    to :: forall x. Rep (ExportSpec l) x -> ExportSpec l
    Generic)

    -- | Indicates the position of the wildcard in an export list
    data EWildcard l = NoWildcard l | EWildcard l Int
      deriving (EWildcard l -> EWildcard l -> Bool
    (EWildcard l -> EWildcard l -> Bool)
    -> (EWildcard l -> EWildcard l -> Bool) -> Eq (EWildcard l)
    forall l. Eq l => EWildcard l -> EWildcard l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => EWildcard l -> EWildcard l -> Bool
    == :: EWildcard l -> EWildcard l -> Bool
    $c/= :: forall l. Eq l => EWildcard l -> EWildcard l -> Bool
    /= :: EWildcard l -> EWildcard l -> Bool
    Eq,Eq (EWildcard l)
    Eq (EWildcard l) =>
    (EWildcard l -> EWildcard l -> Ordering)
    -> (EWildcard l -> EWildcard l -> Bool)
    -> (EWildcard l -> EWildcard l -> Bool)
    -> (EWildcard l -> EWildcard l -> Bool)
    -> (EWildcard l -> EWildcard l -> Bool)
    -> (EWildcard l -> EWildcard l -> EWildcard l)
    -> (EWildcard l -> EWildcard l -> EWildcard l)
    -> Ord (EWildcard l)
    EWildcard l -> EWildcard l -> Bool
    EWildcard l -> EWildcard l -> Ordering
    EWildcard l -> EWildcard l -> EWildcard l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (EWildcard l)
    forall l. Ord l => EWildcard l -> EWildcard l -> Bool
    forall l. Ord l => EWildcard l -> EWildcard l -> Ordering
    forall l. Ord l => EWildcard l -> EWildcard l -> EWildcard l
    $ccompare :: forall l. Ord l => EWildcard l -> EWildcard l -> Ordering
    compare :: EWildcard l -> EWildcard l -> Ordering
    $c< :: forall l. Ord l => EWildcard l -> EWildcard l -> Bool
    < :: EWildcard l -> EWildcard l -> Bool
    $c<= :: forall l. Ord l => EWildcard l -> EWildcard l -> Bool
    <= :: EWildcard l -> EWildcard l -> Bool
    $c> :: forall l. Ord l => EWildcard l -> EWildcard l -> Bool
    > :: EWildcard l -> EWildcard l -> Bool
    $c>= :: forall l. Ord l => EWildcard l -> EWildcard l -> Bool
    >= :: EWildcard l -> EWildcard l -> Bool
    $cmax :: forall l. Ord l => EWildcard l -> EWildcard l -> EWildcard l
    max :: EWildcard l -> EWildcard l -> EWildcard l
    $cmin :: forall l. Ord l => EWildcard l -> EWildcard l -> EWildcard l
    min :: EWildcard l -> EWildcard l -> EWildcard l
    Ord,Int -> EWildcard l -> ShowS
    [EWildcard l] -> ShowS
    EWildcard l -> String
    (Int -> EWildcard l -> ShowS)
    -> (EWildcard l -> String)
    -> ([EWildcard l] -> ShowS)
    -> Show (EWildcard l)
    forall l. Show l => Int -> EWildcard l -> ShowS
    forall l. Show l => [EWildcard l] -> ShowS
    forall l. Show l => EWildcard l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> EWildcard l -> ShowS
    showsPrec :: Int -> EWildcard l -> ShowS
    $cshow :: forall l. Show l => EWildcard l -> String
    show :: EWildcard l -> String
    $cshowList :: forall l. Show l => [EWildcard l] -> ShowS
    showList :: [EWildcard l] -> ShowS
    Show,Typeable,Typeable (EWildcard l)
    Typeable (EWildcard l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (EWildcard l))
    -> (EWildcard l -> Constr)
    -> (EWildcard l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (EWildcard l)))
    -> ((forall b. Data b => b -> b) -> EWildcard l -> EWildcard l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> EWildcard l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> EWildcard l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l))
    -> Data (EWildcard l)
    EWildcard l -> Constr
    EWildcard l -> DataType
    (forall b. Data b => b -> b) -> EWildcard l -> EWildcard l
    forall l. Data l => Typeable (EWildcard l)
    forall l. Data l => EWildcard l -> Constr
    forall l. Data l => EWildcard l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> EWildcard l -> EWildcard l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> EWildcard l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> EWildcard l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EWildcard l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EWildcard l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> EWildcard l -> u
    forall u. (forall d. Data d => d -> u) -> EWildcard l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EWildcard l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EWildcard l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EWildcard l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EWildcard l)
    $ctoConstr :: forall l. Data l => EWildcard l -> Constr
    toConstr :: EWildcard l -> Constr
    $cdataTypeOf :: forall l. Data l => EWildcard l -> DataType
    dataTypeOf :: EWildcard l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EWildcard l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EWildcard l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> EWildcard l -> EWildcard l
    gmapT :: (forall b. Data b => b -> b) -> EWildcard l -> EWildcard l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> EWildcard l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> EWildcard l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> EWildcard l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EWildcard l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l)
    Data,(forall m. Monoid m => EWildcard m -> m)
    -> (forall m a. Monoid m => (a -> m) -> EWildcard a -> m)
    -> (forall m a. Monoid m => (a -> m) -> EWildcard a -> m)
    -> (forall a b. (a -> b -> b) -> b -> EWildcard a -> b)
    -> (forall a b. (a -> b -> b) -> b -> EWildcard a -> b)
    -> (forall b a. (b -> a -> b) -> b -> EWildcard a -> b)
    -> (forall b a. (b -> a -> b) -> b -> EWildcard a -> b)
    -> (forall a. (a -> a -> a) -> EWildcard a -> a)
    -> (forall a. (a -> a -> a) -> EWildcard a -> a)
    -> (forall a. EWildcard a -> [a])
    -> (forall a. EWildcard a -> Bool)
    -> (forall a. EWildcard a -> Int)
    -> (forall a. Eq a => a -> EWildcard a -> Bool)
    -> (forall a. Ord a => EWildcard a -> a)
    -> (forall a. Ord a => EWildcard a -> a)
    -> (forall a. Num a => EWildcard a -> a)
    -> (forall a. Num a => EWildcard a -> a)
    -> Foldable EWildcard
    forall a. Eq a => a -> EWildcard a -> Bool
    forall a. Num a => EWildcard a -> a
    forall a. Ord a => EWildcard a -> a
    forall m. Monoid m => EWildcard m -> m
    forall a. EWildcard a -> Bool
    forall a. EWildcard a -> Int
    forall a. EWildcard a -> [a]
    forall a. (a -> a -> a) -> EWildcard a -> a
    forall m a. Monoid m => (a -> m) -> EWildcard a -> m
    forall b a. (b -> a -> b) -> b -> EWildcard a -> b
    forall a b. (a -> b -> b) -> b -> EWildcard a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => EWildcard m -> m
    fold :: forall m. Monoid m => EWildcard m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> EWildcard a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> EWildcard a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> EWildcard a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> EWildcard a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> EWildcard a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> EWildcard a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> EWildcard a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> EWildcard a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> EWildcard a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> EWildcard a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> EWildcard a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> EWildcard a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> EWildcard a -> a
    foldr1 :: forall a. (a -> a -> a) -> EWildcard a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> EWildcard a -> a
    foldl1 :: forall a. (a -> a -> a) -> EWildcard a -> a
    $ctoList :: forall a. EWildcard a -> [a]
    toList :: forall a. EWildcard a -> [a]
    $cnull :: forall a. EWildcard a -> Bool
    null :: forall a. EWildcard a -> Bool
    $clength :: forall a. EWildcard a -> Int
    length :: forall a. EWildcard a -> Int
    $celem :: forall a. Eq a => a -> EWildcard a -> Bool
    elem :: forall a. Eq a => a -> EWildcard a -> Bool
    $cmaximum :: forall a. Ord a => EWildcard a -> a
    maximum :: forall a. Ord a => EWildcard a -> a
    $cminimum :: forall a. Ord a => EWildcard a -> a
    minimum :: forall a. Ord a => EWildcard a -> a
    $csum :: forall a. Num a => EWildcard a -> a
    sum :: forall a. Num a => EWildcard a -> a
    $cproduct :: forall a. Num a => EWildcard a -> a
    product :: forall a. Num a => EWildcard a -> a
    Foldable,Functor EWildcard
    Foldable EWildcard
    (Functor EWildcard, Foldable EWildcard) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> EWildcard a -> f (EWildcard b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        EWildcard (f a) -> f (EWildcard a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> EWildcard a -> m (EWildcard b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        EWildcard (m a) -> m (EWildcard a))
    -> Traversable EWildcard
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    EWildcard (m a) -> m (EWildcard a)
    forall (f :: * -> *) a.
    Applicative f =>
    EWildcard (f a) -> f (EWildcard a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> EWildcard a -> m (EWildcard b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> EWildcard a -> f (EWildcard b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> EWildcard a -> f (EWildcard b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> EWildcard a -> f (EWildcard b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    EWildcard (f a) -> f (EWildcard a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    EWildcard (f a) -> f (EWildcard a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> EWildcard a -> m (EWildcard b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> EWildcard a -> m (EWildcard b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    EWildcard (m a) -> m (EWildcard a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    EWildcard (m a) -> m (EWildcard a)
    Traversable,(forall a b. (a -> b) -> EWildcard a -> EWildcard b)
    -> (forall a b. a -> EWildcard b -> EWildcard a)
    -> Functor EWildcard
    forall a b. a -> EWildcard b -> EWildcard a
    forall a b. (a -> b) -> EWildcard a -> EWildcard b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> EWildcard a -> EWildcard b
    fmap :: forall a b. (a -> b) -> EWildcard a -> EWildcard b
    $c<$ :: forall a b. a -> EWildcard b -> EWildcard a
    <$ :: forall a b. a -> EWildcard b -> EWildcard a
    Functor,(forall x. EWildcard l -> Rep (EWildcard l) x)
    -> (forall x. Rep (EWildcard l) x -> EWildcard l)
    -> Generic (EWildcard l)
    forall x. Rep (EWildcard l) x -> EWildcard l
    forall x. EWildcard l -> Rep (EWildcard l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (EWildcard l) x -> EWildcard l
    forall l x. EWildcard l -> Rep (EWildcard l) x
    $cfrom :: forall l x. EWildcard l -> Rep (EWildcard l) x
    from :: forall x. EWildcard l -> Rep (EWildcard l) x
    $cto :: forall l x. Rep (EWildcard l) x -> EWildcard l
    to :: forall x. Rep (EWildcard l) x -> EWildcard l
    Generic)

    -- | Namespaces for imports/exports.
    data Namespace l = NoNamespace l | TypeNamespace l | PatternNamespace l
      deriving (Namespace l -> Namespace l -> Bool
    (Namespace l -> Namespace l -> Bool)
    -> (Namespace l -> Namespace l -> Bool) -> Eq (Namespace l)
    forall l. Eq l => Namespace l -> Namespace l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Namespace l -> Namespace l -> Bool
    == :: Namespace l -> Namespace l -> Bool
    $c/= :: forall l. Eq l => Namespace l -> Namespace l -> Bool
    /= :: Namespace l -> Namespace l -> Bool
    Eq,Eq (Namespace l)
    Eq (Namespace l) =>
    (Namespace l -> Namespace l -> Ordering)
    -> (Namespace l -> Namespace l -> Bool)
    -> (Namespace l -> Namespace l -> Bool)
    -> (Namespace l -> Namespace l -> Bool)
    -> (Namespace l -> Namespace l -> Bool)
    -> (Namespace l -> Namespace l -> Namespace l)
    -> (Namespace l -> Namespace l -> Namespace l)
    -> Ord (Namespace l)
    Namespace l -> Namespace l -> Bool
    Namespace l -> Namespace l -> Ordering
    Namespace l -> Namespace l -> Namespace l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Namespace l)
    forall l. Ord l => Namespace l -> Namespace l -> Bool
    forall l. Ord l => Namespace l -> Namespace l -> Ordering
    forall l. Ord l => Namespace l -> Namespace l -> Namespace l
    $ccompare :: forall l. Ord l => Namespace l -> Namespace l -> Ordering
    compare :: Namespace l -> Namespace l -> Ordering
    $c< :: forall l. Ord l => Namespace l -> Namespace l -> Bool
    < :: Namespace l -> Namespace l -> Bool
    $c<= :: forall l. Ord l => Namespace l -> Namespace l -> Bool
    <= :: Namespace l -> Namespace l -> Bool
    $c> :: forall l. Ord l => Namespace l -> Namespace l -> Bool
    > :: Namespace l -> Namespace l -> Bool
    $c>= :: forall l. Ord l => Namespace l -> Namespace l -> Bool
    >= :: Namespace l -> Namespace l -> Bool
    $cmax :: forall l. Ord l => Namespace l -> Namespace l -> Namespace l
    max :: Namespace l -> Namespace l -> Namespace l
    $cmin :: forall l. Ord l => Namespace l -> Namespace l -> Namespace l
    min :: Namespace l -> Namespace l -> Namespace l
    Ord,Int -> Namespace l -> ShowS
    [Namespace l] -> ShowS
    Namespace l -> String
    (Int -> Namespace l -> ShowS)
    -> (Namespace l -> String)
    -> ([Namespace l] -> ShowS)
    -> Show (Namespace l)
    forall l. Show l => Int -> Namespace l -> ShowS
    forall l. Show l => [Namespace l] -> ShowS
    forall l. Show l => Namespace l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Namespace l -> ShowS
    showsPrec :: Int -> Namespace l -> ShowS
    $cshow :: forall l. Show l => Namespace l -> String
    show :: Namespace l -> String
    $cshowList :: forall l. Show l => [Namespace l] -> ShowS
    showList :: [Namespace l] -> ShowS
    Show,Typeable,Typeable (Namespace l)
    Typeable (Namespace l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Namespace l -> c (Namespace l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Namespace l))
    -> (Namespace l -> Constr)
    -> (Namespace l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Namespace l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Namespace l)))
    -> ((forall b. Data b => b -> b) -> Namespace l -> Namespace l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Namespace l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Namespace l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Namespace l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Namespace l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l))
    -> Data (Namespace l)
    Namespace l -> Constr
    Namespace l -> DataType
    (forall b. Data b => b -> b) -> Namespace l -> Namespace l
    forall l. Data l => Typeable (Namespace l)
    forall l. Data l => Namespace l -> Constr
    forall l. Data l => Namespace l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Namespace l -> Namespace l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Namespace l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Namespace l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Namespace l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Namespace l -> c (Namespace l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Namespace l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Namespace l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Namespace l -> u
    forall u. (forall d. Data d => d -> u) -> Namespace l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Namespace l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Namespace l -> c (Namespace l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Namespace l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Namespace l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Namespace l -> c (Namespace l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Namespace l -> c (Namespace l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Namespace l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Namespace l)
    $ctoConstr :: forall l. Data l => Namespace l -> Constr
    toConstr :: Namespace l -> Constr
    $cdataTypeOf :: forall l. Data l => Namespace l -> DataType
    dataTypeOf :: Namespace l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Namespace l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Namespace l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Namespace l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Namespace l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Namespace l -> Namespace l
    gmapT :: (forall b. Data b => b -> b) -> Namespace l -> Namespace l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Namespace l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Namespace l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Namespace l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Namespace l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l)
    Data,(forall m. Monoid m => Namespace m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Namespace a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Namespace a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Namespace a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Namespace a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Namespace a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Namespace a -> b)
    -> (forall a. (a -> a -> a) -> Namespace a -> a)
    -> (forall a. (a -> a -> a) -> Namespace a -> a)
    -> (forall a. Namespace a -> [a])
    -> (forall a. Namespace a -> Bool)
    -> (forall a. Namespace a -> Int)
    -> (forall a. Eq a => a -> Namespace a -> Bool)
    -> (forall a. Ord a => Namespace a -> a)
    -> (forall a. Ord a => Namespace a -> a)
    -> (forall a. Num a => Namespace a -> a)
    -> (forall a. Num a => Namespace a -> a)
    -> Foldable Namespace
    forall a. Eq a => a -> Namespace a -> Bool
    forall a. Num a => Namespace a -> a
    forall a. Ord a => Namespace a -> a
    forall m. Monoid m => Namespace m -> m
    forall a. Namespace a -> Bool
    forall a. Namespace a -> Int
    forall a. Namespace a -> [a]
    forall a. (a -> a -> a) -> Namespace a -> a
    forall m a. Monoid m => (a -> m) -> Namespace a -> m
    forall b a. (b -> a -> b) -> b -> Namespace a -> b
    forall a b. (a -> b -> b) -> b -> Namespace a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Namespace m -> m
    fold :: forall m. Monoid m => Namespace m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Namespace a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Namespace a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Namespace a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Namespace a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Namespace a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Namespace a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Namespace a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Namespace a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Namespace a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Namespace a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Namespace a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Namespace a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Namespace a -> a
    foldr1 :: forall a. (a -> a -> a) -> Namespace a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Namespace a -> a
    foldl1 :: forall a. (a -> a -> a) -> Namespace a -> a
    $ctoList :: forall a. Namespace a -> [a]
    toList :: forall a. Namespace a -> [a]
    $cnull :: forall a. Namespace a -> Bool
    null :: forall a. Namespace a -> Bool
    $clength :: forall a. Namespace a -> Int
    length :: forall a. Namespace a -> Int
    $celem :: forall a. Eq a => a -> Namespace a -> Bool
    elem :: forall a. Eq a => a -> Namespace a -> Bool
    $cmaximum :: forall a. Ord a => Namespace a -> a
    maximum :: forall a. Ord a => Namespace a -> a
    $cminimum :: forall a. Ord a => Namespace a -> a
    minimum :: forall a. Ord a => Namespace a -> a
    $csum :: forall a. Num a => Namespace a -> a
    sum :: forall a. Num a => Namespace a -> a
    $cproduct :: forall a. Num a => Namespace a -> a
    product :: forall a. Num a => Namespace a -> a
    Foldable,Functor Namespace
    Foldable Namespace
    (Functor Namespace, Foldable Namespace) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Namespace a -> f (Namespace b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Namespace (f a) -> f (Namespace a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Namespace a -> m (Namespace b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Namespace (m a) -> m (Namespace a))
    -> Traversable Namespace
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    Namespace (m a) -> m (Namespace a)
    forall (f :: * -> *) a.
    Applicative f =>
    Namespace (f a) -> f (Namespace a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Namespace a -> m (Namespace b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Namespace a -> f (Namespace b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Namespace a -> f (Namespace b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Namespace a -> f (Namespace b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Namespace (f a) -> f (Namespace a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Namespace (f a) -> f (Namespace a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Namespace a -> m (Namespace b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Namespace a -> m (Namespace b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    Namespace (m a) -> m (Namespace a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Namespace (m a) -> m (Namespace a)
    Traversable,(forall a b. (a -> b) -> Namespace a -> Namespace b)
    -> (forall a b. a -> Namespace b -> Namespace a)
    -> Functor Namespace
    forall a b. a -> Namespace b -> Namespace a
    forall a b. (a -> b) -> Namespace a -> Namespace b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Namespace a -> Namespace b
    fmap :: forall a b. (a -> b) -> Namespace a -> Namespace b
    $c<$ :: forall a b. a -> Namespace b -> Namespace a
    <$ :: forall a b. a -> Namespace b -> Namespace a
    Functor,(forall x. Namespace l -> Rep (Namespace l) x)
    -> (forall x. Rep (Namespace l) x -> Namespace l)
    -> Generic (Namespace l)
    forall x. Rep (Namespace l) x -> Namespace l
    forall x. Namespace l -> Rep (Namespace l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Namespace l) x -> Namespace l
    forall l x. Namespace l -> Rep (Namespace l) x
    $cfrom :: forall l x. Namespace l -> Rep (Namespace l) x
    from :: forall x. Namespace l -> Rep (Namespace l) x
    $cto :: forall l x. Rep (Namespace l) x -> Namespace l
    to :: forall x. Rep (Namespace l) x -> Namespace l
    Generic)

    -- | An import declaration.
    data ImportDecl l = ImportDecl
        { forall l. ImportDecl l -> l
    importAnn :: l                   -- ^ annotation, used by parser for position of the @import@ keyword.
        , forall l. ImportDecl l -> ModuleName l
    importModule :: ModuleName l     -- ^ name of the module imported.
        , forall l. ImportDecl l -> Bool
    importQualified :: Bool          -- ^ imported @qualified@?
        , forall l. ImportDecl l -> Bool
    importSrc :: Bool                -- ^ imported with @{-\# SOURCE \#-}@?
        , forall l. ImportDecl l -> Bool
    importSafe :: Bool               -- ^ Import @safe@?
        , forall l. ImportDecl l -> Maybe String
    importPkg :: Maybe String        -- ^ imported with explicit package name
        , forall l. ImportDecl l -> Maybe (ModuleName l)
    importAs :: Maybe (ModuleName l) -- ^ optional alias name in an @as@ clause.
        , forall l. ImportDecl l -> Maybe (ImportSpecList l)
    importSpecs :: Maybe (ImportSpecList l)
                -- ^ optional list of import specifications.
        }
      deriving (ImportDecl l -> ImportDecl l -> Bool
    (ImportDecl l -> ImportDecl l -> Bool)
    -> (ImportDecl l -> ImportDecl l -> Bool) -> Eq (ImportDecl l)
    forall l. Eq l => ImportDecl l -> ImportDecl l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ImportDecl l -> ImportDecl l -> Bool
    == :: ImportDecl l -> ImportDecl l -> Bool
    $c/= :: forall l. Eq l => ImportDecl l -> ImportDecl l -> Bool
    /= :: ImportDecl l -> ImportDecl l -> Bool
    Eq,Eq (ImportDecl l)
    Eq (ImportDecl l) =>
    (ImportDecl l -> ImportDecl l -> Ordering)
    -> (ImportDecl l -> ImportDecl l -> Bool)
    -> (ImportDecl l -> ImportDecl l -> Bool)
    -> (ImportDecl l -> ImportDecl l -> Bool)
    -> (ImportDecl l -> ImportDecl l -> Bool)
    -> (ImportDecl l -> ImportDecl l -> ImportDecl l)
    -> (ImportDecl l -> ImportDecl l -> ImportDecl l)
    -> Ord (ImportDecl l)
    ImportDecl l -> ImportDecl l -> Bool
    ImportDecl l -> ImportDecl l -> Ordering
    ImportDecl l -> ImportDecl l -> ImportDecl l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ImportDecl l)
    forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
    forall l. Ord l => ImportDecl l -> ImportDecl l -> Ordering
    forall l. Ord l => ImportDecl l -> ImportDecl l -> ImportDecl l
    $ccompare :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Ordering
    compare :: ImportDecl l -> ImportDecl l -> Ordering
    $c< :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
    < :: ImportDecl l -> ImportDecl l -> Bool
    $c<= :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
    <= :: ImportDecl l -> ImportDecl l -> Bool
    $c> :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
    > :: ImportDecl l -> ImportDecl l -> Bool
    $c>= :: forall l. Ord l => ImportDecl l -> ImportDecl l -> Bool
    >= :: ImportDecl l -> ImportDecl l -> Bool
    $cmax :: forall l. Ord l => ImportDecl l -> ImportDecl l -> ImportDecl l
    max :: ImportDecl l -> ImportDecl l -> ImportDecl l
    $cmin :: forall l. Ord l => ImportDecl l -> ImportDecl l -> ImportDecl l
    min :: ImportDecl l -> ImportDecl l -> ImportDecl l
    Ord,Int -> ImportDecl l -> ShowS
    [ImportDecl l] -> ShowS
    ImportDecl l -> String
    (Int -> ImportDecl l -> ShowS)
    -> (ImportDecl l -> String)
    -> ([ImportDecl l] -> ShowS)
    -> Show (ImportDecl l)
    forall l. Show l => Int -> ImportDecl l -> ShowS
    forall l. Show l => [ImportDecl l] -> ShowS
    forall l. Show l => ImportDecl l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ImportDecl l -> ShowS
    showsPrec :: Int -> ImportDecl l -> ShowS
    $cshow :: forall l. Show l => ImportDecl l -> String
    show :: ImportDecl l -> String
    $cshowList :: forall l. Show l => [ImportDecl l] -> ShowS
    showList :: [ImportDecl l] -> ShowS
    Show,Typeable,Typeable (ImportDecl l)
    Typeable (ImportDecl l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ImportDecl l))
    -> (ImportDecl l -> Constr)
    -> (ImportDecl l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ImportDecl l)))
    -> ((forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ImportDecl l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l))
    -> Data (ImportDecl l)
    ImportDecl l -> Constr
    ImportDecl l -> DataType
    (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l
    forall l. Data l => Typeable (ImportDecl l)
    forall l. Data l => ImportDecl l -> Constr
    forall l. Data l => ImportDecl l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ImportDecl l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportDecl l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u
    forall u. (forall d. Data d => d -> u) -> ImportDecl l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportDecl l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportDecl l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportDecl l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportDecl l)
    $ctoConstr :: forall l. Data l => ImportDecl l -> Constr
    toConstr :: ImportDecl l -> Constr
    $cdataTypeOf :: forall l. Data l => ImportDecl l -> DataType
    dataTypeOf :: ImportDecl l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportDecl l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportDecl l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l
    gmapT :: (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ImportDecl l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportDecl l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)
    Data,(forall m. Monoid m => ImportDecl m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ImportDecl a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ImportDecl a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ImportDecl a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ImportDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ImportDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ImportDecl a -> b)
    -> (forall a. (a -> a -> a) -> ImportDecl a -> a)
    -> (forall a. (a -> a -> a) -> ImportDecl a -> a)
    -> (forall a. ImportDecl a -> [a])
    -> (forall l. ImportDecl l -> Bool)
    -> (forall a. ImportDecl a -> Int)
    -> (forall a. Eq a => a -> ImportDecl a -> Bool)
    -> (forall a. Ord a => ImportDecl a -> a)
    -> (forall a. Ord a => ImportDecl a -> a)
    -> (forall a. Num a => ImportDecl a -> a)
    -> (forall a. Num a => ImportDecl a -> a)
    -> Foldable ImportDecl
    forall a. Eq a => a -> ImportDecl a -> Bool
    forall a. Num a => ImportDecl a -> a
    forall a. Ord a => ImportDecl a -> a
    forall m. Monoid m => ImportDecl m -> m
    forall l. ImportDecl l -> Bool
    forall a. ImportDecl a -> Int
    forall a. ImportDecl a -> [a]
    forall a. (a -> a -> a) -> ImportDecl a -> a
    forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
    forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
    forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ImportDecl m -> m
    fold :: forall m. Monoid m => ImportDecl m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
    foldr1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
    foldl1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
    $ctoList :: forall a. ImportDecl a -> [a]
    toList :: forall a. ImportDecl a -> [a]
    $cnull :: forall l. ImportDecl l -> Bool
    null :: forall l. ImportDecl l -> Bool
    $clength :: forall a. ImportDecl a -> Int
    length :: forall a. ImportDecl a -> Int
    $celem :: forall a. Eq a => a -> ImportDecl a -> Bool
    elem :: forall a. Eq a => a -> ImportDecl a -> Bool
    $cmaximum :: forall a. Ord a => ImportDecl a -> a
    maximum :: forall a. Ord a => ImportDecl a -> a
    $cminimum :: forall a. Ord a => ImportDecl a -> a
    minimum :: forall a. Ord a => ImportDecl a -> a
    $csum :: forall a. Num a => ImportDecl a -> a
    sum :: forall a. Num a => ImportDecl a -> a
    $cproduct :: forall a. Num a => ImportDecl a -> a
    product :: forall a. Num a => ImportDecl a -> a
    Foldable,Functor ImportDecl
    Foldable ImportDecl
    (Functor ImportDecl, Foldable ImportDecl) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ImportDecl a -> f (ImportDecl b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ImportDecl (f a) -> f (ImportDecl a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ImportDecl a -> m (ImportDecl b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ImportDecl (m a) -> m (ImportDecl a))
    -> Traversable ImportDecl
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ImportDecl (m a) -> m (ImportDecl a)
    forall (f :: * -> *) a.
    Applicative f =>
    ImportDecl (f a) -> f (ImportDecl a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportDecl a -> m (ImportDecl b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportDecl a -> f (ImportDecl b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportDecl a -> f (ImportDecl b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportDecl a -> f (ImportDecl b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ImportDecl (f a) -> f (ImportDecl a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ImportDecl (f a) -> f (ImportDecl a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportDecl a -> m (ImportDecl b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportDecl a -> m (ImportDecl b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ImportDecl (m a) -> m (ImportDecl a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ImportDecl (m a) -> m (ImportDecl a)
    Traversable,(forall a b. (a -> b) -> ImportDecl a -> ImportDecl b)
    -> (forall a b. a -> ImportDecl b -> ImportDecl a)
    -> Functor ImportDecl
    forall a b. a -> ImportDecl b -> ImportDecl a
    forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
    fmap :: forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
    $c<$ :: forall a b. a -> ImportDecl b -> ImportDecl a
    <$ :: forall a b. a -> ImportDecl b -> ImportDecl a
    Functor,(forall x. ImportDecl l -> Rep (ImportDecl l) x)
    -> (forall x. Rep (ImportDecl l) x -> ImportDecl l)
    -> Generic (ImportDecl l)
    forall x. Rep (ImportDecl l) x -> ImportDecl l
    forall x. ImportDecl l -> Rep (ImportDecl l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ImportDecl l) x -> ImportDecl l
    forall l x. ImportDecl l -> Rep (ImportDecl l) x
    $cfrom :: forall l x. ImportDecl l -> Rep (ImportDecl l) x
    from :: forall x. ImportDecl l -> Rep (ImportDecl l) x
    $cto :: forall l x. Rep (ImportDecl l) x -> ImportDecl l
    to :: forall x. Rep (ImportDecl l) x -> ImportDecl l
    Generic)

    -- | An explicit import specification list.
    data ImportSpecList l
        = ImportSpecList l Bool [ImportSpec l]
                -- ^ A list of import specifications.
                -- The 'Bool' is 'True' if the names are excluded
                -- by @hiding@.
      deriving (ImportSpecList l -> ImportSpecList l -> Bool
    (ImportSpecList l -> ImportSpecList l -> Bool)
    -> (ImportSpecList l -> ImportSpecList l -> Bool)
    -> Eq (ImportSpecList l)
    forall l. Eq l => ImportSpecList l -> ImportSpecList l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ImportSpecList l -> ImportSpecList l -> Bool
    == :: ImportSpecList l -> ImportSpecList l -> Bool
    $c/= :: forall l. Eq l => ImportSpecList l -> ImportSpecList l -> Bool
    /= :: ImportSpecList l -> ImportSpecList l -> Bool
    Eq,Eq (ImportSpecList l)
    Eq (ImportSpecList l) =>
    (ImportSpecList l -> ImportSpecList l -> Ordering)
    -> (ImportSpecList l -> ImportSpecList l -> Bool)
    -> (ImportSpecList l -> ImportSpecList l -> Bool)
    -> (ImportSpecList l -> ImportSpecList l -> Bool)
    -> (ImportSpecList l -> ImportSpecList l -> Bool)
    -> (ImportSpecList l -> ImportSpecList l -> ImportSpecList l)
    -> (ImportSpecList l -> ImportSpecList l -> ImportSpecList l)
    -> Ord (ImportSpecList l)
    ImportSpecList l -> ImportSpecList l -> Bool
    ImportSpecList l -> ImportSpecList l -> Ordering
    ImportSpecList l -> ImportSpecList l -> ImportSpecList l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ImportSpecList l)
    forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
    forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Ordering
    forall l.
    Ord l =>
    ImportSpecList l -> ImportSpecList l -> ImportSpecList l
    $ccompare :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Ordering
    compare :: ImportSpecList l -> ImportSpecList l -> Ordering
    $c< :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
    < :: ImportSpecList l -> ImportSpecList l -> Bool
    $c<= :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
    <= :: ImportSpecList l -> ImportSpecList l -> Bool
    $c> :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
    > :: ImportSpecList l -> ImportSpecList l -> Bool
    $c>= :: forall l. Ord l => ImportSpecList l -> ImportSpecList l -> Bool
    >= :: ImportSpecList l -> ImportSpecList l -> Bool
    $cmax :: forall l.
    Ord l =>
    ImportSpecList l -> ImportSpecList l -> ImportSpecList l
    max :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l
    $cmin :: forall l.
    Ord l =>
    ImportSpecList l -> ImportSpecList l -> ImportSpecList l
    min :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l
    Ord,Int -> ImportSpecList l -> ShowS
    [ImportSpecList l] -> ShowS
    ImportSpecList l -> String
    (Int -> ImportSpecList l -> ShowS)
    -> (ImportSpecList l -> String)
    -> ([ImportSpecList l] -> ShowS)
    -> Show (ImportSpecList l)
    forall l. Show l => Int -> ImportSpecList l -> ShowS
    forall l. Show l => [ImportSpecList l] -> ShowS
    forall l. Show l => ImportSpecList l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ImportSpecList l -> ShowS
    showsPrec :: Int -> ImportSpecList l -> ShowS
    $cshow :: forall l. Show l => ImportSpecList l -> String
    show :: ImportSpecList l -> String
    $cshowList :: forall l. Show l => [ImportSpecList l] -> ShowS
    showList :: [ImportSpecList l] -> ShowS
    Show,Typeable,Typeable (ImportSpecList l)
    Typeable (ImportSpecList l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> ImportSpecList l
     -> c (ImportSpecList l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l))
    -> (ImportSpecList l -> Constr)
    -> (ImportSpecList l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ImportSpecList l)))
    -> ((forall b. Data b => b -> b)
        -> ImportSpecList l -> ImportSpecList l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> ImportSpecList l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> ImportSpecList l -> m (ImportSpecList l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ImportSpecList l -> m (ImportSpecList l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ImportSpecList l -> m (ImportSpecList l))
    -> Data (ImportSpecList l)
    ImportSpecList l -> Constr
    ImportSpecList l -> DataType
    (forall b. Data b => b -> b)
    -> ImportSpecList l -> ImportSpecList l
    forall l. Data l => Typeable (ImportSpecList l)
    forall l. Data l => ImportSpecList l -> Constr
    forall l. Data l => ImportSpecList l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> ImportSpecList l -> ImportSpecList l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ImportSpecList l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpecList l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u
    forall u. (forall d. Data d => d -> u) -> ImportSpecList l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpecList l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l)
    $ctoConstr :: forall l. Data l => ImportSpecList l -> Constr
    toConstr :: ImportSpecList l -> Constr
    $cdataTypeOf :: forall l. Data l => ImportSpecList l -> DataType
    dataTypeOf :: ImportSpecList l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpecList l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpecList l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> ImportSpecList l -> ImportSpecList l
    gmapT :: (forall b. Data b => b -> b)
    -> ImportSpecList l -> ImportSpecList l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ImportSpecList l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportSpecList l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportSpecList l -> m (ImportSpecList l)
    Data,(forall m. Monoid m => ImportSpecList m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b)
    -> (forall a. (a -> a -> a) -> ImportSpecList a -> a)
    -> (forall a. (a -> a -> a) -> ImportSpecList a -> a)
    -> (forall a. ImportSpecList a -> [a])
    -> (forall a. ImportSpecList a -> Bool)
    -> (forall a. ImportSpecList a -> Int)
    -> (forall a. Eq a => a -> ImportSpecList a -> Bool)
    -> (forall a. Ord a => ImportSpecList a -> a)
    -> (forall a. Ord a => ImportSpecList a -> a)
    -> (forall a. Num a => ImportSpecList a -> a)
    -> (forall a. Num a => ImportSpecList a -> a)
    -> Foldable ImportSpecList
    forall a. Eq a => a -> ImportSpecList a -> Bool
    forall a. Num a => ImportSpecList a -> a
    forall a. Ord a => ImportSpecList a -> a
    forall m. Monoid m => ImportSpecList m -> m
    forall a. ImportSpecList a -> Bool
    forall a. ImportSpecList a -> Int
    forall a. ImportSpecList a -> [a]
    forall a. (a -> a -> a) -> ImportSpecList a -> a
    forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
    forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
    forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ImportSpecList m -> m
    fold :: forall m. Monoid m => ImportSpecList m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ImportSpecList a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ImportSpecList a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ImportSpecList a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ImportSpecList a -> a
    foldr1 :: forall a. (a -> a -> a) -> ImportSpecList a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ImportSpecList a -> a
    foldl1 :: forall a. (a -> a -> a) -> ImportSpecList a -> a
    $ctoList :: forall a. ImportSpecList a -> [a]
    toList :: forall a. ImportSpecList a -> [a]
    $cnull :: forall a. ImportSpecList a -> Bool
    null :: forall a. ImportSpecList a -> Bool
    $clength :: forall a. ImportSpecList a -> Int
    length :: forall a. ImportSpecList a -> Int
    $celem :: forall a. Eq a => a -> ImportSpecList a -> Bool
    elem :: forall a. Eq a => a -> ImportSpecList a -> Bool
    $cmaximum :: forall a. Ord a => ImportSpecList a -> a
    maximum :: forall a. Ord a => ImportSpecList a -> a
    $cminimum :: forall a. Ord a => ImportSpecList a -> a
    minimum :: forall a. Ord a => ImportSpecList a -> a
    $csum :: forall a. Num a => ImportSpecList a -> a
    sum :: forall a. Num a => ImportSpecList a -> a
    $cproduct :: forall a. Num a => ImportSpecList a -> a
    product :: forall a. Num a => ImportSpecList a -> a
    Foldable,Functor ImportSpecList
    Foldable ImportSpecList
    (Functor ImportSpecList, Foldable ImportSpecList) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ImportSpecList a -> f (ImportSpecList b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ImportSpecList (f a) -> f (ImportSpecList a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ImportSpecList a -> m (ImportSpecList b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ImportSpecList (m a) -> m (ImportSpecList a))
    -> Traversable ImportSpecList
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ImportSpecList (m a) -> m (ImportSpecList a)
    forall (f :: * -> *) a.
    Applicative f =>
    ImportSpecList (f a) -> f (ImportSpecList a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportSpecList a -> m (ImportSpecList b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportSpecList a -> f (ImportSpecList b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportSpecList a -> f (ImportSpecList b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportSpecList a -> f (ImportSpecList b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ImportSpecList (f a) -> f (ImportSpecList a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ImportSpecList (f a) -> f (ImportSpecList a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportSpecList a -> m (ImportSpecList b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportSpecList a -> m (ImportSpecList b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ImportSpecList (m a) -> m (ImportSpecList a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ImportSpecList (m a) -> m (ImportSpecList a)
    Traversable,(forall a b. (a -> b) -> ImportSpecList a -> ImportSpecList b)
    -> (forall a b. a -> ImportSpecList b -> ImportSpecList a)
    -> Functor ImportSpecList
    forall a b. a -> ImportSpecList b -> ImportSpecList a
    forall a b. (a -> b) -> ImportSpecList a -> ImportSpecList b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ImportSpecList a -> ImportSpecList b
    fmap :: forall a b. (a -> b) -> ImportSpecList a -> ImportSpecList b
    $c<$ :: forall a b. a -> ImportSpecList b -> ImportSpecList a
    <$ :: forall a b. a -> ImportSpecList b -> ImportSpecList a
    Functor,(forall x. ImportSpecList l -> Rep (ImportSpecList l) x)
    -> (forall x. Rep (ImportSpecList l) x -> ImportSpecList l)
    -> Generic (ImportSpecList l)
    forall x. Rep (ImportSpecList l) x -> ImportSpecList l
    forall x. ImportSpecList l -> Rep (ImportSpecList l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ImportSpecList l) x -> ImportSpecList l
    forall l x. ImportSpecList l -> Rep (ImportSpecList l) x
    $cfrom :: forall l x. ImportSpecList l -> Rep (ImportSpecList l) x
    from :: forall x. ImportSpecList l -> Rep (ImportSpecList l) x
    $cto :: forall l x. Rep (ImportSpecList l) x -> ImportSpecList l
    to :: forall x. Rep (ImportSpecList l) x -> ImportSpecList l
    Generic)

    -- | An import specification, representing a single explicit item imported
    --   (or hidden) from a module.
    data ImportSpec l
         = IVar l (Name l)                  -- ^ variable
         | IAbs l (Namespace l) (Name l)    -- ^ @T@:
                                            --   the name of a class, datatype or type synonym.
         | IThingAll l (Name l)             -- ^ @T(..)@:
                                            --   a class imported with all of its methods, or
                                            --   a datatype imported with all of its constructors.
         | IThingWith l (Name l) [CName l]  -- ^ @T(C_1,...,C_n)@:
                                            --   a class imported with some of its methods, or
                                            --   a datatype imported with some of its constructors.
      deriving (ImportSpec l -> ImportSpec l -> Bool
    (ImportSpec l -> ImportSpec l -> Bool)
    -> (ImportSpec l -> ImportSpec l -> Bool) -> Eq (ImportSpec l)
    forall l. Eq l => ImportSpec l -> ImportSpec l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ImportSpec l -> ImportSpec l -> Bool
    == :: ImportSpec l -> ImportSpec l -> Bool
    $c/= :: forall l. Eq l => ImportSpec l -> ImportSpec l -> Bool
    /= :: ImportSpec l -> ImportSpec l -> Bool
    Eq,Eq (ImportSpec l)
    Eq (ImportSpec l) =>
    (ImportSpec l -> ImportSpec l -> Ordering)
    -> (ImportSpec l -> ImportSpec l -> Bool)
    -> (ImportSpec l -> ImportSpec l -> Bool)
    -> (ImportSpec l -> ImportSpec l -> Bool)
    -> (ImportSpec l -> ImportSpec l -> Bool)
    -> (ImportSpec l -> ImportSpec l -> ImportSpec l)
    -> (ImportSpec l -> ImportSpec l -> ImportSpec l)
    -> Ord (ImportSpec l)
    ImportSpec l -> ImportSpec l -> Bool
    ImportSpec l -> ImportSpec l -> Ordering
    ImportSpec l -> ImportSpec l -> ImportSpec l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ImportSpec l)
    forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
    forall l. Ord l => ImportSpec l -> ImportSpec l -> Ordering
    forall l. Ord l => ImportSpec l -> ImportSpec l -> ImportSpec l
    $ccompare :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Ordering
    compare :: ImportSpec l -> ImportSpec l -> Ordering
    $c< :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
    < :: ImportSpec l -> ImportSpec l -> Bool
    $c<= :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
    <= :: ImportSpec l -> ImportSpec l -> Bool
    $c> :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
    > :: ImportSpec l -> ImportSpec l -> Bool
    $c>= :: forall l. Ord l => ImportSpec l -> ImportSpec l -> Bool
    >= :: ImportSpec l -> ImportSpec l -> Bool
    $cmax :: forall l. Ord l => ImportSpec l -> ImportSpec l -> ImportSpec l
    max :: ImportSpec l -> ImportSpec l -> ImportSpec l
    $cmin :: forall l. Ord l => ImportSpec l -> ImportSpec l -> ImportSpec l
    min :: ImportSpec l -> ImportSpec l -> ImportSpec l
    Ord,Int -> ImportSpec l -> ShowS
    [ImportSpec l] -> ShowS
    ImportSpec l -> String
    (Int -> ImportSpec l -> ShowS)
    -> (ImportSpec l -> String)
    -> ([ImportSpec l] -> ShowS)
    -> Show (ImportSpec l)
    forall l. Show l => Int -> ImportSpec l -> ShowS
    forall l. Show l => [ImportSpec l] -> ShowS
    forall l. Show l => ImportSpec l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ImportSpec l -> ShowS
    showsPrec :: Int -> ImportSpec l -> ShowS
    $cshow :: forall l. Show l => ImportSpec l -> String
    show :: ImportSpec l -> String
    $cshowList :: forall l. Show l => [ImportSpec l] -> ShowS
    showList :: [ImportSpec l] -> ShowS
    Show,Typeable,Typeable (ImportSpec l)
    Typeable (ImportSpec l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ImportSpec l))
    -> (ImportSpec l -> Constr)
    -> (ImportSpec l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ImportSpec l)))
    -> ((forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ImportSpec l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l))
    -> Data (ImportSpec l)
    ImportSpec l -> Constr
    ImportSpec l -> DataType
    (forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l
    forall l. Data l => Typeable (ImportSpec l)
    forall l. Data l => ImportSpec l -> Constr
    forall l. Data l => ImportSpec l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ImportSpec l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpec l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpec l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u
    forall u. (forall d. Data d => d -> u) -> ImportSpec l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpec l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpec l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpec l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ImportSpec l)
    $ctoConstr :: forall l. Data l => ImportSpec l -> Constr
    toConstr :: ImportSpec l -> Constr
    $cdataTypeOf :: forall l. Data l => ImportSpec l -> DataType
    dataTypeOf :: ImportSpec l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpec l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ImportSpec l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l
    gmapT :: (forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ImportSpec l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportSpec l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l)
    Data,(forall m. Monoid m => ImportSpec m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ImportSpec a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ImportSpec a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ImportSpec a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ImportSpec a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ImportSpec a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ImportSpec a -> b)
    -> (forall a. (a -> a -> a) -> ImportSpec a -> a)
    -> (forall a. (a -> a -> a) -> ImportSpec a -> a)
    -> (forall a. ImportSpec a -> [a])
    -> (forall a. ImportSpec a -> Bool)
    -> (forall a. ImportSpec a -> Int)
    -> (forall a. Eq a => a -> ImportSpec a -> Bool)
    -> (forall a. Ord a => ImportSpec a -> a)
    -> (forall a. Ord a => ImportSpec a -> a)
    -> (forall a. Num a => ImportSpec a -> a)
    -> (forall a. Num a => ImportSpec a -> a)
    -> Foldable ImportSpec
    forall a. Eq a => a -> ImportSpec a -> Bool
    forall a. Num a => ImportSpec a -> a
    forall a. Ord a => ImportSpec a -> a
    forall m. Monoid m => ImportSpec m -> m
    forall a. ImportSpec a -> Bool
    forall a. ImportSpec a -> Int
    forall a. ImportSpec a -> [a]
    forall a. (a -> a -> a) -> ImportSpec a -> a
    forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
    forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
    forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ImportSpec m -> m
    fold :: forall m. Monoid m => ImportSpec m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ImportSpec a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ImportSpec a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ImportSpec a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ImportSpec a -> a
    foldr1 :: forall a. (a -> a -> a) -> ImportSpec a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ImportSpec a -> a
    foldl1 :: forall a. (a -> a -> a) -> ImportSpec a -> a
    $ctoList :: forall a. ImportSpec a -> [a]
    toList :: forall a. ImportSpec a -> [a]
    $cnull :: forall a. ImportSpec a -> Bool
    null :: forall a. ImportSpec a -> Bool
    $clength :: forall a. ImportSpec a -> Int
    length :: forall a. ImportSpec a -> Int
    $celem :: forall a. Eq a => a -> ImportSpec a -> Bool
    elem :: forall a. Eq a => a -> ImportSpec a -> Bool
    $cmaximum :: forall a. Ord a => ImportSpec a -> a
    maximum :: forall a. Ord a => ImportSpec a -> a
    $cminimum :: forall a. Ord a => ImportSpec a -> a
    minimum :: forall a. Ord a => ImportSpec a -> a
    $csum :: forall a. Num a => ImportSpec a -> a
    sum :: forall a. Num a => ImportSpec a -> a
    $cproduct :: forall a. Num a => ImportSpec a -> a
    product :: forall a. Num a => ImportSpec a -> a
    Foldable,Functor ImportSpec
    Foldable ImportSpec
    (Functor ImportSpec, Foldable ImportSpec) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ImportSpec a -> f (ImportSpec b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ImportSpec (f a) -> f (ImportSpec a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ImportSpec a -> m (ImportSpec b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ImportSpec (m a) -> m (ImportSpec a))
    -> Traversable ImportSpec
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ImportSpec (m a) -> m (ImportSpec a)
    forall (f :: * -> *) a.
    Applicative f =>
    ImportSpec (f a) -> f (ImportSpec a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportSpec a -> m (ImportSpec b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportSpec a -> f (ImportSpec b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportSpec a -> f (ImportSpec b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ImportSpec a -> f (ImportSpec b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ImportSpec (f a) -> f (ImportSpec a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ImportSpec (f a) -> f (ImportSpec a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportSpec a -> m (ImportSpec b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ImportSpec a -> m (ImportSpec b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ImportSpec (m a) -> m (ImportSpec a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ImportSpec (m a) -> m (ImportSpec a)
    Traversable,(forall a b. (a -> b) -> ImportSpec a -> ImportSpec b)
    -> (forall a b. a -> ImportSpec b -> ImportSpec a)
    -> Functor ImportSpec
    forall a b. a -> ImportSpec b -> ImportSpec a
    forall a b. (a -> b) -> ImportSpec a -> ImportSpec b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ImportSpec a -> ImportSpec b
    fmap :: forall a b. (a -> b) -> ImportSpec a -> ImportSpec b
    $c<$ :: forall a b. a -> ImportSpec b -> ImportSpec a
    <$ :: forall a b. a -> ImportSpec b -> ImportSpec a
    Functor,(forall x. ImportSpec l -> Rep (ImportSpec l) x)
    -> (forall x. Rep (ImportSpec l) x -> ImportSpec l)
    -> Generic (ImportSpec l)
    forall x. Rep (ImportSpec l) x -> ImportSpec l
    forall x. ImportSpec l -> Rep (ImportSpec l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ImportSpec l) x -> ImportSpec l
    forall l x. ImportSpec l -> Rep (ImportSpec l) x
    $cfrom :: forall l x. ImportSpec l -> Rep (ImportSpec l) x
    from :: forall x. ImportSpec l -> Rep (ImportSpec l) x
    $cto :: forall l x. Rep (ImportSpec l) x -> ImportSpec l
    to :: forall x. Rep (ImportSpec l) x -> ImportSpec l
    Generic)

    -- | Associativity of an operator.
    data Assoc l
         = AssocNone  l -- ^ non-associative operator (declared with @infix@)
         | AssocLeft  l -- ^ left-associative operator (declared with @infixl@).
         | AssocRight l -- ^ right-associative operator (declared with @infixr@)
      deriving (Assoc l -> Assoc l -> Bool
    (Assoc l -> Assoc l -> Bool)
    -> (Assoc l -> Assoc l -> Bool) -> Eq (Assoc l)
    forall l. Eq l => Assoc l -> Assoc l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Assoc l -> Assoc l -> Bool
    == :: Assoc l -> Assoc l -> Bool
    $c/= :: forall l. Eq l => Assoc l -> Assoc l -> Bool
    /= :: Assoc l -> Assoc l -> Bool
    Eq,Eq (Assoc l)
    Eq (Assoc l) =>
    (Assoc l -> Assoc l -> Ordering)
    -> (Assoc l -> Assoc l -> Bool)
    -> (Assoc l -> Assoc l -> Bool)
    -> (Assoc l -> Assoc l -> Bool)
    -> (Assoc l -> Assoc l -> Bool)
    -> (Assoc l -> Assoc l -> Assoc l)
    -> (Assoc l -> Assoc l -> Assoc l)
    -> Ord (Assoc l)
    Assoc l -> Assoc l -> Bool
    Assoc l -> Assoc l -> Ordering
    Assoc l -> Assoc l -> Assoc l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Assoc l)
    forall l. Ord l => Assoc l -> Assoc l -> Bool
    forall l. Ord l => Assoc l -> Assoc l -> Ordering
    forall l. Ord l => Assoc l -> Assoc l -> Assoc l
    $ccompare :: forall l. Ord l => Assoc l -> Assoc l -> Ordering
    compare :: Assoc l -> Assoc l -> Ordering
    $c< :: forall l. Ord l => Assoc l -> Assoc l -> Bool
    < :: Assoc l -> Assoc l -> Bool
    $c<= :: forall l. Ord l => Assoc l -> Assoc l -> Bool
    <= :: Assoc l -> Assoc l -> Bool
    $c> :: forall l. Ord l => Assoc l -> Assoc l -> Bool
    > :: Assoc l -> Assoc l -> Bool
    $c>= :: forall l. Ord l => Assoc l -> Assoc l -> Bool
    >= :: Assoc l -> Assoc l -> Bool
    $cmax :: forall l. Ord l => Assoc l -> Assoc l -> Assoc l
    max :: Assoc l -> Assoc l -> Assoc l
    $cmin :: forall l. Ord l => Assoc l -> Assoc l -> Assoc l
    min :: Assoc l -> Assoc l -> Assoc l
    Ord,Int -> Assoc l -> ShowS
    [Assoc l] -> ShowS
    Assoc l -> String
    (Int -> Assoc l -> ShowS)
    -> (Assoc l -> String) -> ([Assoc l] -> ShowS) -> Show (Assoc l)
    forall l. Show l => Int -> Assoc l -> ShowS
    forall l. Show l => [Assoc l] -> ShowS
    forall l. Show l => Assoc l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Assoc l -> ShowS
    showsPrec :: Int -> Assoc l -> ShowS
    $cshow :: forall l. Show l => Assoc l -> String
    show :: Assoc l -> String
    $cshowList :: forall l. Show l => [Assoc l] -> ShowS
    showList :: [Assoc l] -> ShowS
    Show,Typeable,Typeable (Assoc l)
    Typeable (Assoc l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Assoc l -> c (Assoc l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Assoc l))
    -> (Assoc l -> Constr)
    -> (Assoc l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Assoc l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l)))
    -> ((forall b. Data b => b -> b) -> Assoc l -> Assoc l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Assoc l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Assoc l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Assoc l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Assoc l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l))
    -> Data (Assoc l)
    Assoc l -> Constr
    Assoc l -> DataType
    (forall b. Data b => b -> b) -> Assoc l -> Assoc l
    forall l. Data l => Typeable (Assoc l)
    forall l. Data l => Assoc l -> Constr
    forall l. Data l => Assoc l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Assoc l -> Assoc l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Assoc l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Assoc l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Assoc l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Assoc l -> c (Assoc l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Assoc l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Assoc l -> u
    forall u. (forall d. Data d => d -> u) -> Assoc l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Assoc l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Assoc l -> c (Assoc l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Assoc l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Assoc l -> c (Assoc l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Assoc l -> c (Assoc l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Assoc l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Assoc l)
    $ctoConstr :: forall l. Data l => Assoc l -> Constr
    toConstr :: Assoc l -> Constr
    $cdataTypeOf :: forall l. Data l => Assoc l -> DataType
    dataTypeOf :: Assoc l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Assoc l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Assoc l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Assoc l -> Assoc l
    gmapT :: (forall b. Data b => b -> b) -> Assoc l -> Assoc l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Assoc l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Assoc l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Assoc l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Assoc l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Assoc l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l)
    Data,(forall m. Monoid m => Assoc m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Assoc a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Assoc a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Assoc a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Assoc a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Assoc a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Assoc a -> b)
    -> (forall a. (a -> a -> a) -> Assoc a -> a)
    -> (forall a. (a -> a -> a) -> Assoc a -> a)
    -> (forall a. Assoc a -> [a])
    -> (forall a. Assoc a -> Bool)
    -> (forall a. Assoc a -> Int)
    -> (forall a. Eq a => a -> Assoc a -> Bool)
    -> (forall a. Ord a => Assoc a -> a)
    -> (forall a. Ord a => Assoc a -> a)
    -> (forall a. Num a => Assoc a -> a)
    -> (forall a. Num a => Assoc a -> a)
    -> Foldable Assoc
    forall a. Eq a => a -> Assoc a -> Bool
    forall a. Num a => Assoc a -> a
    forall a. Ord a => Assoc a -> a
    forall m. Monoid m => Assoc m -> m
    forall a. Assoc a -> Bool
    forall a. Assoc a -> Int
    forall a. Assoc a -> [a]
    forall a. (a -> a -> a) -> Assoc a -> a
    forall m a. Monoid m => (a -> m) -> Assoc a -> m
    forall b a. (b -> a -> b) -> b -> Assoc a -> b
    forall a b. (a -> b -> b) -> b -> Assoc a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Assoc m -> m
    fold :: forall m. Monoid m => Assoc m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Assoc a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Assoc a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Assoc a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Assoc a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Assoc a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Assoc a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Assoc a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Assoc a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Assoc a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Assoc a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Assoc a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Assoc a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Assoc a -> a
    foldr1 :: forall a. (a -> a -> a) -> Assoc a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Assoc a -> a
    foldl1 :: forall a. (a -> a -> a) -> Assoc a -> a
    $ctoList :: forall a. Assoc a -> [a]
    toList :: forall a. Assoc a -> [a]
    $cnull :: forall a. Assoc a -> Bool
    null :: forall a. Assoc a -> Bool
    $clength :: forall a. Assoc a -> Int
    length :: forall a. Assoc a -> Int
    $celem :: forall a. Eq a => a -> Assoc a -> Bool
    elem :: forall a. Eq a => a -> Assoc a -> Bool
    $cmaximum :: forall a. Ord a => Assoc a -> a
    maximum :: forall a. Ord a => Assoc a -> a
    $cminimum :: forall a. Ord a => Assoc a -> a
    minimum :: forall a. Ord a => Assoc a -> a
    $csum :: forall a. Num a => Assoc a -> a
    sum :: forall a. Num a => Assoc a -> a
    $cproduct :: forall a. Num a => Assoc a -> a
    product :: forall a. Num a => Assoc a -> a
    Foldable,Functor Assoc
    Foldable Assoc
    (Functor Assoc, Foldable Assoc) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Assoc a -> f (Assoc b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Assoc (f a) -> f (Assoc a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Assoc a -> m (Assoc b))
    -> (forall (m :: * -> *) a. Monad m => Assoc (m a) -> m (Assoc a))
    -> Traversable Assoc
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Assoc (m a) -> m (Assoc a)
    forall (f :: * -> *) a. Applicative f => Assoc (f a) -> f (Assoc a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Assoc a -> m (Assoc b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Assoc a -> f (Assoc b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Assoc a -> f (Assoc b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Assoc a -> f (Assoc b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Assoc (f a) -> f (Assoc a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Assoc (f a) -> f (Assoc a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Assoc a -> m (Assoc b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Assoc a -> m (Assoc b)
    $csequence :: forall (m :: * -> *) a. Monad m => Assoc (m a) -> m (Assoc a)
    sequence :: forall (m :: * -> *) a. Monad m => Assoc (m a) -> m (Assoc a)
    Traversable,(forall a b. (a -> b) -> Assoc a -> Assoc b)
    -> (forall a b. a -> Assoc b -> Assoc a) -> Functor Assoc
    forall a b. a -> Assoc b -> Assoc a
    forall a b. (a -> b) -> Assoc a -> Assoc b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Assoc a -> Assoc b
    fmap :: forall a b. (a -> b) -> Assoc a -> Assoc b
    $c<$ :: forall a b. a -> Assoc b -> Assoc a
    <$ :: forall a b. a -> Assoc b -> Assoc a
    Functor,(forall x. Assoc l -> Rep (Assoc l) x)
    -> (forall x. Rep (Assoc l) x -> Assoc l) -> Generic (Assoc l)
    forall x. Rep (Assoc l) x -> Assoc l
    forall x. Assoc l -> Rep (Assoc l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Assoc l) x -> Assoc l
    forall l x. Assoc l -> Rep (Assoc l) x
    $cfrom :: forall l x. Assoc l -> Rep (Assoc l) x
    from :: forall x. Assoc l -> Rep (Assoc l) x
    $cto :: forall l x. Rep (Assoc l) x -> Assoc l
    to :: forall x. Rep (Assoc l) x -> Assoc l
    Generic)

    -- | A top-level declaration.
    data Decl l
         = TypeDecl     l (DeclHead l) (Type l)
         -- ^ A type declaration
         | TypeFamDecl  l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))
         -- ^ A type family declaration
         | ClosedTypeFamDecl  l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) [TypeEqn l]
         -- ^ A closed type family declaration
         | DataDecl     l (DataOrNew l) (Maybe (Context l)) (DeclHead l)                  [QualConDecl l] [Deriving l]
         -- ^ A data OR newtype declaration
         | GDataDecl    l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l]    [Deriving l]
         -- ^ A data OR newtype declaration, GADT style
         | DataFamDecl  l {-data-}      (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))
         -- ^ A data family declaration
         | TypeInsDecl  l (Type l) (Type l)
         -- ^ A type family instance declaration
         | DataInsDecl  l (DataOrNew l) (Type l)                  [QualConDecl l] [Deriving l]
         -- ^ A data family instance declaration
         | GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l]    [Deriving l]
         -- ^ A data family instance declaration, GADT style
         | ClassDecl    l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])
         -- ^ A declaration of a type class
         | InstDecl     l (Maybe (Overlap l)) (InstRule l) (Maybe [InstDecl l])
         -- ^ An declaration of a type class instance
         | DerivDecl    l (Maybe (DerivStrategy l)) (Maybe (Overlap l)) (InstRule l)
         -- ^ A standalone deriving declaration
         | InfixDecl    l (Assoc l) (Maybe Int) [Op l]
         -- ^ A declaration of operator fixity
         | DefaultDecl  l [Type l]
         -- ^ A declaration of default types
         | SpliceDecl   l (Exp l)
         -- ^ A Template Haskell splicing declaration
         | TSpliceDecl  l (Exp l)
         -- ^ A typed Template Haskell splicing declaration
         | TypeSig      l [Name l] (Type l)
         -- ^ A type signature declaration
         | PatSynSig    l [Name l] (Maybe [TyVarBind l]) (Maybe (Context l))
                                   (Maybe [TyVarBind l]) (Maybe (Context l))
                                                         (Type l)
         -- ^ A pattern synonym signature declation
         | FunBind      l [Match l]
         -- ^ A set of function binding clauses
         | PatBind      l (Pat l) (Rhs l) {-where-} (Maybe (Binds l))
         -- ^ A pattern binding
         | PatSyn l (Pat l) (Pat l) (PatternSynDirection l)
         -- ^ A pattern synonym binding
         | ForImp       l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)
         -- ^ A foreign import declaration
         | ForExp       l (CallConv l)                    (Maybe String) (Name l) (Type l)
         -- ^ A foreign export declaration
         | RulePragmaDecl   l [Rule l]
         -- ^ A RULES pragma
         | DeprPragmaDecl   l [([Name l], String)]
         -- ^ A DEPRECATED pragma
         | WarnPragmaDecl   l [([Name l], String)]
         -- ^ A WARNING pragma
         | InlineSig        l Bool (Maybe (Activation l)) (QName l)
         -- ^ An INLINE pragma
         | InlineConlikeSig l      (Maybe (Activation l)) (QName l)
         -- ^ An INLINE CONLIKE pragma
         | SpecSig          l      (Maybe (Activation l)) (QName l) [Type l]
         -- ^ A SPECIALISE pragma
         | SpecInlineSig    l Bool (Maybe (Activation l)) (QName l) [Type l]
         -- ^ A SPECIALISE INLINE pragma
         | InstSig          l      (InstRule l)
         -- ^ A SPECIALISE instance pragma
         | AnnPragma        l (Annotation l)
         -- ^ An ANN pragma
         | MinimalPragma    l (Maybe (BooleanFormula l))
         -- ^ A MINIMAL pragma
         | RoleAnnotDecl    l (QName l) [Role l]
         -- ^ A role annotation
         | CompletePragma l [Name l] (Maybe (QName l))
         -- ^ A COMPLETE pragma
      deriving (Decl l -> Decl l -> Bool
    (Decl l -> Decl l -> Bool)
    -> (Decl l -> Decl l -> Bool) -> Eq (Decl l)
    forall l. Eq l => Decl l -> Decl l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Decl l -> Decl l -> Bool
    == :: Decl l -> Decl l -> Bool
    $c/= :: forall l. Eq l => Decl l -> Decl l -> Bool
    /= :: Decl l -> Decl l -> Bool
    Eq,Eq (Decl l)
    Eq (Decl l) =>
    (Decl l -> Decl l -> Ordering)
    -> (Decl l -> Decl l -> Bool)
    -> (Decl l -> Decl l -> Bool)
    -> (Decl l -> Decl l -> Bool)
    -> (Decl l -> Decl l -> Bool)
    -> (Decl l -> Decl l -> Decl l)
    -> (Decl l -> Decl l -> Decl l)
    -> Ord (Decl l)
    Decl l -> Decl l -> Bool
    Decl l -> Decl l -> Ordering
    Decl l -> Decl l -> Decl l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Decl l)
    forall l. Ord l => Decl l -> Decl l -> Bool
    forall l. Ord l => Decl l -> Decl l -> Ordering
    forall l. Ord l => Decl l -> Decl l -> Decl l
    $ccompare :: forall l. Ord l => Decl l -> Decl l -> Ordering
    compare :: Decl l -> Decl l -> Ordering
    $c< :: forall l. Ord l => Decl l -> Decl l -> Bool
    < :: Decl l -> Decl l -> Bool
    $c<= :: forall l. Ord l => Decl l -> Decl l -> Bool
    <= :: Decl l -> Decl l -> Bool
    $c> :: forall l. Ord l => Decl l -> Decl l -> Bool
    > :: Decl l -> Decl l -> Bool
    $c>= :: forall l. Ord l => Decl l -> Decl l -> Bool
    >= :: Decl l -> Decl l -> Bool
    $cmax :: forall l. Ord l => Decl l -> Decl l -> Decl l
    max :: Decl l -> Decl l -> Decl l
    $cmin :: forall l. Ord l => Decl l -> Decl l -> Decl l
    min :: Decl l -> Decl l -> Decl l
    Ord,Int -> Decl l -> ShowS
    [Decl l] -> ShowS
    Decl l -> String
    (Int -> Decl l -> ShowS)
    -> (Decl l -> String) -> ([Decl l] -> ShowS) -> Show (Decl l)
    forall l. Show l => Int -> Decl l -> ShowS
    forall l. Show l => [Decl l] -> ShowS
    forall l. Show l => Decl l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Decl l -> ShowS
    showsPrec :: Int -> Decl l -> ShowS
    $cshow :: forall l. Show l => Decl l -> String
    show :: Decl l -> String
    $cshowList :: forall l. Show l => [Decl l] -> ShowS
    showList :: [Decl l] -> ShowS
    Show,Typeable,Typeable (Decl l)
    Typeable (Decl l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Decl l -> c (Decl l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Decl l))
    -> (Decl l -> Constr)
    -> (Decl l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Decl l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l)))
    -> ((forall b. Data b => b -> b) -> Decl l -> Decl l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Decl l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Decl l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Decl l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Decl l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Decl l -> m (Decl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Decl l -> m (Decl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Decl l -> m (Decl l))
    -> Data (Decl l)
    Decl l -> Constr
    Decl l -> DataType
    (forall b. Data b => b -> b) -> Decl l -> Decl l
    forall l. Data l => Typeable (Decl l)
    forall l. Data l => Decl l -> Constr
    forall l. Data l => Decl l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Decl l -> Decl l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Decl l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Decl l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Decl l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Decl l -> c (Decl l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Decl l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Decl l -> u
    forall u. (forall d. Data d => d -> u) -> Decl l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Decl l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Decl l -> c (Decl l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Decl l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Decl l -> c (Decl l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Decl l -> c (Decl l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Decl l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Decl l)
    $ctoConstr :: forall l. Data l => Decl l -> Constr
    toConstr :: Decl l -> Constr
    $cdataTypeOf :: forall l. Data l => Decl l -> DataType
    dataTypeOf :: Decl l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Decl l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Decl l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Decl l -> Decl l
    gmapT :: (forall b. Data b => b -> b) -> Decl l -> Decl l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Decl l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Decl l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Decl l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Decl l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Decl l -> m (Decl l)
    Data,(forall m. Monoid m => Decl m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Decl a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Decl a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Decl a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Decl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Decl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Decl a -> b)
    -> (forall a. (a -> a -> a) -> Decl a -> a)
    -> (forall a. (a -> a -> a) -> Decl a -> a)
    -> (forall a. Decl a -> [a])
    -> (forall a. Decl a -> Bool)
    -> (forall a. Decl a -> Int)
    -> (forall a. Eq a => a -> Decl a -> Bool)
    -> (forall a. Ord a => Decl a -> a)
    -> (forall a. Ord a => Decl a -> a)
    -> (forall a. Num a => Decl a -> a)
    -> (forall a. Num a => Decl a -> a)
    -> Foldable Decl
    forall a. Eq a => a -> Decl a -> Bool
    forall a. Num a => Decl a -> a
    forall a. Ord a => Decl a -> a
    forall m. Monoid m => Decl m -> m
    forall a. Decl a -> Bool
    forall a. Decl a -> Int
    forall a. Decl a -> [a]
    forall a. (a -> a -> a) -> Decl a -> a
    forall m a. Monoid m => (a -> m) -> Decl a -> m
    forall b a. (b -> a -> b) -> b -> Decl a -> b
    forall a b. (a -> b -> b) -> b -> Decl a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Decl m -> m
    fold :: forall m. Monoid m => Decl m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Decl a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Decl a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Decl a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Decl a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Decl a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Decl a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Decl a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Decl a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Decl a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Decl a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Decl a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Decl a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Decl a -> a
    foldr1 :: forall a. (a -> a -> a) -> Decl a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Decl a -> a
    foldl1 :: forall a. (a -> a -> a) -> Decl a -> a
    $ctoList :: forall a. Decl a -> [a]
    toList :: forall a. Decl a -> [a]
    $cnull :: forall a. Decl a -> Bool
    null :: forall a. Decl a -> Bool
    $clength :: forall a. Decl a -> Int
    length :: forall a. Decl a -> Int
    $celem :: forall a. Eq a => a -> Decl a -> Bool
    elem :: forall a. Eq a => a -> Decl a -> Bool
    $cmaximum :: forall a. Ord a => Decl a -> a
    maximum :: forall a. Ord a => Decl a -> a
    $cminimum :: forall a. Ord a => Decl a -> a
    minimum :: forall a. Ord a => Decl a -> a
    $csum :: forall a. Num a => Decl a -> a
    sum :: forall a. Num a => Decl a -> a
    $cproduct :: forall a. Num a => Decl a -> a
    product :: forall a. Num a => Decl a -> a
    Foldable,Functor Decl
    Foldable Decl
    (Functor Decl, Foldable Decl) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Decl a -> f (Decl b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Decl (f a) -> f (Decl a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Decl a -> m (Decl b))
    -> (forall (m :: * -> *) a. Monad m => Decl (m a) -> m (Decl a))
    -> Traversable Decl
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Decl (m a) -> m (Decl a)
    forall (f :: * -> *) a. Applicative f => Decl (f a) -> f (Decl a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Decl a -> m (Decl b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Decl a -> f (Decl b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Decl a -> f (Decl b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Decl a -> f (Decl b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Decl (f a) -> f (Decl a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Decl (f a) -> f (Decl a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Decl a -> m (Decl b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Decl a -> m (Decl b)
    $csequence :: forall (m :: * -> *) a. Monad m => Decl (m a) -> m (Decl a)
    sequence :: forall (m :: * -> *) a. Monad m => Decl (m a) -> m (Decl a)
    Traversable,(forall a b. (a -> b) -> Decl a -> Decl b)
    -> (forall a b. a -> Decl b -> Decl a) -> Functor Decl
    forall a b. a -> Decl b -> Decl a
    forall a b. (a -> b) -> Decl a -> Decl b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Decl a -> Decl b
    fmap :: forall a b. (a -> b) -> Decl a -> Decl b
    $c<$ :: forall a b. a -> Decl b -> Decl a
    <$ :: forall a b. a -> Decl b -> Decl a
    Functor,(forall x. Decl l -> Rep (Decl l) x)
    -> (forall x. Rep (Decl l) x -> Decl l) -> Generic (Decl l)
    forall x. Rep (Decl l) x -> Decl l
    forall x. Decl l -> Rep (Decl l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Decl l) x -> Decl l
    forall l x. Decl l -> Rep (Decl l) x
    $cfrom :: forall l x. Decl l -> Rep (Decl l) x
    from :: forall x. Decl l -> Rep (Decl l) x
    $cto :: forall l x. Rep (Decl l) x -> Decl l
    to :: forall x. Rep (Decl l) x -> Decl l
    Generic)

    data  PatternSynDirection l =
          Unidirectional -- ^ A unidirectional pattern synonym with "<-"
        | ImplicitBidirectional  -- ^ A bidirectional pattern synonym with "="
        | ExplicitBidirectional l [Decl l]  -- ^ A birectional pattern synonym with the construction specified.
        deriving (PatternSynDirection l -> PatternSynDirection l -> Bool
    (PatternSynDirection l -> PatternSynDirection l -> Bool)
    -> (PatternSynDirection l -> PatternSynDirection l -> Bool)
    -> Eq (PatternSynDirection l)
    forall l.
    Eq l =>
    PatternSynDirection l -> PatternSynDirection l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l.
    Eq l =>
    PatternSynDirection l -> PatternSynDirection l -> Bool
    == :: PatternSynDirection l -> PatternSynDirection l -> Bool
    $c/= :: forall l.
    Eq l =>
    PatternSynDirection l -> PatternSynDirection l -> Bool
    /= :: PatternSynDirection l -> PatternSynDirection l -> Bool
    Eq, Eq (PatternSynDirection l)
    Eq (PatternSynDirection l) =>
    (PatternSynDirection l -> PatternSynDirection l -> Ordering)
    -> (PatternSynDirection l -> PatternSynDirection l -> Bool)
    -> (PatternSynDirection l -> PatternSynDirection l -> Bool)
    -> (PatternSynDirection l -> PatternSynDirection l -> Bool)
    -> (PatternSynDirection l -> PatternSynDirection l -> Bool)
    -> (PatternSynDirection l
        -> PatternSynDirection l -> PatternSynDirection l)
    -> (PatternSynDirection l
        -> PatternSynDirection l -> PatternSynDirection l)
    -> Ord (PatternSynDirection l)
    PatternSynDirection l -> PatternSynDirection l -> Bool
    PatternSynDirection l -> PatternSynDirection l -> Ordering
    PatternSynDirection l
    -> PatternSynDirection l -> PatternSynDirection l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (PatternSynDirection l)
    forall l.
    Ord l =>
    PatternSynDirection l -> PatternSynDirection l -> Bool
    forall l.
    Ord l =>
    PatternSynDirection l -> PatternSynDirection l -> Ordering
    forall l.
    Ord l =>
    PatternSynDirection l
    -> PatternSynDirection l -> PatternSynDirection l
    $ccompare :: forall l.
    Ord l =>
    PatternSynDirection l -> PatternSynDirection l -> Ordering
    compare :: PatternSynDirection l -> PatternSynDirection l -> Ordering
    $c< :: forall l.
    Ord l =>
    PatternSynDirection l -> PatternSynDirection l -> Bool
    < :: PatternSynDirection l -> PatternSynDirection l -> Bool
    $c<= :: forall l.
    Ord l =>
    PatternSynDirection l -> PatternSynDirection l -> Bool
    <= :: PatternSynDirection l -> PatternSynDirection l -> Bool
    $c> :: forall l.
    Ord l =>
    PatternSynDirection l -> PatternSynDirection l -> Bool
    > :: PatternSynDirection l -> PatternSynDirection l -> Bool
    $c>= :: forall l.
    Ord l =>
    PatternSynDirection l -> PatternSynDirection l -> Bool
    >= :: PatternSynDirection l -> PatternSynDirection l -> Bool
    $cmax :: forall l.
    Ord l =>
    PatternSynDirection l
    -> PatternSynDirection l -> PatternSynDirection l
    max :: PatternSynDirection l
    -> PatternSynDirection l -> PatternSynDirection l
    $cmin :: forall l.
    Ord l =>
    PatternSynDirection l
    -> PatternSynDirection l -> PatternSynDirection l
    min :: PatternSynDirection l
    -> PatternSynDirection l -> PatternSynDirection l
    Ord, Int -> PatternSynDirection l -> ShowS
    [PatternSynDirection l] -> ShowS
    PatternSynDirection l -> String
    (Int -> PatternSynDirection l -> ShowS)
    -> (PatternSynDirection l -> String)
    -> ([PatternSynDirection l] -> ShowS)
    -> Show (PatternSynDirection l)
    forall l. Show l => Int -> PatternSynDirection l -> ShowS
    forall l. Show l => [PatternSynDirection l] -> ShowS
    forall l. Show l => PatternSynDirection l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> PatternSynDirection l -> ShowS
    showsPrec :: Int -> PatternSynDirection l -> ShowS
    $cshow :: forall l. Show l => PatternSynDirection l -> String
    show :: PatternSynDirection l -> String
    $cshowList :: forall l. Show l => [PatternSynDirection l] -> ShowS
    showList :: [PatternSynDirection l] -> ShowS
    Show, Typeable (PatternSynDirection l)
    Typeable (PatternSynDirection l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> PatternSynDirection l
     -> c (PatternSynDirection l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l))
    -> (PatternSynDirection l -> Constr)
    -> (PatternSynDirection l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (PatternSynDirection l)))
    -> ((forall b. Data b => b -> b)
        -> PatternSynDirection l -> PatternSynDirection l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r
        -> (forall d. Data d => d -> r')
        -> PatternSynDirection l
        -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r
        -> (forall d. Data d => d -> r')
        -> PatternSynDirection l
        -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> PatternSynDirection l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> PatternSynDirection l -> m (PatternSynDirection l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> PatternSynDirection l -> m (PatternSynDirection l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> PatternSynDirection l -> m (PatternSynDirection l))
    -> Data (PatternSynDirection l)
    PatternSynDirection l -> Constr
    PatternSynDirection l -> DataType
    (forall b. Data b => b -> b)
    -> PatternSynDirection l -> PatternSynDirection l
    forall l. Data l => Typeable (PatternSynDirection l)
    forall l. Data l => PatternSynDirection l -> Constr
    forall l. Data l => PatternSynDirection l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> PatternSynDirection l -> PatternSynDirection l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> PatternSynDirection l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> PatternSynDirection l
    -> c (PatternSynDirection l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatternSynDirection l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u
    forall u.
    (forall d. Data d => d -> u) -> PatternSynDirection l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> PatternSynDirection l
    -> c (PatternSynDirection l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatternSynDirection l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> PatternSynDirection l
    -> c (PatternSynDirection l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> PatternSynDirection l
    -> c (PatternSynDirection l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l)
    $ctoConstr :: forall l. Data l => PatternSynDirection l -> Constr
    toConstr :: PatternSynDirection l -> Constr
    $cdataTypeOf :: forall l. Data l => PatternSynDirection l -> DataType
    dataTypeOf :: PatternSynDirection l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatternSynDirection l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatternSynDirection l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> PatternSynDirection l -> PatternSynDirection l
    gmapT :: (forall b. Data b => b -> b)
    -> PatternSynDirection l -> PatternSynDirection l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> PatternSynDirection l -> [u]
    gmapQ :: forall u.
    (forall d. Data d => d -> u) -> PatternSynDirection l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PatternSynDirection l -> m (PatternSynDirection l)
    Data, Typeable, (forall m. Monoid m => PatternSynDirection m -> m)
    -> (forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m)
    -> (forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m)
    -> (forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b)
    -> (forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b)
    -> (forall a. (a -> a -> a) -> PatternSynDirection a -> a)
    -> (forall a. (a -> a -> a) -> PatternSynDirection a -> a)
    -> (forall a. PatternSynDirection a -> [a])
    -> (forall a. PatternSynDirection a -> Bool)
    -> (forall a. PatternSynDirection a -> Int)
    -> (forall a. Eq a => a -> PatternSynDirection a -> Bool)
    -> (forall a. Ord a => PatternSynDirection a -> a)
    -> (forall a. Ord a => PatternSynDirection a -> a)
    -> (forall a. Num a => PatternSynDirection a -> a)
    -> (forall a. Num a => PatternSynDirection a -> a)
    -> Foldable PatternSynDirection
    forall a. Eq a => a -> PatternSynDirection a -> Bool
    forall a. Num a => PatternSynDirection a -> a
    forall a. Ord a => PatternSynDirection a -> a
    forall m. Monoid m => PatternSynDirection m -> m
    forall a. PatternSynDirection a -> Bool
    forall a. PatternSynDirection a -> Int
    forall a. PatternSynDirection a -> [a]
    forall a. (a -> a -> a) -> PatternSynDirection a -> a
    forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
    forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
    forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => PatternSynDirection m -> m
    fold :: forall m. Monoid m => PatternSynDirection m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> PatternSynDirection a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> PatternSynDirection a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> PatternSynDirection a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> PatternSynDirection a -> a
    foldr1 :: forall a. (a -> a -> a) -> PatternSynDirection a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> PatternSynDirection a -> a
    foldl1 :: forall a. (a -> a -> a) -> PatternSynDirection a -> a
    $ctoList :: forall a. PatternSynDirection a -> [a]
    toList :: forall a. PatternSynDirection a -> [a]
    $cnull :: forall a. PatternSynDirection a -> Bool
    null :: forall a. PatternSynDirection a -> Bool
    $clength :: forall a. PatternSynDirection a -> Int
    length :: forall a. PatternSynDirection a -> Int
    $celem :: forall a. Eq a => a -> PatternSynDirection a -> Bool
    elem :: forall a. Eq a => a -> PatternSynDirection a -> Bool
    $cmaximum :: forall a. Ord a => PatternSynDirection a -> a
    maximum :: forall a. Ord a => PatternSynDirection a -> a
    $cminimum :: forall a. Ord a => PatternSynDirection a -> a
    minimum :: forall a. Ord a => PatternSynDirection a -> a
    $csum :: forall a. Num a => PatternSynDirection a -> a
    sum :: forall a. Num a => PatternSynDirection a -> a
    $cproduct :: forall a. Num a => PatternSynDirection a -> a
    product :: forall a. Num a => PatternSynDirection a -> a
    Foldable, Functor PatternSynDirection
    Foldable PatternSynDirection
    (Functor PatternSynDirection, Foldable PatternSynDirection) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        PatternSynDirection (f a) -> f (PatternSynDirection a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        PatternSynDirection (m a) -> m (PatternSynDirection a))
    -> Traversable PatternSynDirection
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    PatternSynDirection (m a) -> m (PatternSynDirection a)
    forall (f :: * -> *) a.
    Applicative f =>
    PatternSynDirection (f a) -> f (PatternSynDirection a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PatternSynDirection a -> f (PatternSynDirection b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PatternSynDirection (f a) -> f (PatternSynDirection a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PatternSynDirection (f a) -> f (PatternSynDirection a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PatternSynDirection a -> m (PatternSynDirection b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    PatternSynDirection (m a) -> m (PatternSynDirection a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    PatternSynDirection (m a) -> m (PatternSynDirection a)
    Traversable, (forall a b.
     (a -> b) -> PatternSynDirection a -> PatternSynDirection b)
    -> (forall a b.
        a -> PatternSynDirection b -> PatternSynDirection a)
    -> Functor PatternSynDirection
    forall a b. a -> PatternSynDirection b -> PatternSynDirection a
    forall a b.
    (a -> b) -> PatternSynDirection a -> PatternSynDirection b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b.
    (a -> b) -> PatternSynDirection a -> PatternSynDirection b
    fmap :: forall a b.
    (a -> b) -> PatternSynDirection a -> PatternSynDirection b
    $c<$ :: forall a b. a -> PatternSynDirection b -> PatternSynDirection a
    <$ :: forall a b. a -> PatternSynDirection b -> PatternSynDirection a
    Functor, (forall x. PatternSynDirection l -> Rep (PatternSynDirection l) x)
    -> (forall x.
        Rep (PatternSynDirection l) x -> PatternSynDirection l)
    -> Generic (PatternSynDirection l)
    forall x. Rep (PatternSynDirection l) x -> PatternSynDirection l
    forall x. PatternSynDirection l -> Rep (PatternSynDirection l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (PatternSynDirection l) x -> PatternSynDirection l
    forall l x. PatternSynDirection l -> Rep (PatternSynDirection l) x
    $cfrom :: forall l x. PatternSynDirection l -> Rep (PatternSynDirection l) x
    from :: forall x. PatternSynDirection l -> Rep (PatternSynDirection l) x
    $cto :: forall l x. Rep (PatternSynDirection l) x -> PatternSynDirection l
    to :: forall x. Rep (PatternSynDirection l) x -> PatternSynDirection l
    Generic)

    -- | A type equation as found in closed type families.
    data TypeEqn l = TypeEqn l (Type l) (Type l) deriving (TypeEqn l -> TypeEqn l -> Bool
    (TypeEqn l -> TypeEqn l -> Bool)
    -> (TypeEqn l -> TypeEqn l -> Bool) -> Eq (TypeEqn l)
    forall l. Eq l => TypeEqn l -> TypeEqn l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => TypeEqn l -> TypeEqn l -> Bool
    == :: TypeEqn l -> TypeEqn l -> Bool
    $c/= :: forall l. Eq l => TypeEqn l -> TypeEqn l -> Bool
    /= :: TypeEqn l -> TypeEqn l -> Bool
    Eq,Eq (TypeEqn l)
    Eq (TypeEqn l) =>
    (TypeEqn l -> TypeEqn l -> Ordering)
    -> (TypeEqn l -> TypeEqn l -> Bool)
    -> (TypeEqn l -> TypeEqn l -> Bool)
    -> (TypeEqn l -> TypeEqn l -> Bool)
    -> (TypeEqn l -> TypeEqn l -> Bool)
    -> (TypeEqn l -> TypeEqn l -> TypeEqn l)
    -> (TypeEqn l -> TypeEqn l -> TypeEqn l)
    -> Ord (TypeEqn l)
    TypeEqn l -> TypeEqn l -> Bool
    TypeEqn l -> TypeEqn l -> Ordering
    TypeEqn l -> TypeEqn l -> TypeEqn l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (TypeEqn l)
    forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
    forall l. Ord l => TypeEqn l -> TypeEqn l -> Ordering
    forall l. Ord l => TypeEqn l -> TypeEqn l -> TypeEqn l
    $ccompare :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Ordering
    compare :: TypeEqn l -> TypeEqn l -> Ordering
    $c< :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
    < :: TypeEqn l -> TypeEqn l -> Bool
    $c<= :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
    <= :: TypeEqn l -> TypeEqn l -> Bool
    $c> :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
    > :: TypeEqn l -> TypeEqn l -> Bool
    $c>= :: forall l. Ord l => TypeEqn l -> TypeEqn l -> Bool
    >= :: TypeEqn l -> TypeEqn l -> Bool
    $cmax :: forall l. Ord l => TypeEqn l -> TypeEqn l -> TypeEqn l
    max :: TypeEqn l -> TypeEqn l -> TypeEqn l
    $cmin :: forall l. Ord l => TypeEqn l -> TypeEqn l -> TypeEqn l
    min :: TypeEqn l -> TypeEqn l -> TypeEqn l
    Ord,Int -> TypeEqn l -> ShowS
    [TypeEqn l] -> ShowS
    TypeEqn l -> String
    (Int -> TypeEqn l -> ShowS)
    -> (TypeEqn l -> String)
    -> ([TypeEqn l] -> ShowS)
    -> Show (TypeEqn l)
    forall l. Show l => Int -> TypeEqn l -> ShowS
    forall l. Show l => [TypeEqn l] -> ShowS
    forall l. Show l => TypeEqn l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> TypeEqn l -> ShowS
    showsPrec :: Int -> TypeEqn l -> ShowS
    $cshow :: forall l. Show l => TypeEqn l -> String
    show :: TypeEqn l -> String
    $cshowList :: forall l. Show l => [TypeEqn l] -> ShowS
    showList :: [TypeEqn l] -> ShowS
    Show,Typeable,Typeable (TypeEqn l)
    Typeable (TypeEqn l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (TypeEqn l))
    -> (TypeEqn l -> Constr)
    -> (TypeEqn l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (TypeEqn l)))
    -> ((forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TypeEqn l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l))
    -> Data (TypeEqn l)
    TypeEqn l -> Constr
    TypeEqn l -> DataType
    (forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l
    forall l. Data l => Typeable (TypeEqn l)
    forall l. Data l => TypeEqn l -> Constr
    forall l. Data l => TypeEqn l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> TypeEqn l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TypeEqn l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TypeEqn l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u
    forall u. (forall d. Data d => d -> u) -> TypeEqn l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TypeEqn l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TypeEqn l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TypeEqn l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TypeEqn l)
    $ctoConstr :: forall l. Data l => TypeEqn l -> Constr
    toConstr :: TypeEqn l -> Constr
    $cdataTypeOf :: forall l. Data l => TypeEqn l -> DataType
    dataTypeOf :: TypeEqn l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TypeEqn l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TypeEqn l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l
    gmapT :: (forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> TypeEqn l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeEqn l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l)
    Data,(forall m. Monoid m => TypeEqn m -> m)
    -> (forall m a. Monoid m => (a -> m) -> TypeEqn a -> m)
    -> (forall m a. Monoid m => (a -> m) -> TypeEqn a -> m)
    -> (forall a b. (a -> b -> b) -> b -> TypeEqn a -> b)
    -> (forall a b. (a -> b -> b) -> b -> TypeEqn a -> b)
    -> (forall b a. (b -> a -> b) -> b -> TypeEqn a -> b)
    -> (forall b a. (b -> a -> b) -> b -> TypeEqn a -> b)
    -> (forall a. (a -> a -> a) -> TypeEqn a -> a)
    -> (forall a. (a -> a -> a) -> TypeEqn a -> a)
    -> (forall a. TypeEqn a -> [a])
    -> (forall a. TypeEqn a -> Bool)
    -> (forall a. TypeEqn a -> Int)
    -> (forall a. Eq a => a -> TypeEqn a -> Bool)
    -> (forall a. Ord a => TypeEqn a -> a)
    -> (forall a. Ord a => TypeEqn a -> a)
    -> (forall a. Num a => TypeEqn a -> a)
    -> (forall a. Num a => TypeEqn a -> a)
    -> Foldable TypeEqn
    forall a. Eq a => a -> TypeEqn a -> Bool
    forall a. Num a => TypeEqn a -> a
    forall a. Ord a => TypeEqn a -> a
    forall m. Monoid m => TypeEqn m -> m
    forall a. TypeEqn a -> Bool
    forall a. TypeEqn a -> Int
    forall a. TypeEqn a -> [a]
    forall a. (a -> a -> a) -> TypeEqn a -> a
    forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
    forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
    forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => TypeEqn m -> m
    fold :: forall m. Monoid m => TypeEqn m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> TypeEqn a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> TypeEqn a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> TypeEqn a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> TypeEqn a -> a
    foldr1 :: forall a. (a -> a -> a) -> TypeEqn a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> TypeEqn a -> a
    foldl1 :: forall a. (a -> a -> a) -> TypeEqn a -> a
    $ctoList :: forall a. TypeEqn a -> [a]
    toList :: forall a. TypeEqn a -> [a]
    $cnull :: forall a. TypeEqn a -> Bool
    null :: forall a. TypeEqn a -> Bool
    $clength :: forall a. TypeEqn a -> Int
    length :: forall a. TypeEqn a -> Int
    $celem :: forall a. Eq a => a -> TypeEqn a -> Bool
    elem :: forall a. Eq a => a -> TypeEqn a -> Bool
    $cmaximum :: forall a. Ord a => TypeEqn a -> a
    maximum :: forall a. Ord a => TypeEqn a -> a
    $cminimum :: forall a. Ord a => TypeEqn a -> a
    minimum :: forall a. Ord a => TypeEqn a -> a
    $csum :: forall a. Num a => TypeEqn a -> a
    sum :: forall a. Num a => TypeEqn a -> a
    $cproduct :: forall a. Num a => TypeEqn a -> a
    product :: forall a. Num a => TypeEqn a -> a
    Foldable,Functor TypeEqn
    Foldable TypeEqn
    (Functor TypeEqn, Foldable TypeEqn) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> TypeEqn a -> f (TypeEqn b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        TypeEqn (f a) -> f (TypeEqn a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> TypeEqn a -> m (TypeEqn b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        TypeEqn (m a) -> m (TypeEqn a))
    -> Traversable TypeEqn
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => TypeEqn (m a) -> m (TypeEqn a)
    forall (f :: * -> *) a.
    Applicative f =>
    TypeEqn (f a) -> f (TypeEqn a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TypeEqn a -> m (TypeEqn b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TypeEqn a -> f (TypeEqn b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TypeEqn a -> f (TypeEqn b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TypeEqn a -> f (TypeEqn b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    TypeEqn (f a) -> f (TypeEqn a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    TypeEqn (f a) -> f (TypeEqn a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TypeEqn a -> m (TypeEqn b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TypeEqn a -> m (TypeEqn b)
    $csequence :: forall (m :: * -> *) a. Monad m => TypeEqn (m a) -> m (TypeEqn a)
    sequence :: forall (m :: * -> *) a. Monad m => TypeEqn (m a) -> m (TypeEqn a)
    Traversable,(forall a b. (a -> b) -> TypeEqn a -> TypeEqn b)
    -> (forall a b. a -> TypeEqn b -> TypeEqn a) -> Functor TypeEqn
    forall a b. a -> TypeEqn b -> TypeEqn a
    forall a b. (a -> b) -> TypeEqn a -> TypeEqn b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> TypeEqn a -> TypeEqn b
    fmap :: forall a b. (a -> b) -> TypeEqn a -> TypeEqn b
    $c<$ :: forall a b. a -> TypeEqn b -> TypeEqn a
    <$ :: forall a b. a -> TypeEqn b -> TypeEqn a
    Functor,(forall x. TypeEqn l -> Rep (TypeEqn l) x)
    -> (forall x. Rep (TypeEqn l) x -> TypeEqn l)
    -> Generic (TypeEqn l)
    forall x. Rep (TypeEqn l) x -> TypeEqn l
    forall x. TypeEqn l -> Rep (TypeEqn l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (TypeEqn l) x -> TypeEqn l
    forall l x. TypeEqn l -> Rep (TypeEqn l) x
    $cfrom :: forall l x. TypeEqn l -> Rep (TypeEqn l) x
    from :: forall x. TypeEqn l -> Rep (TypeEqn l) x
    $cto :: forall l x. Rep (TypeEqn l) x -> TypeEqn l
    to :: forall x. Rep (TypeEqn l) x -> TypeEqn l
    Generic)

    -- | An annotation through an ANN pragma.
    data Annotation l
        = Ann       l (Name l)  (Exp l)
        -- ^ An annotation for a declared name.
        | TypeAnn   l (Name l)  (Exp l)
        -- ^ An annotation for a declared type.
        | ModuleAnn l           (Exp l)
        -- ^ An annotation for the defining module.
      deriving (Annotation l -> Annotation l -> Bool
    (Annotation l -> Annotation l -> Bool)
    -> (Annotation l -> Annotation l -> Bool) -> Eq (Annotation l)
    forall l. Eq l => Annotation l -> Annotation l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Annotation l -> Annotation l -> Bool
    == :: Annotation l -> Annotation l -> Bool
    $c/= :: forall l. Eq l => Annotation l -> Annotation l -> Bool
    /= :: Annotation l -> Annotation l -> Bool
    Eq,Eq (Annotation l)
    Eq (Annotation l) =>
    (Annotation l -> Annotation l -> Ordering)
    -> (Annotation l -> Annotation l -> Bool)
    -> (Annotation l -> Annotation l -> Bool)
    -> (Annotation l -> Annotation l -> Bool)
    -> (Annotation l -> Annotation l -> Bool)
    -> (Annotation l -> Annotation l -> Annotation l)
    -> (Annotation l -> Annotation l -> Annotation l)
    -> Ord (Annotation l)
    Annotation l -> Annotation l -> Bool
    Annotation l -> Annotation l -> Ordering
    Annotation l -> Annotation l -> Annotation l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Annotation l)
    forall l. Ord l => Annotation l -> Annotation l -> Bool
    forall l. Ord l => Annotation l -> Annotation l -> Ordering
    forall l. Ord l => Annotation l -> Annotation l -> Annotation l
    $ccompare :: forall l. Ord l => Annotation l -> Annotation l -> Ordering
    compare :: Annotation l -> Annotation l -> Ordering
    $c< :: forall l. Ord l => Annotation l -> Annotation l -> Bool
    < :: Annotation l -> Annotation l -> Bool
    $c<= :: forall l. Ord l => Annotation l -> Annotation l -> Bool
    <= :: Annotation l -> Annotation l -> Bool
    $c> :: forall l. Ord l => Annotation l -> Annotation l -> Bool
    > :: Annotation l -> Annotation l -> Bool
    $c>= :: forall l. Ord l => Annotation l -> Annotation l -> Bool
    >= :: Annotation l -> Annotation l -> Bool
    $cmax :: forall l. Ord l => Annotation l -> Annotation l -> Annotation l
    max :: Annotation l -> Annotation l -> Annotation l
    $cmin :: forall l. Ord l => Annotation l -> Annotation l -> Annotation l
    min :: Annotation l -> Annotation l -> Annotation l
    Ord,Int -> Annotation l -> ShowS
    [Annotation l] -> ShowS
    Annotation l -> String
    (Int -> Annotation l -> ShowS)
    -> (Annotation l -> String)
    -> ([Annotation l] -> ShowS)
    -> Show (Annotation l)
    forall l. Show l => Int -> Annotation l -> ShowS
    forall l. Show l => [Annotation l] -> ShowS
    forall l. Show l => Annotation l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Annotation l -> ShowS
    showsPrec :: Int -> Annotation l -> ShowS
    $cshow :: forall l. Show l => Annotation l -> String
    show :: Annotation l -> String
    $cshowList :: forall l. Show l => [Annotation l] -> ShowS
    showList :: [Annotation l] -> ShowS
    Show,Typeable,Typeable (Annotation l)
    Typeable (Annotation l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Annotation l -> c (Annotation l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Annotation l))
    -> (Annotation l -> Constr)
    -> (Annotation l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Annotation l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Annotation l)))
    -> ((forall b. Data b => b -> b) -> Annotation l -> Annotation l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Annotation l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Annotation l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Annotation l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Annotation l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l))
    -> Data (Annotation l)
    Annotation l -> Constr
    Annotation l -> DataType
    (forall b. Data b => b -> b) -> Annotation l -> Annotation l
    forall l. Data l => Typeable (Annotation l)
    forall l. Data l => Annotation l -> Constr
    forall l. Data l => Annotation l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Annotation l -> Annotation l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Annotation l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Annotation l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Annotation l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Annotation l -> c (Annotation l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Annotation l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Annotation l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Annotation l -> u
    forall u. (forall d. Data d => d -> u) -> Annotation l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Annotation l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Annotation l -> c (Annotation l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Annotation l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Annotation l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Annotation l -> c (Annotation l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Annotation l -> c (Annotation l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Annotation l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Annotation l)
    $ctoConstr :: forall l. Data l => Annotation l -> Constr
    toConstr :: Annotation l -> Constr
    $cdataTypeOf :: forall l. Data l => Annotation l -> DataType
    dataTypeOf :: Annotation l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Annotation l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Annotation l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Annotation l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Annotation l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Annotation l -> Annotation l
    gmapT :: (forall b. Data b => b -> b) -> Annotation l -> Annotation l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Annotation l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Annotation l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Annotation l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Annotation l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l)
    Data,(forall m. Monoid m => Annotation m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Annotation a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Annotation a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Annotation a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Annotation a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Annotation a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Annotation a -> b)
    -> (forall a. (a -> a -> a) -> Annotation a -> a)
    -> (forall a. (a -> a -> a) -> Annotation a -> a)
    -> (forall a. Annotation a -> [a])
    -> (forall a. Annotation a -> Bool)
    -> (forall a. Annotation a -> Int)
    -> (forall a. Eq a => a -> Annotation a -> Bool)
    -> (forall a. Ord a => Annotation a -> a)
    -> (forall a. Ord a => Annotation a -> a)
    -> (forall a. Num a => Annotation a -> a)
    -> (forall a. Num a => Annotation a -> a)
    -> Foldable Annotation
    forall a. Eq a => a -> Annotation a -> Bool
    forall a. Num a => Annotation a -> a
    forall a. Ord a => Annotation a -> a
    forall m. Monoid m => Annotation m -> m
    forall a. Annotation a -> Bool
    forall a. Annotation a -> Int
    forall a. Annotation a -> [a]
    forall a. (a -> a -> a) -> Annotation a -> a
    forall m a. Monoid m => (a -> m) -> Annotation a -> m
    forall b a. (b -> a -> b) -> b -> Annotation a -> b
    forall a b. (a -> b -> b) -> b -> Annotation a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Annotation m -> m
    fold :: forall m. Monoid m => Annotation m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Annotation a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Annotation a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Annotation a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Annotation a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Annotation a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Annotation a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Annotation a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Annotation a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Annotation a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Annotation a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Annotation a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Annotation a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Annotation a -> a
    foldr1 :: forall a. (a -> a -> a) -> Annotation a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Annotation a -> a
    foldl1 :: forall a. (a -> a -> a) -> Annotation a -> a
    $ctoList :: forall a. Annotation a -> [a]
    toList :: forall a. Annotation a -> [a]
    $cnull :: forall a. Annotation a -> Bool
    null :: forall a. Annotation a -> Bool
    $clength :: forall a. Annotation a -> Int
    length :: forall a. Annotation a -> Int
    $celem :: forall a. Eq a => a -> Annotation a -> Bool
    elem :: forall a. Eq a => a -> Annotation a -> Bool
    $cmaximum :: forall a. Ord a => Annotation a -> a
    maximum :: forall a. Ord a => Annotation a -> a
    $cminimum :: forall a. Ord a => Annotation a -> a
    minimum :: forall a. Ord a => Annotation a -> a
    $csum :: forall a. Num a => Annotation a -> a
    sum :: forall a. Num a => Annotation a -> a
    $cproduct :: forall a. Num a => Annotation a -> a
    product :: forall a. Num a => Annotation a -> a
    Foldable,Functor Annotation
    Foldable Annotation
    (Functor Annotation, Foldable Annotation) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Annotation a -> f (Annotation b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Annotation (f a) -> f (Annotation a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Annotation a -> m (Annotation b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Annotation (m a) -> m (Annotation a))
    -> Traversable Annotation
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    Annotation (m a) -> m (Annotation a)
    forall (f :: * -> *) a.
    Applicative f =>
    Annotation (f a) -> f (Annotation a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Annotation a -> m (Annotation b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Annotation a -> f (Annotation b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Annotation a -> f (Annotation b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Annotation a -> f (Annotation b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Annotation (f a) -> f (Annotation a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Annotation (f a) -> f (Annotation a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Annotation a -> m (Annotation b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Annotation a -> m (Annotation b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    Annotation (m a) -> m (Annotation a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Annotation (m a) -> m (Annotation a)
    Traversable,(forall a b. (a -> b) -> Annotation a -> Annotation b)
    -> (forall a b. a -> Annotation b -> Annotation a)
    -> Functor Annotation
    forall a b. a -> Annotation b -> Annotation a
    forall a b. (a -> b) -> Annotation a -> Annotation b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Annotation a -> Annotation b
    fmap :: forall a b. (a -> b) -> Annotation a -> Annotation b
    $c<$ :: forall a b. a -> Annotation b -> Annotation a
    <$ :: forall a b. a -> Annotation b -> Annotation a
    Functor,(forall x. Annotation l -> Rep (Annotation l) x)
    -> (forall x. Rep (Annotation l) x -> Annotation l)
    -> Generic (Annotation l)
    forall x. Rep (Annotation l) x -> Annotation l
    forall x. Annotation l -> Rep (Annotation l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Annotation l) x -> Annotation l
    forall l x. Annotation l -> Rep (Annotation l) x
    $cfrom :: forall l x. Annotation l -> Rep (Annotation l) x
    from :: forall x. Annotation l -> Rep (Annotation l) x
    $cto :: forall l x. Rep (Annotation l) x -> Annotation l
    to :: forall x. Rep (Annotation l) x -> Annotation l
    Generic)

    -- | A boolean formula for MINIMAL pragmas.
    data BooleanFormula l
        = VarFormula l (Name l)              -- ^ A variable.
        | AndFormula l [BooleanFormula l]    -- ^ And boolean formulas.
        | OrFormula l [BooleanFormula l]     -- ^ Or boolean formulas.
        | ParenFormula l (BooleanFormula l)  -- ^ Parenthesized boolean formulas.
      deriving (BooleanFormula l -> BooleanFormula l -> Bool
    (BooleanFormula l -> BooleanFormula l -> Bool)
    -> (BooleanFormula l -> BooleanFormula l -> Bool)
    -> Eq (BooleanFormula l)
    forall l. Eq l => BooleanFormula l -> BooleanFormula l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => BooleanFormula l -> BooleanFormula l -> Bool
    == :: BooleanFormula l -> BooleanFormula l -> Bool
    $c/= :: forall l. Eq l => BooleanFormula l -> BooleanFormula l -> Bool
    /= :: BooleanFormula l -> BooleanFormula l -> Bool
    Eq,Eq (BooleanFormula l)
    Eq (BooleanFormula l) =>
    (BooleanFormula l -> BooleanFormula l -> Ordering)
    -> (BooleanFormula l -> BooleanFormula l -> Bool)
    -> (BooleanFormula l -> BooleanFormula l -> Bool)
    -> (BooleanFormula l -> BooleanFormula l -> Bool)
    -> (BooleanFormula l -> BooleanFormula l -> Bool)
    -> (BooleanFormula l -> BooleanFormula l -> BooleanFormula l)
    -> (BooleanFormula l -> BooleanFormula l -> BooleanFormula l)
    -> Ord (BooleanFormula l)
    BooleanFormula l -> BooleanFormula l -> Bool
    BooleanFormula l -> BooleanFormula l -> Ordering
    BooleanFormula l -> BooleanFormula l -> BooleanFormula l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (BooleanFormula l)
    forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
    forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Ordering
    forall l.
    Ord l =>
    BooleanFormula l -> BooleanFormula l -> BooleanFormula l
    $ccompare :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Ordering
    compare :: BooleanFormula l -> BooleanFormula l -> Ordering
    $c< :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
    < :: BooleanFormula l -> BooleanFormula l -> Bool
    $c<= :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
    <= :: BooleanFormula l -> BooleanFormula l -> Bool
    $c> :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
    > :: BooleanFormula l -> BooleanFormula l -> Bool
    $c>= :: forall l. Ord l => BooleanFormula l -> BooleanFormula l -> Bool
    >= :: BooleanFormula l -> BooleanFormula l -> Bool
    $cmax :: forall l.
    Ord l =>
    BooleanFormula l -> BooleanFormula l -> BooleanFormula l
    max :: BooleanFormula l -> BooleanFormula l -> BooleanFormula l
    $cmin :: forall l.
    Ord l =>
    BooleanFormula l -> BooleanFormula l -> BooleanFormula l
    min :: BooleanFormula l -> BooleanFormula l -> BooleanFormula l
    Ord,Int -> BooleanFormula l -> ShowS
    [BooleanFormula l] -> ShowS
    BooleanFormula l -> String
    (Int -> BooleanFormula l -> ShowS)
    -> (BooleanFormula l -> String)
    -> ([BooleanFormula l] -> ShowS)
    -> Show (BooleanFormula l)
    forall l. Show l => Int -> BooleanFormula l -> ShowS
    forall l. Show l => [BooleanFormula l] -> ShowS
    forall l. Show l => BooleanFormula l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> BooleanFormula l -> ShowS
    showsPrec :: Int -> BooleanFormula l -> ShowS
    $cshow :: forall l. Show l => BooleanFormula l -> String
    show :: BooleanFormula l -> String
    $cshowList :: forall l. Show l => [BooleanFormula l] -> ShowS
    showList :: [BooleanFormula l] -> ShowS
    Show,Typeable,Typeable (BooleanFormula l)
    Typeable (BooleanFormula l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> BooleanFormula l
     -> c (BooleanFormula l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (BooleanFormula l))
    -> (BooleanFormula l -> Constr)
    -> (BooleanFormula l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (BooleanFormula l)))
    -> ((forall b. Data b => b -> b)
        -> BooleanFormula l -> BooleanFormula l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> BooleanFormula l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> BooleanFormula l -> m (BooleanFormula l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> BooleanFormula l -> m (BooleanFormula l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> BooleanFormula l -> m (BooleanFormula l))
    -> Data (BooleanFormula l)
    BooleanFormula l -> Constr
    BooleanFormula l -> DataType
    (forall b. Data b => b -> b)
    -> BooleanFormula l -> BooleanFormula l
    forall l. Data l => Typeable (BooleanFormula l)
    forall l. Data l => BooleanFormula l -> Constr
    forall l. Data l => BooleanFormula l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> BooleanFormula l -> BooleanFormula l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> BooleanFormula l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BooleanFormula l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BooleanFormula l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u
    forall u. (forall d. Data d => d -> u) -> BooleanFormula l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BooleanFormula l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BooleanFormula l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BooleanFormula l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BooleanFormula l)
    $ctoConstr :: forall l. Data l => BooleanFormula l -> Constr
    toConstr :: BooleanFormula l -> Constr
    $cdataTypeOf :: forall l. Data l => BooleanFormula l -> DataType
    dataTypeOf :: BooleanFormula l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BooleanFormula l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BooleanFormula l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> BooleanFormula l -> BooleanFormula l
    gmapT :: (forall b. Data b => b -> b)
    -> BooleanFormula l -> BooleanFormula l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> BooleanFormula l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> BooleanFormula l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BooleanFormula l -> m (BooleanFormula l)
    Data,(forall m. Monoid m => BooleanFormula m -> m)
    -> (forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m)
    -> (forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m)
    -> (forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b)
    -> (forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b)
    -> (forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b)
    -> (forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b)
    -> (forall a. (a -> a -> a) -> BooleanFormula a -> a)
    -> (forall a. (a -> a -> a) -> BooleanFormula a -> a)
    -> (forall a. BooleanFormula a -> [a])
    -> (forall a. BooleanFormula a -> Bool)
    -> (forall a. BooleanFormula a -> Int)
    -> (forall a. Eq a => a -> BooleanFormula a -> Bool)
    -> (forall a. Ord a => BooleanFormula a -> a)
    -> (forall a. Ord a => BooleanFormula a -> a)
    -> (forall a. Num a => BooleanFormula a -> a)
    -> (forall a. Num a => BooleanFormula a -> a)
    -> Foldable BooleanFormula
    forall a. Eq a => a -> BooleanFormula a -> Bool
    forall a. Num a => BooleanFormula a -> a
    forall a. Ord a => BooleanFormula a -> a
    forall m. Monoid m => BooleanFormula m -> m
    forall a. BooleanFormula a -> Bool
    forall a. BooleanFormula a -> Int
    forall a. BooleanFormula a -> [a]
    forall a. (a -> a -> a) -> BooleanFormula a -> a
    forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
    forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
    forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => BooleanFormula m -> m
    fold :: forall m. Monoid m => BooleanFormula m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> BooleanFormula a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> BooleanFormula a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> BooleanFormula a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> BooleanFormula a -> a
    foldr1 :: forall a. (a -> a -> a) -> BooleanFormula a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> BooleanFormula a -> a
    foldl1 :: forall a. (a -> a -> a) -> BooleanFormula a -> a
    $ctoList :: forall a. BooleanFormula a -> [a]
    toList :: forall a. BooleanFormula a -> [a]
    $cnull :: forall a. BooleanFormula a -> Bool
    null :: forall a. BooleanFormula a -> Bool
    $clength :: forall a. BooleanFormula a -> Int
    length :: forall a. BooleanFormula a -> Int
    $celem :: forall a. Eq a => a -> BooleanFormula a -> Bool
    elem :: forall a. Eq a => a -> BooleanFormula a -> Bool
    $cmaximum :: forall a. Ord a => BooleanFormula a -> a
    maximum :: forall a. Ord a => BooleanFormula a -> a
    $cminimum :: forall a. Ord a => BooleanFormula a -> a
    minimum :: forall a. Ord a => BooleanFormula a -> a
    $csum :: forall a. Num a => BooleanFormula a -> a
    sum :: forall a. Num a => BooleanFormula a -> a
    $cproduct :: forall a. Num a => BooleanFormula a -> a
    product :: forall a. Num a => BooleanFormula a -> a
    Foldable,Functor BooleanFormula
    Foldable BooleanFormula
    (Functor BooleanFormula, Foldable BooleanFormula) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> BooleanFormula a -> f (BooleanFormula b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        BooleanFormula (f a) -> f (BooleanFormula a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> BooleanFormula a -> m (BooleanFormula b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        BooleanFormula (m a) -> m (BooleanFormula a))
    -> Traversable BooleanFormula
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    BooleanFormula (m a) -> m (BooleanFormula a)
    forall (f :: * -> *) a.
    Applicative f =>
    BooleanFormula (f a) -> f (BooleanFormula a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BooleanFormula a -> m (BooleanFormula b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> BooleanFormula a -> f (BooleanFormula b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> BooleanFormula a -> f (BooleanFormula b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> BooleanFormula a -> f (BooleanFormula b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    BooleanFormula (f a) -> f (BooleanFormula a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    BooleanFormula (f a) -> f (BooleanFormula a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BooleanFormula a -> m (BooleanFormula b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BooleanFormula a -> m (BooleanFormula b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    BooleanFormula (m a) -> m (BooleanFormula a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    BooleanFormula (m a) -> m (BooleanFormula a)
    Traversable,(forall a b. (a -> b) -> BooleanFormula a -> BooleanFormula b)
    -> (forall a b. a -> BooleanFormula b -> BooleanFormula a)
    -> Functor BooleanFormula
    forall a b. a -> BooleanFormula b -> BooleanFormula a
    forall a b. (a -> b) -> BooleanFormula a -> BooleanFormula b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> BooleanFormula a -> BooleanFormula b
    fmap :: forall a b. (a -> b) -> BooleanFormula a -> BooleanFormula b
    $c<$ :: forall a b. a -> BooleanFormula b -> BooleanFormula a
    <$ :: forall a b. a -> BooleanFormula b -> BooleanFormula a
    Functor,(forall x. BooleanFormula l -> Rep (BooleanFormula l) x)
    -> (forall x. Rep (BooleanFormula l) x -> BooleanFormula l)
    -> Generic (BooleanFormula l)
    forall x. Rep (BooleanFormula l) x -> BooleanFormula l
    forall x. BooleanFormula l -> Rep (BooleanFormula l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (BooleanFormula l) x -> BooleanFormula l
    forall l x. BooleanFormula l -> Rep (BooleanFormula l) x
    $cfrom :: forall l x. BooleanFormula l -> Rep (BooleanFormula l) x
    from :: forall x. BooleanFormula l -> Rep (BooleanFormula l) x
    $cto :: forall l x. Rep (BooleanFormula l) x -> BooleanFormula l
    to :: forall x. Rep (BooleanFormula l) x -> BooleanFormula l
    Generic)

    data Role l
      = Nominal l
      | Representational l
      | Phantom l
      | RoleWildcard l
      deriving (Role l -> Role l -> Bool
    (Role l -> Role l -> Bool)
    -> (Role l -> Role l -> Bool) -> Eq (Role l)
    forall l. Eq l => Role l -> Role l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Role l -> Role l -> Bool
    == :: Role l -> Role l -> Bool
    $c/= :: forall l. Eq l => Role l -> Role l -> Bool
    /= :: Role l -> Role l -> Bool
    Eq,Eq (Role l)
    Eq (Role l) =>
    (Role l -> Role l -> Ordering)
    -> (Role l -> Role l -> Bool)
    -> (Role l -> Role l -> Bool)
    -> (Role l -> Role l -> Bool)
    -> (Role l -> Role l -> Bool)
    -> (Role l -> Role l -> Role l)
    -> (Role l -> Role l -> Role l)
    -> Ord (Role l)
    Role l -> Role l -> Bool
    Role l -> Role l -> Ordering
    Role l -> Role l -> Role l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Role l)
    forall l. Ord l => Role l -> Role l -> Bool
    forall l. Ord l => Role l -> Role l -> Ordering
    forall l. Ord l => Role l -> Role l -> Role l
    $ccompare :: forall l. Ord l => Role l -> Role l -> Ordering
    compare :: Role l -> Role l -> Ordering
    $c< :: forall l. Ord l => Role l -> Role l -> Bool
    < :: Role l -> Role l -> Bool
    $c<= :: forall l. Ord l => Role l -> Role l -> Bool
    <= :: Role l -> Role l -> Bool
    $c> :: forall l. Ord l => Role l -> Role l -> Bool
    > :: Role l -> Role l -> Bool
    $c>= :: forall l. Ord l => Role l -> Role l -> Bool
    >= :: Role l -> Role l -> Bool
    $cmax :: forall l. Ord l => Role l -> Role l -> Role l
    max :: Role l -> Role l -> Role l
    $cmin :: forall l. Ord l => Role l -> Role l -> Role l
    min :: Role l -> Role l -> Role l
    Ord,Int -> Role l -> ShowS
    [Role l] -> ShowS
    Role l -> String
    (Int -> Role l -> ShowS)
    -> (Role l -> String) -> ([Role l] -> ShowS) -> Show (Role l)
    forall l. Show l => Int -> Role l -> ShowS
    forall l. Show l => [Role l] -> ShowS
    forall l. Show l => Role l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Role l -> ShowS
    showsPrec :: Int -> Role l -> ShowS
    $cshow :: forall l. Show l => Role l -> String
    show :: Role l -> String
    $cshowList :: forall l. Show l => [Role l] -> ShowS
    showList :: [Role l] -> ShowS
    Show,Typeable,Typeable (Role l)
    Typeable (Role l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Role l -> c (Role l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Role l))
    -> (Role l -> Constr)
    -> (Role l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Role l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l)))
    -> ((forall b. Data b => b -> b) -> Role l -> Role l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Role l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Role l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Role l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Role l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Role l -> m (Role l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Role l -> m (Role l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Role l -> m (Role l))
    -> Data (Role l)
    Role l -> Constr
    Role l -> DataType
    (forall b. Data b => b -> b) -> Role l -> Role l
    forall l. Data l => Typeable (Role l)
    forall l. Data l => Role l -> Constr
    forall l. Data l => Role l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Role l -> Role l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Role l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Role l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Role l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Role l -> c (Role l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Role l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Role l -> u
    forall u. (forall d. Data d => d -> u) -> Role l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Role l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Role l -> c (Role l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Role l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Role l -> c (Role l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Role l -> c (Role l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Role l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Role l)
    $ctoConstr :: forall l. Data l => Role l -> Constr
    toConstr :: Role l -> Constr
    $cdataTypeOf :: forall l. Data l => Role l -> DataType
    dataTypeOf :: Role l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Role l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Role l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Role l -> Role l
    gmapT :: (forall b. Data b => b -> b) -> Role l -> Role l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Role l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Role l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Role l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Role l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role l -> m (Role l)
    Data,(forall m. Monoid m => Role m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Role a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Role a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Role a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Role a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Role a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Role a -> b)
    -> (forall a. (a -> a -> a) -> Role a -> a)
    -> (forall a. (a -> a -> a) -> Role a -> a)
    -> (forall a. Role a -> [a])
    -> (forall a. Role a -> Bool)
    -> (forall a. Role a -> Int)
    -> (forall a. Eq a => a -> Role a -> Bool)
    -> (forall a. Ord a => Role a -> a)
    -> (forall a. Ord a => Role a -> a)
    -> (forall a. Num a => Role a -> a)
    -> (forall a. Num a => Role a -> a)
    -> Foldable Role
    forall a. Eq a => a -> Role a -> Bool
    forall a. Num a => Role a -> a
    forall a. Ord a => Role a -> a
    forall m. Monoid m => Role m -> m
    forall a. Role a -> Bool
    forall a. Role a -> Int
    forall a. Role a -> [a]
    forall a. (a -> a -> a) -> Role a -> a
    forall m a. Monoid m => (a -> m) -> Role a -> m
    forall b a. (b -> a -> b) -> b -> Role a -> b
    forall a b. (a -> b -> b) -> b -> Role a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Role m -> m
    fold :: forall m. Monoid m => Role m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Role a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Role a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Role a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Role a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Role a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Role a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Role a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Role a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Role a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Role a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Role a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Role a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Role a -> a
    foldr1 :: forall a. (a -> a -> a) -> Role a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Role a -> a
    foldl1 :: forall a. (a -> a -> a) -> Role a -> a
    $ctoList :: forall a. Role a -> [a]
    toList :: forall a. Role a -> [a]
    $cnull :: forall a. Role a -> Bool
    null :: forall a. Role a -> Bool
    $clength :: forall a. Role a -> Int
    length :: forall a. Role a -> Int
    $celem :: forall a. Eq a => a -> Role a -> Bool
    elem :: forall a. Eq a => a -> Role a -> Bool
    $cmaximum :: forall a. Ord a => Role a -> a
    maximum :: forall a. Ord a => Role a -> a
    $cminimum :: forall a. Ord a => Role a -> a
    minimum :: forall a. Ord a => Role a -> a
    $csum :: forall a. Num a => Role a -> a
    sum :: forall a. Num a => Role a -> a
    $cproduct :: forall a. Num a => Role a -> a
    product :: forall a. Num a => Role a -> a
    Foldable,Functor Role
    Foldable Role
    (Functor Role, Foldable Role) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Role a -> f (Role b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Role (f a) -> f (Role a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Role a -> m (Role b))
    -> (forall (m :: * -> *) a. Monad m => Role (m a) -> m (Role a))
    -> Traversable Role
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Role (m a) -> m (Role a)
    forall (f :: * -> *) a. Applicative f => Role (f a) -> f (Role a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Role a -> m (Role b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Role a -> f (Role b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Role a -> f (Role b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Role a -> f (Role b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Role (f a) -> f (Role a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Role (f a) -> f (Role a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Role a -> m (Role b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Role a -> m (Role b)
    $csequence :: forall (m :: * -> *) a. Monad m => Role (m a) -> m (Role a)
    sequence :: forall (m :: * -> *) a. Monad m => Role (m a) -> m (Role a)
    Traversable,(forall a b. (a -> b) -> Role a -> Role b)
    -> (forall a b. a -> Role b -> Role a) -> Functor Role
    forall a b. a -> Role b -> Role a
    forall a b. (a -> b) -> Role a -> Role b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Role a -> Role b
    fmap :: forall a b. (a -> b) -> Role a -> Role b
    $c<$ :: forall a b. a -> Role b -> Role a
    <$ :: forall a b. a -> Role b -> Role a
    Functor,(forall x. Role l -> Rep (Role l) x)
    -> (forall x. Rep (Role l) x -> Role l) -> Generic (Role l)
    forall x. Rep (Role l) x -> Role l
    forall x. Role l -> Rep (Role l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Role l) x -> Role l
    forall l x. Role l -> Rep (Role l) x
    $cfrom :: forall l x. Role l -> Rep (Role l) x
    from :: forall x. Role l -> Rep (Role l) x
    $cto :: forall l x. Rep (Role l) x -> Role l
    to :: forall x. Rep (Role l) x -> Role l
    Generic)

    -- | A flag stating whether a declaration is a data or newtype declaration.
    data DataOrNew l = DataType l | NewType l
      deriving (DataOrNew l -> DataOrNew l -> Bool
    (DataOrNew l -> DataOrNew l -> Bool)
    -> (DataOrNew l -> DataOrNew l -> Bool) -> Eq (DataOrNew l)
    forall l. Eq l => DataOrNew l -> DataOrNew l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => DataOrNew l -> DataOrNew l -> Bool
    == :: DataOrNew l -> DataOrNew l -> Bool
    $c/= :: forall l. Eq l => DataOrNew l -> DataOrNew l -> Bool
    /= :: DataOrNew l -> DataOrNew l -> Bool
    Eq,Eq (DataOrNew l)
    Eq (DataOrNew l) =>
    (DataOrNew l -> DataOrNew l -> Ordering)
    -> (DataOrNew l -> DataOrNew l -> Bool)
    -> (DataOrNew l -> DataOrNew l -> Bool)
    -> (DataOrNew l -> DataOrNew l -> Bool)
    -> (DataOrNew l -> DataOrNew l -> Bool)
    -> (DataOrNew l -> DataOrNew l -> DataOrNew l)
    -> (DataOrNew l -> DataOrNew l -> DataOrNew l)
    -> Ord (DataOrNew l)
    DataOrNew l -> DataOrNew l -> Bool
    DataOrNew l -> DataOrNew l -> Ordering
    DataOrNew l -> DataOrNew l -> DataOrNew l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (DataOrNew l)
    forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
    forall l. Ord l => DataOrNew l -> DataOrNew l -> Ordering
    forall l. Ord l => DataOrNew l -> DataOrNew l -> DataOrNew l
    $ccompare :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Ordering
    compare :: DataOrNew l -> DataOrNew l -> Ordering
    $c< :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
    < :: DataOrNew l -> DataOrNew l -> Bool
    $c<= :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
    <= :: DataOrNew l -> DataOrNew l -> Bool
    $c> :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
    > :: DataOrNew l -> DataOrNew l -> Bool
    $c>= :: forall l. Ord l => DataOrNew l -> DataOrNew l -> Bool
    >= :: DataOrNew l -> DataOrNew l -> Bool
    $cmax :: forall l. Ord l => DataOrNew l -> DataOrNew l -> DataOrNew l
    max :: DataOrNew l -> DataOrNew l -> DataOrNew l
    $cmin :: forall l. Ord l => DataOrNew l -> DataOrNew l -> DataOrNew l
    min :: DataOrNew l -> DataOrNew l -> DataOrNew l
    Ord,Int -> DataOrNew l -> ShowS
    [DataOrNew l] -> ShowS
    DataOrNew l -> String
    (Int -> DataOrNew l -> ShowS)
    -> (DataOrNew l -> String)
    -> ([DataOrNew l] -> ShowS)
    -> Show (DataOrNew l)
    forall l. Show l => Int -> DataOrNew l -> ShowS
    forall l. Show l => [DataOrNew l] -> ShowS
    forall l. Show l => DataOrNew l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> DataOrNew l -> ShowS
    showsPrec :: Int -> DataOrNew l -> ShowS
    $cshow :: forall l. Show l => DataOrNew l -> String
    show :: DataOrNew l -> String
    $cshowList :: forall l. Show l => [DataOrNew l] -> ShowS
    showList :: [DataOrNew l] -> ShowS
    Show,Typeable,Typeable (DataOrNew l)
    Typeable (DataOrNew l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (DataOrNew l))
    -> (DataOrNew l -> Constr)
    -> (DataOrNew l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (DataOrNew l)))
    -> ((forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DataOrNew l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l))
    -> Data (DataOrNew l)
    DataOrNew l -> Constr
    DataOrNew l -> DataType
    (forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l
    forall l. Data l => Typeable (DataOrNew l)
    forall l. Data l => DataOrNew l -> Constr
    forall l. Data l => DataOrNew l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> DataOrNew l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DataOrNew l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DataOrNew l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u
    forall u. (forall d. Data d => d -> u) -> DataOrNew l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DataOrNew l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DataOrNew l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DataOrNew l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DataOrNew l)
    $ctoConstr :: forall l. Data l => DataOrNew l -> Constr
    toConstr :: DataOrNew l -> Constr
    $cdataTypeOf :: forall l. Data l => DataOrNew l -> DataType
    dataTypeOf :: DataOrNew l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DataOrNew l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DataOrNew l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l
    gmapT :: (forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> DataOrNew l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DataOrNew l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l)
    Data,(forall m. Monoid m => DataOrNew m -> m)
    -> (forall m a. Monoid m => (a -> m) -> DataOrNew a -> m)
    -> (forall m a. Monoid m => (a -> m) -> DataOrNew a -> m)
    -> (forall a b. (a -> b -> b) -> b -> DataOrNew a -> b)
    -> (forall a b. (a -> b -> b) -> b -> DataOrNew a -> b)
    -> (forall b a. (b -> a -> b) -> b -> DataOrNew a -> b)
    -> (forall b a. (b -> a -> b) -> b -> DataOrNew a -> b)
    -> (forall a. (a -> a -> a) -> DataOrNew a -> a)
    -> (forall a. (a -> a -> a) -> DataOrNew a -> a)
    -> (forall a. DataOrNew a -> [a])
    -> (forall a. DataOrNew a -> Bool)
    -> (forall a. DataOrNew a -> Int)
    -> (forall a. Eq a => a -> DataOrNew a -> Bool)
    -> (forall a. Ord a => DataOrNew a -> a)
    -> (forall a. Ord a => DataOrNew a -> a)
    -> (forall a. Num a => DataOrNew a -> a)
    -> (forall a. Num a => DataOrNew a -> a)
    -> Foldable DataOrNew
    forall a. Eq a => a -> DataOrNew a -> Bool
    forall a. Num a => DataOrNew a -> a
    forall a. Ord a => DataOrNew a -> a
    forall m. Monoid m => DataOrNew m -> m
    forall a. DataOrNew a -> Bool
    forall a. DataOrNew a -> Int
    forall a. DataOrNew a -> [a]
    forall a. (a -> a -> a) -> DataOrNew a -> a
    forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
    forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
    forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => DataOrNew m -> m
    fold :: forall m. Monoid m => DataOrNew m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> DataOrNew a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> DataOrNew a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> DataOrNew a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> DataOrNew a -> a
    foldr1 :: forall a. (a -> a -> a) -> DataOrNew a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> DataOrNew a -> a
    foldl1 :: forall a. (a -> a -> a) -> DataOrNew a -> a
    $ctoList :: forall a. DataOrNew a -> [a]
    toList :: forall a. DataOrNew a -> [a]
    $cnull :: forall a. DataOrNew a -> Bool
    null :: forall a. DataOrNew a -> Bool
    $clength :: forall a. DataOrNew a -> Int
    length :: forall a. DataOrNew a -> Int
    $celem :: forall a. Eq a => a -> DataOrNew a -> Bool
    elem :: forall a. Eq a => a -> DataOrNew a -> Bool
    $cmaximum :: forall a. Ord a => DataOrNew a -> a
    maximum :: forall a. Ord a => DataOrNew a -> a
    $cminimum :: forall a. Ord a => DataOrNew a -> a
    minimum :: forall a. Ord a => DataOrNew a -> a
    $csum :: forall a. Num a => DataOrNew a -> a
    sum :: forall a. Num a => DataOrNew a -> a
    $cproduct :: forall a. Num a => DataOrNew a -> a
    product :: forall a. Num a => DataOrNew a -> a
    Foldable,Functor DataOrNew
    Foldable DataOrNew
    (Functor DataOrNew, Foldable DataOrNew) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> DataOrNew a -> f (DataOrNew b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        DataOrNew (f a) -> f (DataOrNew a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> DataOrNew a -> m (DataOrNew b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        DataOrNew (m a) -> m (DataOrNew a))
    -> Traversable DataOrNew
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    DataOrNew (m a) -> m (DataOrNew a)
    forall (f :: * -> *) a.
    Applicative f =>
    DataOrNew (f a) -> f (DataOrNew a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DataOrNew a -> m (DataOrNew b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DataOrNew a -> f (DataOrNew b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DataOrNew a -> f (DataOrNew b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DataOrNew a -> f (DataOrNew b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    DataOrNew (f a) -> f (DataOrNew a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    DataOrNew (f a) -> f (DataOrNew a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DataOrNew a -> m (DataOrNew b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DataOrNew a -> m (DataOrNew b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    DataOrNew (m a) -> m (DataOrNew a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    DataOrNew (m a) -> m (DataOrNew a)
    Traversable,(forall a b. (a -> b) -> DataOrNew a -> DataOrNew b)
    -> (forall a b. a -> DataOrNew b -> DataOrNew a)
    -> Functor DataOrNew
    forall a b. a -> DataOrNew b -> DataOrNew a
    forall a b. (a -> b) -> DataOrNew a -> DataOrNew b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> DataOrNew a -> DataOrNew b
    fmap :: forall a b. (a -> b) -> DataOrNew a -> DataOrNew b
    $c<$ :: forall a b. a -> DataOrNew b -> DataOrNew a
    <$ :: forall a b. a -> DataOrNew b -> DataOrNew a
    Functor,(forall x. DataOrNew l -> Rep (DataOrNew l) x)
    -> (forall x. Rep (DataOrNew l) x -> DataOrNew l)
    -> Generic (DataOrNew l)
    forall x. Rep (DataOrNew l) x -> DataOrNew l
    forall x. DataOrNew l -> Rep (DataOrNew l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (DataOrNew l) x -> DataOrNew l
    forall l x. DataOrNew l -> Rep (DataOrNew l) x
    $cfrom :: forall l x. DataOrNew l -> Rep (DataOrNew l) x
    from :: forall x. DataOrNew l -> Rep (DataOrNew l) x
    $cto :: forall l x. Rep (DataOrNew l) x -> DataOrNew l
    to :: forall x. Rep (DataOrNew l) x -> DataOrNew l
    Generic)

    -- | Injectivity info for injective type families
    data InjectivityInfo l = InjectivityInfo l (Name l) [Name l]
      deriving (InjectivityInfo l -> InjectivityInfo l -> Bool
    (InjectivityInfo l -> InjectivityInfo l -> Bool)
    -> (InjectivityInfo l -> InjectivityInfo l -> Bool)
    -> Eq (InjectivityInfo l)
    forall l. Eq l => InjectivityInfo l -> InjectivityInfo l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => InjectivityInfo l -> InjectivityInfo l -> Bool
    == :: InjectivityInfo l -> InjectivityInfo l -> Bool
    $c/= :: forall l. Eq l => InjectivityInfo l -> InjectivityInfo l -> Bool
    /= :: InjectivityInfo l -> InjectivityInfo l -> Bool
    Eq, Eq (InjectivityInfo l)
    Eq (InjectivityInfo l) =>
    (InjectivityInfo l -> InjectivityInfo l -> Ordering)
    -> (InjectivityInfo l -> InjectivityInfo l -> Bool)
    -> (InjectivityInfo l -> InjectivityInfo l -> Bool)
    -> (InjectivityInfo l -> InjectivityInfo l -> Bool)
    -> (InjectivityInfo l -> InjectivityInfo l -> Bool)
    -> (InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l)
    -> (InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l)
    -> Ord (InjectivityInfo l)
    InjectivityInfo l -> InjectivityInfo l -> Bool
    InjectivityInfo l -> InjectivityInfo l -> Ordering
    InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (InjectivityInfo l)
    forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
    forall l.
    Ord l =>
    InjectivityInfo l -> InjectivityInfo l -> Ordering
    forall l.
    Ord l =>
    InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
    $ccompare :: forall l.
    Ord l =>
    InjectivityInfo l -> InjectivityInfo l -> Ordering
    compare :: InjectivityInfo l -> InjectivityInfo l -> Ordering
    $c< :: forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
    < :: InjectivityInfo l -> InjectivityInfo l -> Bool
    $c<= :: forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
    <= :: InjectivityInfo l -> InjectivityInfo l -> Bool
    $c> :: forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
    > :: InjectivityInfo l -> InjectivityInfo l -> Bool
    $c>= :: forall l. Ord l => InjectivityInfo l -> InjectivityInfo l -> Bool
    >= :: InjectivityInfo l -> InjectivityInfo l -> Bool
    $cmax :: forall l.
    Ord l =>
    InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
    max :: InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
    $cmin :: forall l.
    Ord l =>
    InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
    min :: InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l
    Ord, Int -> InjectivityInfo l -> ShowS
    [InjectivityInfo l] -> ShowS
    InjectivityInfo l -> String
    (Int -> InjectivityInfo l -> ShowS)
    -> (InjectivityInfo l -> String)
    -> ([InjectivityInfo l] -> ShowS)
    -> Show (InjectivityInfo l)
    forall l. Show l => Int -> InjectivityInfo l -> ShowS
    forall l. Show l => [InjectivityInfo l] -> ShowS
    forall l. Show l => InjectivityInfo l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> InjectivityInfo l -> ShowS
    showsPrec :: Int -> InjectivityInfo l -> ShowS
    $cshow :: forall l. Show l => InjectivityInfo l -> String
    show :: InjectivityInfo l -> String
    $cshowList :: forall l. Show l => [InjectivityInfo l] -> ShowS
    showList :: [InjectivityInfo l] -> ShowS
    Show, Typeable, Typeable (InjectivityInfo l)
    Typeable (InjectivityInfo l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> InjectivityInfo l
     -> c (InjectivityInfo l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l))
    -> (InjectivityInfo l -> Constr)
    -> (InjectivityInfo l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (InjectivityInfo l)))
    -> ((forall b. Data b => b -> b)
        -> InjectivityInfo l -> InjectivityInfo l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> InjectivityInfo l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> InjectivityInfo l -> m (InjectivityInfo l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> InjectivityInfo l -> m (InjectivityInfo l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> InjectivityInfo l -> m (InjectivityInfo l))
    -> Data (InjectivityInfo l)
    InjectivityInfo l -> Constr
    InjectivityInfo l -> DataType
    (forall b. Data b => b -> b)
    -> InjectivityInfo l -> InjectivityInfo l
    forall l. Data l => Typeable (InjectivityInfo l)
    forall l. Data l => InjectivityInfo l -> Constr
    forall l. Data l => InjectivityInfo l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> InjectivityInfo l -> InjectivityInfo l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> InjectivityInfo l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> InjectivityInfo l
    -> c (InjectivityInfo l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InjectivityInfo l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u
    forall u. (forall d. Data d => d -> u) -> InjectivityInfo l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> InjectivityInfo l
    -> c (InjectivityInfo l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InjectivityInfo l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> InjectivityInfo l
    -> c (InjectivityInfo l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> InjectivityInfo l
    -> c (InjectivityInfo l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l)
    $ctoConstr :: forall l. Data l => InjectivityInfo l -> Constr
    toConstr :: InjectivityInfo l -> Constr
    $cdataTypeOf :: forall l. Data l => InjectivityInfo l -> DataType
    dataTypeOf :: InjectivityInfo l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InjectivityInfo l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InjectivityInfo l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> InjectivityInfo l -> InjectivityInfo l
    gmapT :: (forall b. Data b => b -> b)
    -> InjectivityInfo l -> InjectivityInfo l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> InjectivityInfo l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> InjectivityInfo l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InjectivityInfo l -> m (InjectivityInfo l)
    Data, (forall m. Monoid m => InjectivityInfo m -> m)
    -> (forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m)
    -> (forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m)
    -> (forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b)
    -> (forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b)
    -> (forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b)
    -> (forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b)
    -> (forall a. (a -> a -> a) -> InjectivityInfo a -> a)
    -> (forall a. (a -> a -> a) -> InjectivityInfo a -> a)
    -> (forall a. InjectivityInfo a -> [a])
    -> (forall a. InjectivityInfo a -> Bool)
    -> (forall a. InjectivityInfo a -> Int)
    -> (forall a. Eq a => a -> InjectivityInfo a -> Bool)
    -> (forall a. Ord a => InjectivityInfo a -> a)
    -> (forall a. Ord a => InjectivityInfo a -> a)
    -> (forall a. Num a => InjectivityInfo a -> a)
    -> (forall a. Num a => InjectivityInfo a -> a)
    -> Foldable InjectivityInfo
    forall a. Eq a => a -> InjectivityInfo a -> Bool
    forall a. Num a => InjectivityInfo a -> a
    forall a. Ord a => InjectivityInfo a -> a
    forall m. Monoid m => InjectivityInfo m -> m
    forall a. InjectivityInfo a -> Bool
    forall a. InjectivityInfo a -> Int
    forall a. InjectivityInfo a -> [a]
    forall a. (a -> a -> a) -> InjectivityInfo a -> a
    forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
    forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
    forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => InjectivityInfo m -> m
    fold :: forall m. Monoid m => InjectivityInfo m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> InjectivityInfo a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> InjectivityInfo a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> InjectivityInfo a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> InjectivityInfo a -> a
    foldr1 :: forall a. (a -> a -> a) -> InjectivityInfo a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> InjectivityInfo a -> a
    foldl1 :: forall a. (a -> a -> a) -> InjectivityInfo a -> a
    $ctoList :: forall a. InjectivityInfo a -> [a]
    toList :: forall a. InjectivityInfo a -> [a]
    $cnull :: forall a. InjectivityInfo a -> Bool
    null :: forall a. InjectivityInfo a -> Bool
    $clength :: forall a. InjectivityInfo a -> Int
    length :: forall a. InjectivityInfo a -> Int
    $celem :: forall a. Eq a => a -> InjectivityInfo a -> Bool
    elem :: forall a. Eq a => a -> InjectivityInfo a -> Bool
    $cmaximum :: forall a. Ord a => InjectivityInfo a -> a
    maximum :: forall a. Ord a => InjectivityInfo a -> a
    $cminimum :: forall a. Ord a => InjectivityInfo a -> a
    minimum :: forall a. Ord a => InjectivityInfo a -> a
    $csum :: forall a. Num a => InjectivityInfo a -> a
    sum :: forall a. Num a => InjectivityInfo a -> a
    $cproduct :: forall a. Num a => InjectivityInfo a -> a
    product :: forall a. Num a => InjectivityInfo a -> a
    Foldable, Functor InjectivityInfo
    Foldable InjectivityInfo
    (Functor InjectivityInfo, Foldable InjectivityInfo) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        InjectivityInfo (f a) -> f (InjectivityInfo a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        InjectivityInfo (m a) -> m (InjectivityInfo a))
    -> Traversable InjectivityInfo
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    InjectivityInfo (m a) -> m (InjectivityInfo a)
    forall (f :: * -> *) a.
    Applicative f =>
    InjectivityInfo (f a) -> f (InjectivityInfo a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    InjectivityInfo (f a) -> f (InjectivityInfo a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    InjectivityInfo (f a) -> f (InjectivityInfo a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    InjectivityInfo (m a) -> m (InjectivityInfo a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    InjectivityInfo (m a) -> m (InjectivityInfo a)
    Traversable, (forall a b. (a -> b) -> InjectivityInfo a -> InjectivityInfo b)
    -> (forall a b. a -> InjectivityInfo b -> InjectivityInfo a)
    -> Functor InjectivityInfo
    forall a b. a -> InjectivityInfo b -> InjectivityInfo a
    forall a b. (a -> b) -> InjectivityInfo a -> InjectivityInfo b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> InjectivityInfo a -> InjectivityInfo b
    fmap :: forall a b. (a -> b) -> InjectivityInfo a -> InjectivityInfo b
    $c<$ :: forall a b. a -> InjectivityInfo b -> InjectivityInfo a
    <$ :: forall a b. a -> InjectivityInfo b -> InjectivityInfo a
    Functor, (forall x. InjectivityInfo l -> Rep (InjectivityInfo l) x)
    -> (forall x. Rep (InjectivityInfo l) x -> InjectivityInfo l)
    -> Generic (InjectivityInfo l)
    forall x. Rep (InjectivityInfo l) x -> InjectivityInfo l
    forall x. InjectivityInfo l -> Rep (InjectivityInfo l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (InjectivityInfo l) x -> InjectivityInfo l
    forall l x. InjectivityInfo l -> Rep (InjectivityInfo l) x
    $cfrom :: forall l x. InjectivityInfo l -> Rep (InjectivityInfo l) x
    from :: forall x. InjectivityInfo l -> Rep (InjectivityInfo l) x
    $cto :: forall l x. Rep (InjectivityInfo l) x -> InjectivityInfo l
    to :: forall x. Rep (InjectivityInfo l) x -> InjectivityInfo l
    Generic)

    data ResultSig l = KindSig l (Kind l) | TyVarSig l (TyVarBind l)
      deriving (ResultSig l -> ResultSig l -> Bool
    (ResultSig l -> ResultSig l -> Bool)
    -> (ResultSig l -> ResultSig l -> Bool) -> Eq (ResultSig l)
    forall l. Eq l => ResultSig l -> ResultSig l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ResultSig l -> ResultSig l -> Bool
    == :: ResultSig l -> ResultSig l -> Bool
    $c/= :: forall l. Eq l => ResultSig l -> ResultSig l -> Bool
    /= :: ResultSig l -> ResultSig l -> Bool
    Eq, Eq (ResultSig l)
    Eq (ResultSig l) =>
    (ResultSig l -> ResultSig l -> Ordering)
    -> (ResultSig l -> ResultSig l -> Bool)
    -> (ResultSig l -> ResultSig l -> Bool)
    -> (ResultSig l -> ResultSig l -> Bool)
    -> (ResultSig l -> ResultSig l -> Bool)
    -> (ResultSig l -> ResultSig l -> ResultSig l)
    -> (ResultSig l -> ResultSig l -> ResultSig l)
    -> Ord (ResultSig l)
    ResultSig l -> ResultSig l -> Bool
    ResultSig l -> ResultSig l -> Ordering
    ResultSig l -> ResultSig l -> ResultSig l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ResultSig l)
    forall l. Ord l => ResultSig l -> ResultSig l -> Bool
    forall l. Ord l => ResultSig l -> ResultSig l -> Ordering
    forall l. Ord l => ResultSig l -> ResultSig l -> ResultSig l
    $ccompare :: forall l. Ord l => ResultSig l -> ResultSig l -> Ordering
    compare :: ResultSig l -> ResultSig l -> Ordering
    $c< :: forall l. Ord l => ResultSig l -> ResultSig l -> Bool
    < :: ResultSig l -> ResultSig l -> Bool
    $c<= :: forall l. Ord l => ResultSig l -> ResultSig l -> Bool
    <= :: ResultSig l -> ResultSig l -> Bool
    $c> :: forall l. Ord l => ResultSig l -> ResultSig l -> Bool
    > :: ResultSig l -> ResultSig l -> Bool
    $c>= :: forall l. Ord l => ResultSig l -> ResultSig l -> Bool
    >= :: ResultSig l -> ResultSig l -> Bool
    $cmax :: forall l. Ord l => ResultSig l -> ResultSig l -> ResultSig l
    max :: ResultSig l -> ResultSig l -> ResultSig l
    $cmin :: forall l. Ord l => ResultSig l -> ResultSig l -> ResultSig l
    min :: ResultSig l -> ResultSig l -> ResultSig l
    Ord, Int -> ResultSig l -> ShowS
    [ResultSig l] -> ShowS
    ResultSig l -> String
    (Int -> ResultSig l -> ShowS)
    -> (ResultSig l -> String)
    -> ([ResultSig l] -> ShowS)
    -> Show (ResultSig l)
    forall l. Show l => Int -> ResultSig l -> ShowS
    forall l. Show l => [ResultSig l] -> ShowS
    forall l. Show l => ResultSig l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ResultSig l -> ShowS
    showsPrec :: Int -> ResultSig l -> ShowS
    $cshow :: forall l. Show l => ResultSig l -> String
    show :: ResultSig l -> String
    $cshowList :: forall l. Show l => [ResultSig l] -> ShowS
    showList :: [ResultSig l] -> ShowS
    Show, Typeable, Typeable (ResultSig l)
    Typeable (ResultSig l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ResultSig l))
    -> (ResultSig l -> Constr)
    -> (ResultSig l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ResultSig l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ResultSig l)))
    -> ((forall b. Data b => b -> b) -> ResultSig l -> ResultSig l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ResultSig l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ResultSig l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l))
    -> Data (ResultSig l)
    ResultSig l -> Constr
    ResultSig l -> DataType
    (forall b. Data b => b -> b) -> ResultSig l -> ResultSig l
    forall l. Data l => Typeable (ResultSig l)
    forall l. Data l => ResultSig l -> Constr
    forall l. Data l => ResultSig l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ResultSig l -> ResultSig l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ResultSig l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ResultSig l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ResultSig l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ResultSig l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ResultSig l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ResultSig l -> u
    forall u. (forall d. Data d => d -> u) -> ResultSig l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ResultSig l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ResultSig l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ResultSig l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ResultSig l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ResultSig l)
    $ctoConstr :: forall l. Data l => ResultSig l -> Constr
    toConstr :: ResultSig l -> Constr
    $cdataTypeOf :: forall l. Data l => ResultSig l -> DataType
    dataTypeOf :: ResultSig l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ResultSig l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ResultSig l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ResultSig l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ResultSig l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ResultSig l -> ResultSig l
    gmapT :: (forall b. Data b => b -> b) -> ResultSig l -> ResultSig l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ResultSig l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ResultSig l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ResultSig l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ResultSig l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l)
    Data, (forall m. Monoid m => ResultSig m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ResultSig a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ResultSig a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ResultSig a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ResultSig a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ResultSig a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ResultSig a -> b)
    -> (forall a. (a -> a -> a) -> ResultSig a -> a)
    -> (forall a. (a -> a -> a) -> ResultSig a -> a)
    -> (forall a. ResultSig a -> [a])
    -> (forall a. ResultSig a -> Bool)
    -> (forall a. ResultSig a -> Int)
    -> (forall a. Eq a => a -> ResultSig a -> Bool)
    -> (forall a. Ord a => ResultSig a -> a)
    -> (forall a. Ord a => ResultSig a -> a)
    -> (forall a. Num a => ResultSig a -> a)
    -> (forall a. Num a => ResultSig a -> a)
    -> Foldable ResultSig
    forall a. Eq a => a -> ResultSig a -> Bool
    forall a. Num a => ResultSig a -> a
    forall a. Ord a => ResultSig a -> a
    forall m. Monoid m => ResultSig m -> m
    forall a. ResultSig a -> Bool
    forall a. ResultSig a -> Int
    forall a. ResultSig a -> [a]
    forall a. (a -> a -> a) -> ResultSig a -> a
    forall m a. Monoid m => (a -> m) -> ResultSig a -> m
    forall b a. (b -> a -> b) -> b -> ResultSig a -> b
    forall a b. (a -> b -> b) -> b -> ResultSig a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ResultSig m -> m
    fold :: forall m. Monoid m => ResultSig m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ResultSig a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ResultSig a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ResultSig a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ResultSig a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ResultSig a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ResultSig a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ResultSig a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ResultSig a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ResultSig a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ResultSig a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ResultSig a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ResultSig a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ResultSig a -> a
    foldr1 :: forall a. (a -> a -> a) -> ResultSig a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ResultSig a -> a
    foldl1 :: forall a. (a -> a -> a) -> ResultSig a -> a
    $ctoList :: forall a. ResultSig a -> [a]
    toList :: forall a. ResultSig a -> [a]
    $cnull :: forall a. ResultSig a -> Bool
    null :: forall a. ResultSig a -> Bool
    $clength :: forall a. ResultSig a -> Int
    length :: forall a. ResultSig a -> Int
    $celem :: forall a. Eq a => a -> ResultSig a -> Bool
    elem :: forall a. Eq a => a -> ResultSig a -> Bool
    $cmaximum :: forall a. Ord a => ResultSig a -> a
    maximum :: forall a. Ord a => ResultSig a -> a
    $cminimum :: forall a. Ord a => ResultSig a -> a
    minimum :: forall a. Ord a => ResultSig a -> a
    $csum :: forall a. Num a => ResultSig a -> a
    sum :: forall a. Num a => ResultSig a -> a
    $cproduct :: forall a. Num a => ResultSig a -> a
    product :: forall a. Num a => ResultSig a -> a
    Foldable, Functor ResultSig
    Foldable ResultSig
    (Functor ResultSig, Foldable ResultSig) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ResultSig a -> f (ResultSig b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ResultSig (f a) -> f (ResultSig a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ResultSig a -> m (ResultSig b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ResultSig (m a) -> m (ResultSig a))
    -> Traversable ResultSig
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ResultSig (m a) -> m (ResultSig a)
    forall (f :: * -> *) a.
    Applicative f =>
    ResultSig (f a) -> f (ResultSig a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ResultSig a -> m (ResultSig b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ResultSig a -> f (ResultSig b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ResultSig a -> f (ResultSig b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ResultSig a -> f (ResultSig b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ResultSig (f a) -> f (ResultSig a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ResultSig (f a) -> f (ResultSig a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ResultSig a -> m (ResultSig b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ResultSig a -> m (ResultSig b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ResultSig (m a) -> m (ResultSig a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ResultSig (m a) -> m (ResultSig a)
    Traversable, (forall a b. (a -> b) -> ResultSig a -> ResultSig b)
    -> (forall a b. a -> ResultSig b -> ResultSig a)
    -> Functor ResultSig
    forall a b. a -> ResultSig b -> ResultSig a
    forall a b. (a -> b) -> ResultSig a -> ResultSig b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ResultSig a -> ResultSig b
    fmap :: forall a b. (a -> b) -> ResultSig a -> ResultSig b
    $c<$ :: forall a b. a -> ResultSig b -> ResultSig a
    <$ :: forall a b. a -> ResultSig b -> ResultSig a
    Functor, (forall x. ResultSig l -> Rep (ResultSig l) x)
    -> (forall x. Rep (ResultSig l) x -> ResultSig l)
    -> Generic (ResultSig l)
    forall x. Rep (ResultSig l) x -> ResultSig l
    forall x. ResultSig l -> Rep (ResultSig l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ResultSig l) x -> ResultSig l
    forall l x. ResultSig l -> Rep (ResultSig l) x
    $cfrom :: forall l x. ResultSig l -> Rep (ResultSig l) x
    from :: forall x. ResultSig l -> Rep (ResultSig l) x
    $cto :: forall l x. Rep (ResultSig l) x -> ResultSig l
    to :: forall x. Rep (ResultSig l) x -> ResultSig l
    Generic)

    -- | The head of a type or class declaration, which consists of the type
    -- or class name applied to some type variables
    --
    -- @class C a b@ is represented as
    --
    -- >DHApp
    -- >   ()
    -- >   (DHApp
    -- >      () (DHead () (Ident () "C")) (UnkindedVar () (Ident () "a")))
    -- >   (UnkindedVar () (Ident () "b"))
    --
    -- (where the annotation type @l@ is instantiated with @()@)
    --
    -- @class (a :< b) c@ is represented as
    --
    -- >DHApp
    -- >   ()
    -- >   (DHParen
    -- >      ()
    -- >      (DHApp
    -- >         ()
    -- >         (DHInfix () (UnkindedVar () (Ident () "a")) (Symbol () ":<"))
    -- >         (UnkindedVar () (Ident () "b"))))
    -- >   (UnkindedVar () (Ident () "c"))
    data DeclHead l
        = DHead l (Name l) -- ^ type or class name
        | DHInfix l (TyVarBind l) (Name l) -- ^ infix application of the type/class name to the left operand
        | DHParen l (DeclHead l) -- ^ parenthesized declaration head
        | DHApp   l (DeclHead l) (TyVarBind l) -- ^ application to one more type variable
      deriving (DeclHead l -> DeclHead l -> Bool
    (DeclHead l -> DeclHead l -> Bool)
    -> (DeclHead l -> DeclHead l -> Bool) -> Eq (DeclHead l)
    forall l. Eq l => DeclHead l -> DeclHead l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => DeclHead l -> DeclHead l -> Bool
    == :: DeclHead l -> DeclHead l -> Bool
    $c/= :: forall l. Eq l => DeclHead l -> DeclHead l -> Bool
    /= :: DeclHead l -> DeclHead l -> Bool
    Eq,Eq (DeclHead l)
    Eq (DeclHead l) =>
    (DeclHead l -> DeclHead l -> Ordering)
    -> (DeclHead l -> DeclHead l -> Bool)
    -> (DeclHead l -> DeclHead l -> Bool)
    -> (DeclHead l -> DeclHead l -> Bool)
    -> (DeclHead l -> DeclHead l -> Bool)
    -> (DeclHead l -> DeclHead l -> DeclHead l)
    -> (DeclHead l -> DeclHead l -> DeclHead l)
    -> Ord (DeclHead l)
    DeclHead l -> DeclHead l -> Bool
    DeclHead l -> DeclHead l -> Ordering
    DeclHead l -> DeclHead l -> DeclHead l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (DeclHead l)
    forall l. Ord l => DeclHead l -> DeclHead l -> Bool
    forall l. Ord l => DeclHead l -> DeclHead l -> Ordering
    forall l. Ord l => DeclHead l -> DeclHead l -> DeclHead l
    $ccompare :: forall l. Ord l => DeclHead l -> DeclHead l -> Ordering
    compare :: DeclHead l -> DeclHead l -> Ordering
    $c< :: forall l. Ord l => DeclHead l -> DeclHead l -> Bool
    < :: DeclHead l -> DeclHead l -> Bool
    $c<= :: forall l. Ord l => DeclHead l -> DeclHead l -> Bool
    <= :: DeclHead l -> DeclHead l -> Bool
    $c> :: forall l. Ord l => DeclHead l -> DeclHead l -> Bool
    > :: DeclHead l -> DeclHead l -> Bool
    $c>= :: forall l. Ord l => DeclHead l -> DeclHead l -> Bool
    >= :: DeclHead l -> DeclHead l -> Bool
    $cmax :: forall l. Ord l => DeclHead l -> DeclHead l -> DeclHead l
    max :: DeclHead l -> DeclHead l -> DeclHead l
    $cmin :: forall l. Ord l => DeclHead l -> DeclHead l -> DeclHead l
    min :: DeclHead l -> DeclHead l -> DeclHead l
    Ord,Int -> DeclHead l -> ShowS
    [DeclHead l] -> ShowS
    DeclHead l -> String
    (Int -> DeclHead l -> ShowS)
    -> (DeclHead l -> String)
    -> ([DeclHead l] -> ShowS)
    -> Show (DeclHead l)
    forall l. Show l => Int -> DeclHead l -> ShowS
    forall l. Show l => [DeclHead l] -> ShowS
    forall l. Show l => DeclHead l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> DeclHead l -> ShowS
    showsPrec :: Int -> DeclHead l -> ShowS
    $cshow :: forall l. Show l => DeclHead l -> String
    show :: DeclHead l -> String
    $cshowList :: forall l. Show l => [DeclHead l] -> ShowS
    showList :: [DeclHead l] -> ShowS
    Show,Typeable,Typeable (DeclHead l)
    Typeable (DeclHead l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (DeclHead l))
    -> (DeclHead l -> Constr)
    -> (DeclHead l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (DeclHead l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (DeclHead l)))
    -> ((forall b. Data b => b -> b) -> DeclHead l -> DeclHead l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DeclHead l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DeclHead l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l))
    -> Data (DeclHead l)
    DeclHead l -> Constr
    DeclHead l -> DataType
    (forall b. Data b => b -> b) -> DeclHead l -> DeclHead l
    forall l. Data l => Typeable (DeclHead l)
    forall l. Data l => DeclHead l -> Constr
    forall l. Data l => DeclHead l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> DeclHead l -> DeclHead l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> DeclHead l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> DeclHead l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DeclHead l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DeclHead l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DeclHead l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> DeclHead l -> u
    forall u. (forall d. Data d => d -> u) -> DeclHead l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DeclHead l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DeclHead l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DeclHead l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DeclHead l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DeclHead l)
    $ctoConstr :: forall l. Data l => DeclHead l -> Constr
    toConstr :: DeclHead l -> Constr
    $cdataTypeOf :: forall l. Data l => DeclHead l -> DataType
    dataTypeOf :: DeclHead l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DeclHead l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DeclHead l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DeclHead l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DeclHead l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> DeclHead l -> DeclHead l
    gmapT :: (forall b. Data b => b -> b) -> DeclHead l -> DeclHead l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> DeclHead l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DeclHead l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> DeclHead l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeclHead l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l)
    Data,(forall m. Monoid m => DeclHead m -> m)
    -> (forall m a. Monoid m => (a -> m) -> DeclHead a -> m)
    -> (forall m a. Monoid m => (a -> m) -> DeclHead a -> m)
    -> (forall a b. (a -> b -> b) -> b -> DeclHead a -> b)
    -> (forall a b. (a -> b -> b) -> b -> DeclHead a -> b)
    -> (forall b a. (b -> a -> b) -> b -> DeclHead a -> b)
    -> (forall b a. (b -> a -> b) -> b -> DeclHead a -> b)
    -> (forall a. (a -> a -> a) -> DeclHead a -> a)
    -> (forall a. (a -> a -> a) -> DeclHead a -> a)
    -> (forall a. DeclHead a -> [a])
    -> (forall a. DeclHead a -> Bool)
    -> (forall a. DeclHead a -> Int)
    -> (forall a. Eq a => a -> DeclHead a -> Bool)
    -> (forall a. Ord a => DeclHead a -> a)
    -> (forall a. Ord a => DeclHead a -> a)
    -> (forall a. Num a => DeclHead a -> a)
    -> (forall a. Num a => DeclHead a -> a)
    -> Foldable DeclHead
    forall a. Eq a => a -> DeclHead a -> Bool
    forall a. Num a => DeclHead a -> a
    forall a. Ord a => DeclHead a -> a
    forall m. Monoid m => DeclHead m -> m
    forall a. DeclHead a -> Bool
    forall a. DeclHead a -> Int
    forall a. DeclHead a -> [a]
    forall a. (a -> a -> a) -> DeclHead a -> a
    forall m a. Monoid m => (a -> m) -> DeclHead a -> m
    forall b a. (b -> a -> b) -> b -> DeclHead a -> b
    forall a b. (a -> b -> b) -> b -> DeclHead a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => DeclHead m -> m
    fold :: forall m. Monoid m => DeclHead m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> DeclHead a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> DeclHead a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> DeclHead a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> DeclHead a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> DeclHead a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> DeclHead a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> DeclHead a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> DeclHead a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> DeclHead a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> DeclHead a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> DeclHead a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> DeclHead a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> DeclHead a -> a
    foldr1 :: forall a. (a -> a -> a) -> DeclHead a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> DeclHead a -> a
    foldl1 :: forall a. (a -> a -> a) -> DeclHead a -> a
    $ctoList :: forall a. DeclHead a -> [a]
    toList :: forall a. DeclHead a -> [a]
    $cnull :: forall a. DeclHead a -> Bool
    null :: forall a. DeclHead a -> Bool
    $clength :: forall a. DeclHead a -> Int
    length :: forall a. DeclHead a -> Int
    $celem :: forall a. Eq a => a -> DeclHead a -> Bool
    elem :: forall a. Eq a => a -> DeclHead a -> Bool
    $cmaximum :: forall a. Ord a => DeclHead a -> a
    maximum :: forall a. Ord a => DeclHead a -> a
    $cminimum :: forall a. Ord a => DeclHead a -> a
    minimum :: forall a. Ord a => DeclHead a -> a
    $csum :: forall a. Num a => DeclHead a -> a
    sum :: forall a. Num a => DeclHead a -> a
    $cproduct :: forall a. Num a => DeclHead a -> a
    product :: forall a. Num a => DeclHead a -> a
    Foldable,Functor DeclHead
    Foldable DeclHead
    (Functor DeclHead, Foldable DeclHead) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> DeclHead a -> f (DeclHead b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        DeclHead (f a) -> f (DeclHead a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> DeclHead a -> m (DeclHead b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        DeclHead (m a) -> m (DeclHead a))
    -> Traversable DeclHead
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => DeclHead (m a) -> m (DeclHead a)
    forall (f :: * -> *) a.
    Applicative f =>
    DeclHead (f a) -> f (DeclHead a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DeclHead a -> m (DeclHead b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DeclHead a -> f (DeclHead b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DeclHead a -> f (DeclHead b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DeclHead a -> f (DeclHead b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    DeclHead (f a) -> f (DeclHead a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    DeclHead (f a) -> f (DeclHead a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DeclHead a -> m (DeclHead b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DeclHead a -> m (DeclHead b)
    $csequence :: forall (m :: * -> *) a. Monad m => DeclHead (m a) -> m (DeclHead a)
    sequence :: forall (m :: * -> *) a. Monad m => DeclHead (m a) -> m (DeclHead a)
    Traversable,(forall a b. (a -> b) -> DeclHead a -> DeclHead b)
    -> (forall a b. a -> DeclHead b -> DeclHead a) -> Functor DeclHead
    forall a b. a -> DeclHead b -> DeclHead a
    forall a b. (a -> b) -> DeclHead a -> DeclHead b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> DeclHead a -> DeclHead b
    fmap :: forall a b. (a -> b) -> DeclHead a -> DeclHead b
    $c<$ :: forall a b. a -> DeclHead b -> DeclHead a
    <$ :: forall a b. a -> DeclHead b -> DeclHead a
    Functor,(forall x. DeclHead l -> Rep (DeclHead l) x)
    -> (forall x. Rep (DeclHead l) x -> DeclHead l)
    -> Generic (DeclHead l)
    forall x. Rep (DeclHead l) x -> DeclHead l
    forall x. DeclHead l -> Rep (DeclHead l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (DeclHead l) x -> DeclHead l
    forall l x. DeclHead l -> Rep (DeclHead l) x
    $cfrom :: forall l x. DeclHead l -> Rep (DeclHead l) x
    from :: forall x. DeclHead l -> Rep (DeclHead l) x
    $cto :: forall l x. Rep (DeclHead l) x -> DeclHead l
    to :: forall x. Rep (DeclHead l) x -> DeclHead l
    Generic)

    -- | The instance declaration rule, which is, roughly, the part of the instance declaration before the @where@ keyword.
    --
    -- Example: @instance Ord a => Ord (Maybe a)@ is represented as
    --
    -- >IRule
    -- >   ()
    -- >   Nothing
    -- >   (Just
    -- >      (CxSingle
    -- >         ()
    -- >         (ClassA
    -- >            () (UnQual () (Ident () "Ord")) [ TyVar () (Ident () "a") ])))
    -- >   (IHApp
    -- >      ()
    -- >      (IHCon () (UnQual () (Ident () "Ord")))
    -- >      (TyParen
    -- >         ()
    -- >         (TyApp
    -- >            ()
    -- >            (TyCon () (UnQual () (Ident () "Maybe")))
    -- >            (TyVar () (Ident () "a")))))
    --
    -- An optional explicit forall after @instance@ is supported:
    -- @instance forall a . Ord a => Ord (Maybe a) where@ becomes
    --
    -- >IRule
    -- >   ()
    -- >   (Just [ UnkindedVar () (Ident () "a") ])
    -- >   ...
    data InstRule l
        = IRule l (Maybe [TyVarBind l]) (Maybe (Context l)) (InstHead l)
        | IParen l (InstRule l)
      deriving (InstRule l -> InstRule l -> Bool
    (InstRule l -> InstRule l -> Bool)
    -> (InstRule l -> InstRule l -> Bool) -> Eq (InstRule l)
    forall l. Eq l => InstRule l -> InstRule l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => InstRule l -> InstRule l -> Bool
    == :: InstRule l -> InstRule l -> Bool
    $c/= :: forall l. Eq l => InstRule l -> InstRule l -> Bool
    /= :: InstRule l -> InstRule l -> Bool
    Eq,Eq (InstRule l)
    Eq (InstRule l) =>
    (InstRule l -> InstRule l -> Ordering)
    -> (InstRule l -> InstRule l -> Bool)
    -> (InstRule l -> InstRule l -> Bool)
    -> (InstRule l -> InstRule l -> Bool)
    -> (InstRule l -> InstRule l -> Bool)
    -> (InstRule l -> InstRule l -> InstRule l)
    -> (InstRule l -> InstRule l -> InstRule l)
    -> Ord (InstRule l)
    InstRule l -> InstRule l -> Bool
    InstRule l -> InstRule l -> Ordering
    InstRule l -> InstRule l -> InstRule l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (InstRule l)
    forall l. Ord l => InstRule l -> InstRule l -> Bool
    forall l. Ord l => InstRule l -> InstRule l -> Ordering
    forall l. Ord l => InstRule l -> InstRule l -> InstRule l
    $ccompare :: forall l. Ord l => InstRule l -> InstRule l -> Ordering
    compare :: InstRule l -> InstRule l -> Ordering
    $c< :: forall l. Ord l => InstRule l -> InstRule l -> Bool
    < :: InstRule l -> InstRule l -> Bool
    $c<= :: forall l. Ord l => InstRule l -> InstRule l -> Bool
    <= :: InstRule l -> InstRule l -> Bool
    $c> :: forall l. Ord l => InstRule l -> InstRule l -> Bool
    > :: InstRule l -> InstRule l -> Bool
    $c>= :: forall l. Ord l => InstRule l -> InstRule l -> Bool
    >= :: InstRule l -> InstRule l -> Bool
    $cmax :: forall l. Ord l => InstRule l -> InstRule l -> InstRule l
    max :: InstRule l -> InstRule l -> InstRule l
    $cmin :: forall l. Ord l => InstRule l -> InstRule l -> InstRule l
    min :: InstRule l -> InstRule l -> InstRule l
    Ord,Int -> InstRule l -> ShowS
    [InstRule l] -> ShowS
    InstRule l -> String
    (Int -> InstRule l -> ShowS)
    -> (InstRule l -> String)
    -> ([InstRule l] -> ShowS)
    -> Show (InstRule l)
    forall l. Show l => Int -> InstRule l -> ShowS
    forall l. Show l => [InstRule l] -> ShowS
    forall l. Show l => InstRule l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> InstRule l -> ShowS
    showsPrec :: Int -> InstRule l -> ShowS
    $cshow :: forall l. Show l => InstRule l -> String
    show :: InstRule l -> String
    $cshowList :: forall l. Show l => [InstRule l] -> ShowS
    showList :: [InstRule l] -> ShowS
    Show,Typeable,Typeable (InstRule l)
    Typeable (InstRule l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> InstRule l -> c (InstRule l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (InstRule l))
    -> (InstRule l -> Constr)
    -> (InstRule l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (InstRule l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (InstRule l)))
    -> ((forall b. Data b => b -> b) -> InstRule l -> InstRule l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> InstRule l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> InstRule l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> InstRule l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> InstRule l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l))
    -> Data (InstRule l)
    InstRule l -> Constr
    InstRule l -> DataType
    (forall b. Data b => b -> b) -> InstRule l -> InstRule l
    forall l. Data l => Typeable (InstRule l)
    forall l. Data l => InstRule l -> Constr
    forall l. Data l => InstRule l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> InstRule l -> InstRule l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> InstRule l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> InstRule l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstRule l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstRule l -> c (InstRule l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstRule l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstRule l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> InstRule l -> u
    forall u. (forall d. Data d => d -> u) -> InstRule l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstRule l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstRule l -> c (InstRule l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstRule l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstRule l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstRule l -> c (InstRule l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstRule l -> c (InstRule l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstRule l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstRule l)
    $ctoConstr :: forall l. Data l => InstRule l -> Constr
    toConstr :: InstRule l -> Constr
    $cdataTypeOf :: forall l. Data l => InstRule l -> DataType
    dataTypeOf :: InstRule l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstRule l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstRule l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstRule l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstRule l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> InstRule l -> InstRule l
    gmapT :: (forall b. Data b => b -> b) -> InstRule l -> InstRule l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstRule l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> InstRule l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> InstRule l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> InstRule l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InstRule l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l)
    Data,(forall m. Monoid m => InstRule m -> m)
    -> (forall m a. Monoid m => (a -> m) -> InstRule a -> m)
    -> (forall m a. Monoid m => (a -> m) -> InstRule a -> m)
    -> (forall a b. (a -> b -> b) -> b -> InstRule a -> b)
    -> (forall a b. (a -> b -> b) -> b -> InstRule a -> b)
    -> (forall b a. (b -> a -> b) -> b -> InstRule a -> b)
    -> (forall b a. (b -> a -> b) -> b -> InstRule a -> b)
    -> (forall a. (a -> a -> a) -> InstRule a -> a)
    -> (forall a. (a -> a -> a) -> InstRule a -> a)
    -> (forall a. InstRule a -> [a])
    -> (forall a. InstRule a -> Bool)
    -> (forall a. InstRule a -> Int)
    -> (forall a. Eq a => a -> InstRule a -> Bool)
    -> (forall a. Ord a => InstRule a -> a)
    -> (forall a. Ord a => InstRule a -> a)
    -> (forall a. Num a => InstRule a -> a)
    -> (forall a. Num a => InstRule a -> a)
    -> Foldable InstRule
    forall a. Eq a => a -> InstRule a -> Bool
    forall a. Num a => InstRule a -> a
    forall a. Ord a => InstRule a -> a
    forall m. Monoid m => InstRule m -> m
    forall a. InstRule a -> Bool
    forall a. InstRule a -> Int
    forall a. InstRule a -> [a]
    forall a. (a -> a -> a) -> InstRule a -> a
    forall m a. Monoid m => (a -> m) -> InstRule a -> m
    forall b a. (b -> a -> b) -> b -> InstRule a -> b
    forall a b. (a -> b -> b) -> b -> InstRule a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => InstRule m -> m
    fold :: forall m. Monoid m => InstRule m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> InstRule a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> InstRule a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> InstRule a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> InstRule a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> InstRule a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> InstRule a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> InstRule a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> InstRule a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> InstRule a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> InstRule a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> InstRule a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> InstRule a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> InstRule a -> a
    foldr1 :: forall a. (a -> a -> a) -> InstRule a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> InstRule a -> a
    foldl1 :: forall a. (a -> a -> a) -> InstRule a -> a
    $ctoList :: forall a. InstRule a -> [a]
    toList :: forall a. InstRule a -> [a]
    $cnull :: forall a. InstRule a -> Bool
    null :: forall a. InstRule a -> Bool
    $clength :: forall a. InstRule a -> Int
    length :: forall a. InstRule a -> Int
    $celem :: forall a. Eq a => a -> InstRule a -> Bool
    elem :: forall a. Eq a => a -> InstRule a -> Bool
    $cmaximum :: forall a. Ord a => InstRule a -> a
    maximum :: forall a. Ord a => InstRule a -> a
    $cminimum :: forall a. Ord a => InstRule a -> a
    minimum :: forall a. Ord a => InstRule a -> a
    $csum :: forall a. Num a => InstRule a -> a
    sum :: forall a. Num a => InstRule a -> a
    $cproduct :: forall a. Num a => InstRule a -> a
    product :: forall a. Num a => InstRule a -> a
    Foldable,Functor InstRule
    Foldable InstRule
    (Functor InstRule, Foldable InstRule) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> InstRule a -> f (InstRule b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        InstRule (f a) -> f (InstRule a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> InstRule a -> m (InstRule b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        InstRule (m a) -> m (InstRule a))
    -> Traversable InstRule
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => InstRule (m a) -> m (InstRule a)
    forall (f :: * -> *) a.
    Applicative f =>
    InstRule (f a) -> f (InstRule a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstRule a -> m (InstRule b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstRule a -> f (InstRule b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstRule a -> f (InstRule b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstRule a -> f (InstRule b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    InstRule (f a) -> f (InstRule a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    InstRule (f a) -> f (InstRule a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstRule a -> m (InstRule b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstRule a -> m (InstRule b)
    $csequence :: forall (m :: * -> *) a. Monad m => InstRule (m a) -> m (InstRule a)
    sequence :: forall (m :: * -> *) a. Monad m => InstRule (m a) -> m (InstRule a)
    Traversable,(forall a b. (a -> b) -> InstRule a -> InstRule b)
    -> (forall a b. a -> InstRule b -> InstRule a) -> Functor InstRule
    forall a b. a -> InstRule b -> InstRule a
    forall a b. (a -> b) -> InstRule a -> InstRule b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> InstRule a -> InstRule b
    fmap :: forall a b. (a -> b) -> InstRule a -> InstRule b
    $c<$ :: forall a b. a -> InstRule b -> InstRule a
    <$ :: forall a b. a -> InstRule b -> InstRule a
    Functor,(forall x. InstRule l -> Rep (InstRule l) x)
    -> (forall x. Rep (InstRule l) x -> InstRule l)
    -> Generic (InstRule l)
    forall x. Rep (InstRule l) x -> InstRule l
    forall x. InstRule l -> Rep (InstRule l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (InstRule l) x -> InstRule l
    forall l x. InstRule l -> Rep (InstRule l) x
    $cfrom :: forall l x. InstRule l -> Rep (InstRule l) x
    from :: forall x. InstRule l -> Rep (InstRule l) x
    $cto :: forall l x. Rep (InstRule l) x -> InstRule l
    to :: forall x. Rep (InstRule l) x -> InstRule l
    Generic)

    -- See bugs #7 and #31 for more details and use cases for the rationale
    -- of the split. DeclOrInstHead should be used by DeclHead as the name implies.

    -- | The instance head. The split between rule/head allow us to represent
    -- @instance (Bounded a => Bounded [a]) where@ faithfully.
    --
    -- The structure of 'InstHead' follows one of 'DeclHead'.
    --
    -- For example, @instance C (Maybe a) Int where@ is represented as
    --
    -- >IHApp
    -- >   ()
    -- >   (IHApp
    -- >      ()
    -- >      (IHCon () (UnQual () (Ident () "C")))
    -- >      (TyParen
    -- >         ()
    -- >         (TyApp
    -- >            ()
    -- >            (TyCon () (UnQual () (Ident () "Maybe")))
    -- >            (TyVar () (Ident () "a")))))
    -- >   (TyCon () (UnQual () (Ident () "Int")))))
    data InstHead l
        = IHCon l (QName l) -- ^ type or class name
        | IHInfix l (Type l) (QName l) -- ^ infix application of the type/class name to the left operand
        | IHParen l (InstHead l) -- ^ parenthesized instance head
        | IHApp   l (InstHead l) (Type l) -- ^ application to one more type
      deriving (InstHead l -> InstHead l -> Bool
    (InstHead l -> InstHead l -> Bool)
    -> (InstHead l -> InstHead l -> Bool) -> Eq (InstHead l)
    forall l. Eq l => InstHead l -> InstHead l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => InstHead l -> InstHead l -> Bool
    == :: InstHead l -> InstHead l -> Bool
    $c/= :: forall l. Eq l => InstHead l -> InstHead l -> Bool
    /= :: InstHead l -> InstHead l -> Bool
    Eq,Eq (InstHead l)
    Eq (InstHead l) =>
    (InstHead l -> InstHead l -> Ordering)
    -> (InstHead l -> InstHead l -> Bool)
    -> (InstHead l -> InstHead l -> Bool)
    -> (InstHead l -> InstHead l -> Bool)
    -> (InstHead l -> InstHead l -> Bool)
    -> (InstHead l -> InstHead l -> InstHead l)
    -> (InstHead l -> InstHead l -> InstHead l)
    -> Ord (InstHead l)
    InstHead l -> InstHead l -> Bool
    InstHead l -> InstHead l -> Ordering
    InstHead l -> InstHead l -> InstHead l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (InstHead l)
    forall l. Ord l => InstHead l -> InstHead l -> Bool
    forall l. Ord l => InstHead l -> InstHead l -> Ordering
    forall l. Ord l => InstHead l -> InstHead l -> InstHead l
    $ccompare :: forall l. Ord l => InstHead l -> InstHead l -> Ordering
    compare :: InstHead l -> InstHead l -> Ordering
    $c< :: forall l. Ord l => InstHead l -> InstHead l -> Bool
    < :: InstHead l -> InstHead l -> Bool
    $c<= :: forall l. Ord l => InstHead l -> InstHead l -> Bool
    <= :: InstHead l -> InstHead l -> Bool
    $c> :: forall l. Ord l => InstHead l -> InstHead l -> Bool
    > :: InstHead l -> InstHead l -> Bool
    $c>= :: forall l. Ord l => InstHead l -> InstHead l -> Bool
    >= :: InstHead l -> InstHead l -> Bool
    $cmax :: forall l. Ord l => InstHead l -> InstHead l -> InstHead l
    max :: InstHead l -> InstHead l -> InstHead l
    $cmin :: forall l. Ord l => InstHead l -> InstHead l -> InstHead l
    min :: InstHead l -> InstHead l -> InstHead l
    Ord,Int -> InstHead l -> ShowS
    [InstHead l] -> ShowS
    InstHead l -> String
    (Int -> InstHead l -> ShowS)
    -> (InstHead l -> String)
    -> ([InstHead l] -> ShowS)
    -> Show (InstHead l)
    forall l. Show l => Int -> InstHead l -> ShowS
    forall l. Show l => [InstHead l] -> ShowS
    forall l. Show l => InstHead l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> InstHead l -> ShowS
    showsPrec :: Int -> InstHead l -> ShowS
    $cshow :: forall l. Show l => InstHead l -> String
    show :: InstHead l -> String
    $cshowList :: forall l. Show l => [InstHead l] -> ShowS
    showList :: [InstHead l] -> ShowS
    Show,Typeable,Typeable (InstHead l)
    Typeable (InstHead l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> InstHead l -> c (InstHead l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (InstHead l))
    -> (InstHead l -> Constr)
    -> (InstHead l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (InstHead l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (InstHead l)))
    -> ((forall b. Data b => b -> b) -> InstHead l -> InstHead l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> InstHead l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> InstHead l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> InstHead l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> InstHead l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l))
    -> Data (InstHead l)
    InstHead l -> Constr
    InstHead l -> DataType
    (forall b. Data b => b -> b) -> InstHead l -> InstHead l
    forall l. Data l => Typeable (InstHead l)
    forall l. Data l => InstHead l -> Constr
    forall l. Data l => InstHead l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> InstHead l -> InstHead l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> InstHead l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> InstHead l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstHead l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstHead l -> c (InstHead l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstHead l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstHead l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> InstHead l -> u
    forall u. (forall d. Data d => d -> u) -> InstHead l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstHead l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstHead l -> c (InstHead l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstHead l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstHead l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstHead l -> c (InstHead l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstHead l -> c (InstHead l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstHead l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstHead l)
    $ctoConstr :: forall l. Data l => InstHead l -> Constr
    toConstr :: InstHead l -> Constr
    $cdataTypeOf :: forall l. Data l => InstHead l -> DataType
    dataTypeOf :: InstHead l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstHead l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstHead l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstHead l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstHead l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> InstHead l -> InstHead l
    gmapT :: (forall b. Data b => b -> b) -> InstHead l -> InstHead l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstHead l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> InstHead l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> InstHead l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> InstHead l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InstHead l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l)
    Data,(forall m. Monoid m => InstHead m -> m)
    -> (forall m a. Monoid m => (a -> m) -> InstHead a -> m)
    -> (forall m a. Monoid m => (a -> m) -> InstHead a -> m)
    -> (forall a b. (a -> b -> b) -> b -> InstHead a -> b)
    -> (forall a b. (a -> b -> b) -> b -> InstHead a -> b)
    -> (forall b a. (b -> a -> b) -> b -> InstHead a -> b)
    -> (forall b a. (b -> a -> b) -> b -> InstHead a -> b)
    -> (forall a. (a -> a -> a) -> InstHead a -> a)
    -> (forall a. (a -> a -> a) -> InstHead a -> a)
    -> (forall a. InstHead a -> [a])
    -> (forall a. InstHead a -> Bool)
    -> (forall a. InstHead a -> Int)
    -> (forall a. Eq a => a -> InstHead a -> Bool)
    -> (forall a. Ord a => InstHead a -> a)
    -> (forall a. Ord a => InstHead a -> a)
    -> (forall a. Num a => InstHead a -> a)
    -> (forall a. Num a => InstHead a -> a)
    -> Foldable InstHead
    forall a. Eq a => a -> InstHead a -> Bool
    forall a. Num a => InstHead a -> a
    forall a. Ord a => InstHead a -> a
    forall m. Monoid m => InstHead m -> m
    forall a. InstHead a -> Bool
    forall a. InstHead a -> Int
    forall a. InstHead a -> [a]
    forall a. (a -> a -> a) -> InstHead a -> a
    forall m a. Monoid m => (a -> m) -> InstHead a -> m
    forall b a. (b -> a -> b) -> b -> InstHead a -> b
    forall a b. (a -> b -> b) -> b -> InstHead a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => InstHead m -> m
    fold :: forall m. Monoid m => InstHead m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> InstHead a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> InstHead a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> InstHead a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> InstHead a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> InstHead a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> InstHead a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> InstHead a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> InstHead a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> InstHead a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> InstHead a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> InstHead a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> InstHead a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> InstHead a -> a
    foldr1 :: forall a. (a -> a -> a) -> InstHead a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> InstHead a -> a
    foldl1 :: forall a. (a -> a -> a) -> InstHead a -> a
    $ctoList :: forall a. InstHead a -> [a]
    toList :: forall a. InstHead a -> [a]
    $cnull :: forall a. InstHead a -> Bool
    null :: forall a. InstHead a -> Bool
    $clength :: forall a. InstHead a -> Int
    length :: forall a. InstHead a -> Int
    $celem :: forall a. Eq a => a -> InstHead a -> Bool
    elem :: forall a. Eq a => a -> InstHead a -> Bool
    $cmaximum :: forall a. Ord a => InstHead a -> a
    maximum :: forall a. Ord a => InstHead a -> a
    $cminimum :: forall a. Ord a => InstHead a -> a
    minimum :: forall a. Ord a => InstHead a -> a
    $csum :: forall a. Num a => InstHead a -> a
    sum :: forall a. Num a => InstHead a -> a
    $cproduct :: forall a. Num a => InstHead a -> a
    product :: forall a. Num a => InstHead a -> a
    Foldable,Functor InstHead
    Foldable InstHead
    (Functor InstHead, Foldable InstHead) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> InstHead a -> f (InstHead b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        InstHead (f a) -> f (InstHead a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> InstHead a -> m (InstHead b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        InstHead (m a) -> m (InstHead a))
    -> Traversable InstHead
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => InstHead (m a) -> m (InstHead a)
    forall (f :: * -> *) a.
    Applicative f =>
    InstHead (f a) -> f (InstHead a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstHead a -> m (InstHead b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstHead a -> f (InstHead b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstHead a -> f (InstHead b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstHead a -> f (InstHead b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    InstHead (f a) -> f (InstHead a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    InstHead (f a) -> f (InstHead a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstHead a -> m (InstHead b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstHead a -> m (InstHead b)
    $csequence :: forall (m :: * -> *) a. Monad m => InstHead (m a) -> m (InstHead a)
    sequence :: forall (m :: * -> *) a. Monad m => InstHead (m a) -> m (InstHead a)
    Traversable,(forall a b. (a -> b) -> InstHead a -> InstHead b)
    -> (forall a b. a -> InstHead b -> InstHead a) -> Functor InstHead
    forall a b. a -> InstHead b -> InstHead a
    forall a b. (a -> b) -> InstHead a -> InstHead b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> InstHead a -> InstHead b
    fmap :: forall a b. (a -> b) -> InstHead a -> InstHead b
    $c<$ :: forall a b. a -> InstHead b -> InstHead a
    <$ :: forall a b. a -> InstHead b -> InstHead a
    Functor,(forall x. InstHead l -> Rep (InstHead l) x)
    -> (forall x. Rep (InstHead l) x -> InstHead l)
    -> Generic (InstHead l)
    forall x. Rep (InstHead l) x -> InstHead l
    forall x. InstHead l -> Rep (InstHead l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (InstHead l) x -> InstHead l
    forall l x. InstHead l -> Rep (InstHead l) x
    $cfrom :: forall l x. InstHead l -> Rep (InstHead l) x
    from :: forall x. InstHead l -> Rep (InstHead l) x
    $cto :: forall l x. Rep (InstHead l) x -> InstHead l
    to :: forall x. Rep (InstHead l) x -> InstHead l
    Generic)

    -- | A deriving clause following a data type declaration.
    data Deriving l = Deriving l (Maybe (DerivStrategy l)) [InstRule l]
      deriving (Deriving l -> Deriving l -> Bool
    (Deriving l -> Deriving l -> Bool)
    -> (Deriving l -> Deriving l -> Bool) -> Eq (Deriving l)
    forall l. Eq l => Deriving l -> Deriving l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Deriving l -> Deriving l -> Bool
    == :: Deriving l -> Deriving l -> Bool
    $c/= :: forall l. Eq l => Deriving l -> Deriving l -> Bool
    /= :: Deriving l -> Deriving l -> Bool
    Eq,Eq (Deriving l)
    Eq (Deriving l) =>
    (Deriving l -> Deriving l -> Ordering)
    -> (Deriving l -> Deriving l -> Bool)
    -> (Deriving l -> Deriving l -> Bool)
    -> (Deriving l -> Deriving l -> Bool)
    -> (Deriving l -> Deriving l -> Bool)
    -> (Deriving l -> Deriving l -> Deriving l)
    -> (Deriving l -> Deriving l -> Deriving l)
    -> Ord (Deriving l)
    Deriving l -> Deriving l -> Bool
    Deriving l -> Deriving l -> Ordering
    Deriving l -> Deriving l -> Deriving l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Deriving l)
    forall l. Ord l => Deriving l -> Deriving l -> Bool
    forall l. Ord l => Deriving l -> Deriving l -> Ordering
    forall l. Ord l => Deriving l -> Deriving l -> Deriving l
    $ccompare :: forall l. Ord l => Deriving l -> Deriving l -> Ordering
    compare :: Deriving l -> Deriving l -> Ordering
    $c< :: forall l. Ord l => Deriving l -> Deriving l -> Bool
    < :: Deriving l -> Deriving l -> Bool
    $c<= :: forall l. Ord l => Deriving l -> Deriving l -> Bool
    <= :: Deriving l -> Deriving l -> Bool
    $c> :: forall l. Ord l => Deriving l -> Deriving l -> Bool
    > :: Deriving l -> Deriving l -> Bool
    $c>= :: forall l. Ord l => Deriving l -> Deriving l -> Bool
    >= :: Deriving l -> Deriving l -> Bool
    $cmax :: forall l. Ord l => Deriving l -> Deriving l -> Deriving l
    max :: Deriving l -> Deriving l -> Deriving l
    $cmin :: forall l. Ord l => Deriving l -> Deriving l -> Deriving l
    min :: Deriving l -> Deriving l -> Deriving l
    Ord,Int -> Deriving l -> ShowS
    [Deriving l] -> ShowS
    Deriving l -> String
    (Int -> Deriving l -> ShowS)
    -> (Deriving l -> String)
    -> ([Deriving l] -> ShowS)
    -> Show (Deriving l)
    forall l. Show l => Int -> Deriving l -> ShowS
    forall l. Show l => [Deriving l] -> ShowS
    forall l. Show l => Deriving l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Deriving l -> ShowS
    showsPrec :: Int -> Deriving l -> ShowS
    $cshow :: forall l. Show l => Deriving l -> String
    show :: Deriving l -> String
    $cshowList :: forall l. Show l => [Deriving l] -> ShowS
    showList :: [Deriving l] -> ShowS
    Show,Typeable,Typeable (Deriving l)
    Typeable (Deriving l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Deriving l -> c (Deriving l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Deriving l))
    -> (Deriving l -> Constr)
    -> (Deriving l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Deriving l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Deriving l)))
    -> ((forall b. Data b => b -> b) -> Deriving l -> Deriving l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Deriving l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Deriving l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Deriving l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Deriving l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l))
    -> Data (Deriving l)
    Deriving l -> Constr
    Deriving l -> DataType
    (forall b. Data b => b -> b) -> Deriving l -> Deriving l
    forall l. Data l => Typeable (Deriving l)
    forall l. Data l => Deriving l -> Constr
    forall l. Data l => Deriving l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Deriving l -> Deriving l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Deriving l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Deriving l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Deriving l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Deriving l -> c (Deriving l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Deriving l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Deriving l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Deriving l -> u
    forall u. (forall d. Data d => d -> u) -> Deriving l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Deriving l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Deriving l -> c (Deriving l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Deriving l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Deriving l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Deriving l -> c (Deriving l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Deriving l -> c (Deriving l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Deriving l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Deriving l)
    $ctoConstr :: forall l. Data l => Deriving l -> Constr
    toConstr :: Deriving l -> Constr
    $cdataTypeOf :: forall l. Data l => Deriving l -> DataType
    dataTypeOf :: Deriving l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Deriving l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Deriving l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Deriving l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Deriving l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Deriving l -> Deriving l
    gmapT :: (forall b. Data b => b -> b) -> Deriving l -> Deriving l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Deriving l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Deriving l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Deriving l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Deriving l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Deriving l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l)
    Data,(forall m. Monoid m => Deriving m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Deriving a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Deriving a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Deriving a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Deriving a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Deriving a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Deriving a -> b)
    -> (forall a. (a -> a -> a) -> Deriving a -> a)
    -> (forall a. (a -> a -> a) -> Deriving a -> a)
    -> (forall a. Deriving a -> [a])
    -> (forall a. Deriving a -> Bool)
    -> (forall a. Deriving a -> Int)
    -> (forall a. Eq a => a -> Deriving a -> Bool)
    -> (forall a. Ord a => Deriving a -> a)
    -> (forall a. Ord a => Deriving a -> a)
    -> (forall a. Num a => Deriving a -> a)
    -> (forall a. Num a => Deriving a -> a)
    -> Foldable Deriving
    forall a. Eq a => a -> Deriving a -> Bool
    forall a. Num a => Deriving a -> a
    forall a. Ord a => Deriving a -> a
    forall m. Monoid m => Deriving m -> m
    forall a. Deriving a -> Bool
    forall a. Deriving a -> Int
    forall a. Deriving a -> [a]
    forall a. (a -> a -> a) -> Deriving a -> a
    forall m a. Monoid m => (a -> m) -> Deriving a -> m
    forall b a. (b -> a -> b) -> b -> Deriving a -> b
    forall a b. (a -> b -> b) -> b -> Deriving a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Deriving m -> m
    fold :: forall m. Monoid m => Deriving m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Deriving a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Deriving a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Deriving a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Deriving a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Deriving a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Deriving a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Deriving a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Deriving a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Deriving a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Deriving a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Deriving a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Deriving a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Deriving a -> a
    foldr1 :: forall a. (a -> a -> a) -> Deriving a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Deriving a -> a
    foldl1 :: forall a. (a -> a -> a) -> Deriving a -> a
    $ctoList :: forall a. Deriving a -> [a]
    toList :: forall a. Deriving a -> [a]
    $cnull :: forall a. Deriving a -> Bool
    null :: forall a. Deriving a -> Bool
    $clength :: forall a. Deriving a -> Int
    length :: forall a. Deriving a -> Int
    $celem :: forall a. Eq a => a -> Deriving a -> Bool
    elem :: forall a. Eq a => a -> Deriving a -> Bool
    $cmaximum :: forall a. Ord a => Deriving a -> a
    maximum :: forall a. Ord a => Deriving a -> a
    $cminimum :: forall a. Ord a => Deriving a -> a
    minimum :: forall a. Ord a => Deriving a -> a
    $csum :: forall a. Num a => Deriving a -> a
    sum :: forall a. Num a => Deriving a -> a
    $cproduct :: forall a. Num a => Deriving a -> a
    product :: forall a. Num a => Deriving a -> a
    Foldable,Functor Deriving
    Foldable Deriving
    (Functor Deriving, Foldable Deriving) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Deriving a -> f (Deriving b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Deriving (f a) -> f (Deriving a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Deriving a -> m (Deriving b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Deriving (m a) -> m (Deriving a))
    -> Traversable Deriving
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Deriving (m a) -> m (Deriving a)
    forall (f :: * -> *) a.
    Applicative f =>
    Deriving (f a) -> f (Deriving a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Deriving a -> m (Deriving b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Deriving a -> f (Deriving b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Deriving a -> f (Deriving b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Deriving a -> f (Deriving b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Deriving (f a) -> f (Deriving a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Deriving (f a) -> f (Deriving a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Deriving a -> m (Deriving b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Deriving a -> m (Deriving b)
    $csequence :: forall (m :: * -> *) a. Monad m => Deriving (m a) -> m (Deriving a)
    sequence :: forall (m :: * -> *) a. Monad m => Deriving (m a) -> m (Deriving a)
    Traversable,(forall a b. (a -> b) -> Deriving a -> Deriving b)
    -> (forall a b. a -> Deriving b -> Deriving a) -> Functor Deriving
    forall a b. a -> Deriving b -> Deriving a
    forall a b. (a -> b) -> Deriving a -> Deriving b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Deriving a -> Deriving b
    fmap :: forall a b. (a -> b) -> Deriving a -> Deriving b
    $c<$ :: forall a b. a -> Deriving b -> Deriving a
    <$ :: forall a b. a -> Deriving b -> Deriving a
    Functor,(forall x. Deriving l -> Rep (Deriving l) x)
    -> (forall x. Rep (Deriving l) x -> Deriving l)
    -> Generic (Deriving l)
    forall x. Rep (Deriving l) x -> Deriving l
    forall x. Deriving l -> Rep (Deriving l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Deriving l) x -> Deriving l
    forall l x. Deriving l -> Rep (Deriving l) x
    $cfrom :: forall l x. Deriving l -> Rep (Deriving l) x
    from :: forall x. Deriving l -> Rep (Deriving l) x
    $cto :: forall l x. Rep (Deriving l) x -> Deriving l
    to :: forall x. Rep (Deriving l) x -> Deriving l
    Generic)

    -- | Which technique the user explicitly requested when deriving an instance.
    data DerivStrategy l
      = DerivStock l        -- ^ GHC's \"standard\" strategy, which is to implement a
                            --   custom instance for the data type. This only works for
                            --   certain types that GHC knows about (e.g., 'Eq', 'Show',
                            --   'Functor' when @-XDeriveFunctor@ is enabled, etc.)
      | DerivAnyclass l     -- ^ @-XDeriveAnyClass@
      | DerivNewtype l      -- ^ @-XGeneralizedNewtypeDeriving@
      | DerivVia l (Type l) -- ^ @-XDerivingVia@
      deriving (DerivStrategy l -> DerivStrategy l -> Bool
    (DerivStrategy l -> DerivStrategy l -> Bool)
    -> (DerivStrategy l -> DerivStrategy l -> Bool)
    -> Eq (DerivStrategy l)
    forall l. Eq l => DerivStrategy l -> DerivStrategy l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => DerivStrategy l -> DerivStrategy l -> Bool
    == :: DerivStrategy l -> DerivStrategy l -> Bool
    $c/= :: forall l. Eq l => DerivStrategy l -> DerivStrategy l -> Bool
    /= :: DerivStrategy l -> DerivStrategy l -> Bool
    Eq,Eq (DerivStrategy l)
    Eq (DerivStrategy l) =>
    (DerivStrategy l -> DerivStrategy l -> Ordering)
    -> (DerivStrategy l -> DerivStrategy l -> Bool)
    -> (DerivStrategy l -> DerivStrategy l -> Bool)
    -> (DerivStrategy l -> DerivStrategy l -> Bool)
    -> (DerivStrategy l -> DerivStrategy l -> Bool)
    -> (DerivStrategy l -> DerivStrategy l -> DerivStrategy l)
    -> (DerivStrategy l -> DerivStrategy l -> DerivStrategy l)
    -> Ord (DerivStrategy l)
    DerivStrategy l -> DerivStrategy l -> Bool
    DerivStrategy l -> DerivStrategy l -> Ordering
    DerivStrategy l -> DerivStrategy l -> DerivStrategy l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (DerivStrategy l)
    forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
    forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Ordering
    forall l.
    Ord l =>
    DerivStrategy l -> DerivStrategy l -> DerivStrategy l
    $ccompare :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Ordering
    compare :: DerivStrategy l -> DerivStrategy l -> Ordering
    $c< :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
    < :: DerivStrategy l -> DerivStrategy l -> Bool
    $c<= :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
    <= :: DerivStrategy l -> DerivStrategy l -> Bool
    $c> :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
    > :: DerivStrategy l -> DerivStrategy l -> Bool
    $c>= :: forall l. Ord l => DerivStrategy l -> DerivStrategy l -> Bool
    >= :: DerivStrategy l -> DerivStrategy l -> Bool
    $cmax :: forall l.
    Ord l =>
    DerivStrategy l -> DerivStrategy l -> DerivStrategy l
    max :: DerivStrategy l -> DerivStrategy l -> DerivStrategy l
    $cmin :: forall l.
    Ord l =>
    DerivStrategy l -> DerivStrategy l -> DerivStrategy l
    min :: DerivStrategy l -> DerivStrategy l -> DerivStrategy l
    Ord,Int -> DerivStrategy l -> ShowS
    [DerivStrategy l] -> ShowS
    DerivStrategy l -> String
    (Int -> DerivStrategy l -> ShowS)
    -> (DerivStrategy l -> String)
    -> ([DerivStrategy l] -> ShowS)
    -> Show (DerivStrategy l)
    forall l. Show l => Int -> DerivStrategy l -> ShowS
    forall l. Show l => [DerivStrategy l] -> ShowS
    forall l. Show l => DerivStrategy l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> DerivStrategy l -> ShowS
    showsPrec :: Int -> DerivStrategy l -> ShowS
    $cshow :: forall l. Show l => DerivStrategy l -> String
    show :: DerivStrategy l -> String
    $cshowList :: forall l. Show l => [DerivStrategy l] -> ShowS
    showList :: [DerivStrategy l] -> ShowS
    Show,Typeable,Typeable (DerivStrategy l)
    Typeable (DerivStrategy l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (DerivStrategy l))
    -> (DerivStrategy l -> Constr)
    -> (DerivStrategy l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (DerivStrategy l)))
    -> ((forall b. Data b => b -> b)
        -> DerivStrategy l -> DerivStrategy l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> DerivStrategy l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> DerivStrategy l -> m (DerivStrategy l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DerivStrategy l -> m (DerivStrategy l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> DerivStrategy l -> m (DerivStrategy l))
    -> Data (DerivStrategy l)
    DerivStrategy l -> Constr
    DerivStrategy l -> DataType
    (forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l
    forall l. Data l => Typeable (DerivStrategy l)
    forall l. Data l => DerivStrategy l -> Constr
    forall l. Data l => DerivStrategy l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> DerivStrategy l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DerivStrategy l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DerivStrategy l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u
    forall u. (forall d. Data d => d -> u) -> DerivStrategy l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DerivStrategy l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DerivStrategy l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DerivStrategy l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DerivStrategy l)
    $ctoConstr :: forall l. Data l => DerivStrategy l -> Constr
    toConstr :: DerivStrategy l -> Constr
    $cdataTypeOf :: forall l. Data l => DerivStrategy l -> DataType
    dataTypeOf :: DerivStrategy l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DerivStrategy l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DerivStrategy l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l
    gmapT :: (forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> DerivStrategy l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DerivStrategy l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivStrategy l -> m (DerivStrategy l)
    Data,(forall m. Monoid m => DerivStrategy m -> m)
    -> (forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m)
    -> (forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m)
    -> (forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b)
    -> (forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b)
    -> (forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b)
    -> (forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b)
    -> (forall a. (a -> a -> a) -> DerivStrategy a -> a)
    -> (forall a. (a -> a -> a) -> DerivStrategy a -> a)
    -> (forall a. DerivStrategy a -> [a])
    -> (forall a. DerivStrategy a -> Bool)
    -> (forall a. DerivStrategy a -> Int)
    -> (forall a. Eq a => a -> DerivStrategy a -> Bool)
    -> (forall a. Ord a => DerivStrategy a -> a)
    -> (forall a. Ord a => DerivStrategy a -> a)
    -> (forall a. Num a => DerivStrategy a -> a)
    -> (forall a. Num a => DerivStrategy a -> a)
    -> Foldable DerivStrategy
    forall a. Eq a => a -> DerivStrategy a -> Bool
    forall a. Num a => DerivStrategy a -> a
    forall a. Ord a => DerivStrategy a -> a
    forall m. Monoid m => DerivStrategy m -> m
    forall a. DerivStrategy a -> Bool
    forall a. DerivStrategy a -> Int
    forall a. DerivStrategy a -> [a]
    forall a. (a -> a -> a) -> DerivStrategy a -> a
    forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
    forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
    forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => DerivStrategy m -> m
    fold :: forall m. Monoid m => DerivStrategy m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> DerivStrategy a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> DerivStrategy a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> DerivStrategy a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> DerivStrategy a -> a
    foldr1 :: forall a. (a -> a -> a) -> DerivStrategy a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> DerivStrategy a -> a
    foldl1 :: forall a. (a -> a -> a) -> DerivStrategy a -> a
    $ctoList :: forall a. DerivStrategy a -> [a]
    toList :: forall a. DerivStrategy a -> [a]
    $cnull :: forall a. DerivStrategy a -> Bool
    null :: forall a. DerivStrategy a -> Bool
    $clength :: forall a. DerivStrategy a -> Int
    length :: forall a. DerivStrategy a -> Int
    $celem :: forall a. Eq a => a -> DerivStrategy a -> Bool
    elem :: forall a. Eq a => a -> DerivStrategy a -> Bool
    $cmaximum :: forall a. Ord a => DerivStrategy a -> a
    maximum :: forall a. Ord a => DerivStrategy a -> a
    $cminimum :: forall a. Ord a => DerivStrategy a -> a
    minimum :: forall a. Ord a => DerivStrategy a -> a
    $csum :: forall a. Num a => DerivStrategy a -> a
    sum :: forall a. Num a => DerivStrategy a -> a
    $cproduct :: forall a. Num a => DerivStrategy a -> a
    product :: forall a. Num a => DerivStrategy a -> a
    Foldable,Functor DerivStrategy
    Foldable DerivStrategy
    (Functor DerivStrategy, Foldable DerivStrategy) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> DerivStrategy a -> f (DerivStrategy b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        DerivStrategy (f a) -> f (DerivStrategy a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> DerivStrategy a -> m (DerivStrategy b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        DerivStrategy (m a) -> m (DerivStrategy a))
    -> Traversable DerivStrategy
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    DerivStrategy (m a) -> m (DerivStrategy a)
    forall (f :: * -> *) a.
    Applicative f =>
    DerivStrategy (f a) -> f (DerivStrategy a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DerivStrategy a -> m (DerivStrategy b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DerivStrategy a -> f (DerivStrategy b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DerivStrategy a -> f (DerivStrategy b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> DerivStrategy a -> f (DerivStrategy b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    DerivStrategy (f a) -> f (DerivStrategy a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    DerivStrategy (f a) -> f (DerivStrategy a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DerivStrategy a -> m (DerivStrategy b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DerivStrategy a -> m (DerivStrategy b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    DerivStrategy (m a) -> m (DerivStrategy a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    DerivStrategy (m a) -> m (DerivStrategy a)
    Traversable,(forall a b. (a -> b) -> DerivStrategy a -> DerivStrategy b)
    -> (forall a b. a -> DerivStrategy b -> DerivStrategy a)
    -> Functor DerivStrategy
    forall a b. a -> DerivStrategy b -> DerivStrategy a
    forall a b. (a -> b) -> DerivStrategy a -> DerivStrategy b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> DerivStrategy a -> DerivStrategy b
    fmap :: forall a b. (a -> b) -> DerivStrategy a -> DerivStrategy b
    $c<$ :: forall a b. a -> DerivStrategy b -> DerivStrategy a
    <$ :: forall a b. a -> DerivStrategy b -> DerivStrategy a
    Functor,(forall x. DerivStrategy l -> Rep (DerivStrategy l) x)
    -> (forall x. Rep (DerivStrategy l) x -> DerivStrategy l)
    -> Generic (DerivStrategy l)
    forall x. Rep (DerivStrategy l) x -> DerivStrategy l
    forall x. DerivStrategy l -> Rep (DerivStrategy l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (DerivStrategy l) x -> DerivStrategy l
    forall l x. DerivStrategy l -> Rep (DerivStrategy l) x
    $cfrom :: forall l x. DerivStrategy l -> Rep (DerivStrategy l) x
    from :: forall x. DerivStrategy l -> Rep (DerivStrategy l) x
    $cto :: forall l x. Rep (DerivStrategy l) x -> DerivStrategy l
    to :: forall x. Rep (DerivStrategy l) x -> DerivStrategy l
    Generic)

    -- | A binding group inside a @let@ or @where@ clause.
    data Binds l
        = BDecls  l [Decl l]     -- ^ An ordinary binding group
        | IPBinds l [IPBind l]   -- ^ A binding group for implicit parameters
      deriving (Binds l -> Binds l -> Bool
    (Binds l -> Binds l -> Bool)
    -> (Binds l -> Binds l -> Bool) -> Eq (Binds l)
    forall l. Eq l => Binds l -> Binds l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Binds l -> Binds l -> Bool
    == :: Binds l -> Binds l -> Bool
    $c/= :: forall l. Eq l => Binds l -> Binds l -> Bool
    /= :: Binds l -> Binds l -> Bool
    Eq,Eq (Binds l)
    Eq (Binds l) =>
    (Binds l -> Binds l -> Ordering)
    -> (Binds l -> Binds l -> Bool)
    -> (Binds l -> Binds l -> Bool)
    -> (Binds l -> Binds l -> Bool)
    -> (Binds l -> Binds l -> Bool)
    -> (Binds l -> Binds l -> Binds l)
    -> (Binds l -> Binds l -> Binds l)
    -> Ord (Binds l)
    Binds l -> Binds l -> Bool
    Binds l -> Binds l -> Ordering
    Binds l -> Binds l -> Binds l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Binds l)
    forall l. Ord l => Binds l -> Binds l -> Bool
    forall l. Ord l => Binds l -> Binds l -> Ordering
    forall l. Ord l => Binds l -> Binds l -> Binds l
    $ccompare :: forall l. Ord l => Binds l -> Binds l -> Ordering
    compare :: Binds l -> Binds l -> Ordering
    $c< :: forall l. Ord l => Binds l -> Binds l -> Bool
    < :: Binds l -> Binds l -> Bool
    $c<= :: forall l. Ord l => Binds l -> Binds l -> Bool
    <= :: Binds l -> Binds l -> Bool
    $c> :: forall l. Ord l => Binds l -> Binds l -> Bool
    > :: Binds l -> Binds l -> Bool
    $c>= :: forall l. Ord l => Binds l -> Binds l -> Bool
    >= :: Binds l -> Binds l -> Bool
    $cmax :: forall l. Ord l => Binds l -> Binds l -> Binds l
    max :: Binds l -> Binds l -> Binds l
    $cmin :: forall l. Ord l => Binds l -> Binds l -> Binds l
    min :: Binds l -> Binds l -> Binds l
    Ord,Int -> Binds l -> ShowS
    [Binds l] -> ShowS
    Binds l -> String
    (Int -> Binds l -> ShowS)
    -> (Binds l -> String) -> ([Binds l] -> ShowS) -> Show (Binds l)
    forall l. Show l => Int -> Binds l -> ShowS
    forall l. Show l => [Binds l] -> ShowS
    forall l. Show l => Binds l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Binds l -> ShowS
    showsPrec :: Int -> Binds l -> ShowS
    $cshow :: forall l. Show l => Binds l -> String
    show :: Binds l -> String
    $cshowList :: forall l. Show l => [Binds l] -> ShowS
    showList :: [Binds l] -> ShowS
    Show,Typeable,Typeable (Binds l)
    Typeable (Binds l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Binds l -> c (Binds l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Binds l))
    -> (Binds l -> Constr)
    -> (Binds l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Binds l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l)))
    -> ((forall b. Data b => b -> b) -> Binds l -> Binds l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Binds l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Binds l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Binds l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Binds l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Binds l -> m (Binds l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Binds l -> m (Binds l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Binds l -> m (Binds l))
    -> Data (Binds l)
    Binds l -> Constr
    Binds l -> DataType
    (forall b. Data b => b -> b) -> Binds l -> Binds l
    forall l. Data l => Typeable (Binds l)
    forall l. Data l => Binds l -> Constr
    forall l. Data l => Binds l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Binds l -> Binds l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Binds l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Binds l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Binds l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binds l -> c (Binds l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Binds l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Binds l -> u
    forall u. (forall d. Data d => d -> u) -> Binds l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Binds l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binds l -> c (Binds l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Binds l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binds l -> c (Binds l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Binds l -> c (Binds l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Binds l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Binds l)
    $ctoConstr :: forall l. Data l => Binds l -> Constr
    toConstr :: Binds l -> Constr
    $cdataTypeOf :: forall l. Data l => Binds l -> DataType
    dataTypeOf :: Binds l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Binds l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Binds l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Binds l -> Binds l
    gmapT :: (forall b. Data b => b -> b) -> Binds l -> Binds l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binds l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Binds l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Binds l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Binds l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binds l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binds l -> m (Binds l)
    Data,(forall m. Monoid m => Binds m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Binds a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Binds a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Binds a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Binds a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Binds a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Binds a -> b)
    -> (forall a. (a -> a -> a) -> Binds a -> a)
    -> (forall a. (a -> a -> a) -> Binds a -> a)
    -> (forall a. Binds a -> [a])
    -> (forall a. Binds a -> Bool)
    -> (forall a. Binds a -> Int)
    -> (forall a. Eq a => a -> Binds a -> Bool)
    -> (forall a. Ord a => Binds a -> a)
    -> (forall a. Ord a => Binds a -> a)
    -> (forall a. Num a => Binds a -> a)
    -> (forall a. Num a => Binds a -> a)
    -> Foldable Binds
    forall a. Eq a => a -> Binds a -> Bool
    forall a. Num a => Binds a -> a
    forall a. Ord a => Binds a -> a
    forall m. Monoid m => Binds m -> m
    forall a. Binds a -> Bool
    forall a. Binds a -> Int
    forall a. Binds a -> [a]
    forall a. (a -> a -> a) -> Binds a -> a
    forall m a. Monoid m => (a -> m) -> Binds a -> m
    forall b a. (b -> a -> b) -> b -> Binds a -> b
    forall a b. (a -> b -> b) -> b -> Binds a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Binds m -> m
    fold :: forall m. Monoid m => Binds m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Binds a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Binds a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Binds a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Binds a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Binds a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Binds a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Binds a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Binds a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Binds a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Binds a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Binds a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Binds a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Binds a -> a
    foldr1 :: forall a. (a -> a -> a) -> Binds a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Binds a -> a
    foldl1 :: forall a. (a -> a -> a) -> Binds a -> a
    $ctoList :: forall a. Binds a -> [a]
    toList :: forall a. Binds a -> [a]
    $cnull :: forall a. Binds a -> Bool
    null :: forall a. Binds a -> Bool
    $clength :: forall a. Binds a -> Int
    length :: forall a. Binds a -> Int
    $celem :: forall a. Eq a => a -> Binds a -> Bool
    elem :: forall a. Eq a => a -> Binds a -> Bool
    $cmaximum :: forall a. Ord a => Binds a -> a
    maximum :: forall a. Ord a => Binds a -> a
    $cminimum :: forall a. Ord a => Binds a -> a
    minimum :: forall a. Ord a => Binds a -> a
    $csum :: forall a. Num a => Binds a -> a
    sum :: forall a. Num a => Binds a -> a
    $cproduct :: forall a. Num a => Binds a -> a
    product :: forall a. Num a => Binds a -> a
    Foldable,Functor Binds
    Foldable Binds
    (Functor Binds, Foldable Binds) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Binds a -> f (Binds b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Binds (f a) -> f (Binds a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Binds a -> m (Binds b))
    -> (forall (m :: * -> *) a. Monad m => Binds (m a) -> m (Binds a))
    -> Traversable Binds
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Binds (m a) -> m (Binds a)
    forall (f :: * -> *) a. Applicative f => Binds (f a) -> f (Binds a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Binds a -> m (Binds b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Binds a -> f (Binds b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Binds a -> f (Binds b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Binds a -> f (Binds b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Binds (f a) -> f (Binds a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Binds (f a) -> f (Binds a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Binds a -> m (Binds b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Binds a -> m (Binds b)
    $csequence :: forall (m :: * -> *) a. Monad m => Binds (m a) -> m (Binds a)
    sequence :: forall (m :: * -> *) a. Monad m => Binds (m a) -> m (Binds a)
    Traversable,(forall a b. (a -> b) -> Binds a -> Binds b)
    -> (forall a b. a -> Binds b -> Binds a) -> Functor Binds
    forall a b. a -> Binds b -> Binds a
    forall a b. (a -> b) -> Binds a -> Binds b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Binds a -> Binds b
    fmap :: forall a b. (a -> b) -> Binds a -> Binds b
    $c<$ :: forall a b. a -> Binds b -> Binds a
    <$ :: forall a b. a -> Binds b -> Binds a
    Functor,(forall x. Binds l -> Rep (Binds l) x)
    -> (forall x. Rep (Binds l) x -> Binds l) -> Generic (Binds l)
    forall x. Rep (Binds l) x -> Binds l
    forall x. Binds l -> Rep (Binds l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Binds l) x -> Binds l
    forall l x. Binds l -> Rep (Binds l) x
    $cfrom :: forall l x. Binds l -> Rep (Binds l) x
    from :: forall x. Binds l -> Rep (Binds l) x
    $cto :: forall l x. Rep (Binds l) x -> Binds l
    to :: forall x. Rep (Binds l) x -> Binds l
    Generic)

    -- | A binding of an implicit parameter.
    data IPBind l = IPBind l (IPName l) (Exp l)
      deriving (IPBind l -> IPBind l -> Bool
    (IPBind l -> IPBind l -> Bool)
    -> (IPBind l -> IPBind l -> Bool) -> Eq (IPBind l)
    forall l. Eq l => IPBind l -> IPBind l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => IPBind l -> IPBind l -> Bool
    == :: IPBind l -> IPBind l -> Bool
    $c/= :: forall l. Eq l => IPBind l -> IPBind l -> Bool
    /= :: IPBind l -> IPBind l -> Bool
    Eq,Eq (IPBind l)
    Eq (IPBind l) =>
    (IPBind l -> IPBind l -> Ordering)
    -> (IPBind l -> IPBind l -> Bool)
    -> (IPBind l -> IPBind l -> Bool)
    -> (IPBind l -> IPBind l -> Bool)
    -> (IPBind l -> IPBind l -> Bool)
    -> (IPBind l -> IPBind l -> IPBind l)
    -> (IPBind l -> IPBind l -> IPBind l)
    -> Ord (IPBind l)
    IPBind l -> IPBind l -> Bool
    IPBind l -> IPBind l -> Ordering
    IPBind l -> IPBind l -> IPBind l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (IPBind l)
    forall l. Ord l => IPBind l -> IPBind l -> Bool
    forall l. Ord l => IPBind l -> IPBind l -> Ordering
    forall l. Ord l => IPBind l -> IPBind l -> IPBind l
    $ccompare :: forall l. Ord l => IPBind l -> IPBind l -> Ordering
    compare :: IPBind l -> IPBind l -> Ordering
    $c< :: forall l. Ord l => IPBind l -> IPBind l -> Bool
    < :: IPBind l -> IPBind l -> Bool
    $c<= :: forall l. Ord l => IPBind l -> IPBind l -> Bool
    <= :: IPBind l -> IPBind l -> Bool
    $c> :: forall l. Ord l => IPBind l -> IPBind l -> Bool
    > :: IPBind l -> IPBind l -> Bool
    $c>= :: forall l. Ord l => IPBind l -> IPBind l -> Bool
    >= :: IPBind l -> IPBind l -> Bool
    $cmax :: forall l. Ord l => IPBind l -> IPBind l -> IPBind l
    max :: IPBind l -> IPBind l -> IPBind l
    $cmin :: forall l. Ord l => IPBind l -> IPBind l -> IPBind l
    min :: IPBind l -> IPBind l -> IPBind l
    Ord,Int -> IPBind l -> ShowS
    [IPBind l] -> ShowS
    IPBind l -> String
    (Int -> IPBind l -> ShowS)
    -> (IPBind l -> String) -> ([IPBind l] -> ShowS) -> Show (IPBind l)
    forall l. Show l => Int -> IPBind l -> ShowS
    forall l. Show l => [IPBind l] -> ShowS
    forall l. Show l => IPBind l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> IPBind l -> ShowS
    showsPrec :: Int -> IPBind l -> ShowS
    $cshow :: forall l. Show l => IPBind l -> String
    show :: IPBind l -> String
    $cshowList :: forall l. Show l => [IPBind l] -> ShowS
    showList :: [IPBind l] -> ShowS
    Show,Typeable,Typeable (IPBind l)
    Typeable (IPBind l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> IPBind l -> c (IPBind l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (IPBind l))
    -> (IPBind l -> Constr)
    -> (IPBind l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (IPBind l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (IPBind l)))
    -> ((forall b. Data b => b -> b) -> IPBind l -> IPBind l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> IPBind l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> IPBind l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> IPBind l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> IPBind l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l))
    -> Data (IPBind l)
    IPBind l -> Constr
    IPBind l -> DataType
    (forall b. Data b => b -> b) -> IPBind l -> IPBind l
    forall l. Data l => Typeable (IPBind l)
    forall l. Data l => IPBind l -> Constr
    forall l. Data l => IPBind l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> IPBind l -> IPBind l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> IPBind l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> IPBind l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBind l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPBind l -> c (IPBind l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBind l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> IPBind l -> u
    forall u. (forall d. Data d => d -> u) -> IPBind l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBind l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPBind l -> c (IPBind l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBind l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPBind l -> c (IPBind l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPBind l -> c (IPBind l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBind l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBind l)
    $ctoConstr :: forall l. Data l => IPBind l -> Constr
    toConstr :: IPBind l -> Constr
    $cdataTypeOf :: forall l. Data l => IPBind l -> DataType
    dataTypeOf :: IPBind l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBind l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBind l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> IPBind l -> IPBind l
    gmapT :: (forall b. Data b => b -> b) -> IPBind l -> IPBind l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBind l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> IPBind l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> IPBind l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> IPBind l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPBind l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l)
    Data,(forall m. Monoid m => IPBind m -> m)
    -> (forall m a. Monoid m => (a -> m) -> IPBind a -> m)
    -> (forall m a. Monoid m => (a -> m) -> IPBind a -> m)
    -> (forall a b. (a -> b -> b) -> b -> IPBind a -> b)
    -> (forall a b. (a -> b -> b) -> b -> IPBind a -> b)
    -> (forall b a. (b -> a -> b) -> b -> IPBind a -> b)
    -> (forall b a. (b -> a -> b) -> b -> IPBind a -> b)
    -> (forall a. (a -> a -> a) -> IPBind a -> a)
    -> (forall a. (a -> a -> a) -> IPBind a -> a)
    -> (forall a. IPBind a -> [a])
    -> (forall a. IPBind a -> Bool)
    -> (forall a. IPBind a -> Int)
    -> (forall a. Eq a => a -> IPBind a -> Bool)
    -> (forall a. Ord a => IPBind a -> a)
    -> (forall a. Ord a => IPBind a -> a)
    -> (forall a. Num a => IPBind a -> a)
    -> (forall a. Num a => IPBind a -> a)
    -> Foldable IPBind
    forall a. Eq a => a -> IPBind a -> Bool
    forall a. Num a => IPBind a -> a
    forall a. Ord a => IPBind a -> a
    forall m. Monoid m => IPBind m -> m
    forall a. IPBind a -> Bool
    forall a. IPBind a -> Int
    forall a. IPBind a -> [a]
    forall a. (a -> a -> a) -> IPBind a -> a
    forall m a. Monoid m => (a -> m) -> IPBind a -> m
    forall b a. (b -> a -> b) -> b -> IPBind a -> b
    forall a b. (a -> b -> b) -> b -> IPBind a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => IPBind m -> m
    fold :: forall m. Monoid m => IPBind m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> IPBind a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> IPBind a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> IPBind a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> IPBind a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> IPBind a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> IPBind a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> IPBind a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> IPBind a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> IPBind a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> IPBind a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> IPBind a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> IPBind a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> IPBind a -> a
    foldr1 :: forall a. (a -> a -> a) -> IPBind a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> IPBind a -> a
    foldl1 :: forall a. (a -> a -> a) -> IPBind a -> a
    $ctoList :: forall a. IPBind a -> [a]
    toList :: forall a. IPBind a -> [a]
    $cnull :: forall a. IPBind a -> Bool
    null :: forall a. IPBind a -> Bool
    $clength :: forall a. IPBind a -> Int
    length :: forall a. IPBind a -> Int
    $celem :: forall a. Eq a => a -> IPBind a -> Bool
    elem :: forall a. Eq a => a -> IPBind a -> Bool
    $cmaximum :: forall a. Ord a => IPBind a -> a
    maximum :: forall a. Ord a => IPBind a -> a
    $cminimum :: forall a. Ord a => IPBind a -> a
    minimum :: forall a. Ord a => IPBind a -> a
    $csum :: forall a. Num a => IPBind a -> a
    sum :: forall a. Num a => IPBind a -> a
    $cproduct :: forall a. Num a => IPBind a -> a
    product :: forall a. Num a => IPBind a -> a
    Foldable,Functor IPBind
    Foldable IPBind
    (Functor IPBind, Foldable IPBind) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> IPBind a -> f (IPBind b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        IPBind (f a) -> f (IPBind a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> IPBind a -> m (IPBind b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        IPBind (m a) -> m (IPBind a))
    -> Traversable IPBind
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => IPBind (m a) -> m (IPBind a)
    forall (f :: * -> *) a.
    Applicative f =>
    IPBind (f a) -> f (IPBind a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPBind a -> m (IPBind b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPBind a -> f (IPBind b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPBind a -> f (IPBind b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPBind a -> f (IPBind b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    IPBind (f a) -> f (IPBind a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    IPBind (f a) -> f (IPBind a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPBind a -> m (IPBind b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPBind a -> m (IPBind b)
    $csequence :: forall (m :: * -> *) a. Monad m => IPBind (m a) -> m (IPBind a)
    sequence :: forall (m :: * -> *) a. Monad m => IPBind (m a) -> m (IPBind a)
    Traversable,(forall a b. (a -> b) -> IPBind a -> IPBind b)
    -> (forall a b. a -> IPBind b -> IPBind a) -> Functor IPBind
    forall a b. a -> IPBind b -> IPBind a
    forall a b. (a -> b) -> IPBind a -> IPBind b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> IPBind a -> IPBind b
    fmap :: forall a b. (a -> b) -> IPBind a -> IPBind b
    $c<$ :: forall a b. a -> IPBind b -> IPBind a
    <$ :: forall a b. a -> IPBind b -> IPBind a
    Functor,(forall x. IPBind l -> Rep (IPBind l) x)
    -> (forall x. Rep (IPBind l) x -> IPBind l) -> Generic (IPBind l)
    forall x. Rep (IPBind l) x -> IPBind l
    forall x. IPBind l -> Rep (IPBind l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (IPBind l) x -> IPBind l
    forall l x. IPBind l -> Rep (IPBind l) x
    $cfrom :: forall l x. IPBind l -> Rep (IPBind l) x
    from :: forall x. IPBind l -> Rep (IPBind l) x
    $cto :: forall l x. Rep (IPBind l) x -> IPBind l
    to :: forall x. Rep (IPBind l) x -> IPBind l
    Generic)

    -- | Clauses of a function binding.
    data Match l
         = Match l      (Name l) [Pat l]         (Rhs l) {-where-} (Maybe (Binds l))
            -- ^ A clause defined with prefix notation, i.e. the function name
            --  followed by its argument patterns, the right-hand side and an
            --  optional where clause.
         | InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) {-where-} (Maybe (Binds l))
            -- ^ A clause defined with infix notation, i.e. first its first argument
            --  pattern, then the function name, then its following argument(s),
            --  the right-hand side and an optional where clause.
            --  Note that there can be more than two arguments to a function declared
            --  infix, hence the list of pattern arguments.
      deriving (Match l -> Match l -> Bool
    (Match l -> Match l -> Bool)
    -> (Match l -> Match l -> Bool) -> Eq (Match l)
    forall l. Eq l => Match l -> Match l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Match l -> Match l -> Bool
    == :: Match l -> Match l -> Bool
    $c/= :: forall l. Eq l => Match l -> Match l -> Bool
    /= :: Match l -> Match l -> Bool
    Eq,Eq (Match l)
    Eq (Match l) =>
    (Match l -> Match l -> Ordering)
    -> (Match l -> Match l -> Bool)
    -> (Match l -> Match l -> Bool)
    -> (Match l -> Match l -> Bool)
    -> (Match l -> Match l -> Bool)
    -> (Match l -> Match l -> Match l)
    -> (Match l -> Match l -> Match l)
    -> Ord (Match l)
    Match l -> Match l -> Bool
    Match l -> Match l -> Ordering
    Match l -> Match l -> Match l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Match l)
    forall l. Ord l => Match l -> Match l -> Bool
    forall l. Ord l => Match l -> Match l -> Ordering
    forall l. Ord l => Match l -> Match l -> Match l
    $ccompare :: forall l. Ord l => Match l -> Match l -> Ordering
    compare :: Match l -> Match l -> Ordering
    $c< :: forall l. Ord l => Match l -> Match l -> Bool
    < :: Match l -> Match l -> Bool
    $c<= :: forall l. Ord l => Match l -> Match l -> Bool
    <= :: Match l -> Match l -> Bool
    $c> :: forall l. Ord l => Match l -> Match l -> Bool
    > :: Match l -> Match l -> Bool
    $c>= :: forall l. Ord l => Match l -> Match l -> Bool
    >= :: Match l -> Match l -> Bool
    $cmax :: forall l. Ord l => Match l -> Match l -> Match l
    max :: Match l -> Match l -> Match l
    $cmin :: forall l. Ord l => Match l -> Match l -> Match l
    min :: Match l -> Match l -> Match l
    Ord,Int -> Match l -> ShowS
    [Match l] -> ShowS
    Match l -> String
    (Int -> Match l -> ShowS)
    -> (Match l -> String) -> ([Match l] -> ShowS) -> Show (Match l)
    forall l. Show l => Int -> Match l -> ShowS
    forall l. Show l => [Match l] -> ShowS
    forall l. Show l => Match l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Match l -> ShowS
    showsPrec :: Int -> Match l -> ShowS
    $cshow :: forall l. Show l => Match l -> String
    show :: Match l -> String
    $cshowList :: forall l. Show l => [Match l] -> ShowS
    showList :: [Match l] -> ShowS
    Show,Typeable,Typeable (Match l)
    Typeable (Match l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Match l -> c (Match l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Match l))
    -> (Match l -> Constr)
    -> (Match l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Match l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l)))
    -> ((forall b. Data b => b -> b) -> Match l -> Match l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Match l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Match l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Match l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Match l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Match l -> m (Match l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Match l -> m (Match l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Match l -> m (Match l))
    -> Data (Match l)
    Match l -> Constr
    Match l -> DataType
    (forall b. Data b => b -> b) -> Match l -> Match l
    forall l. Data l => Typeable (Match l)
    forall l. Data l => Match l -> Constr
    forall l. Data l => Match l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Match l -> Match l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Match l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Match l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Match l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Match l -> c (Match l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Match l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Match l -> u
    forall u. (forall d. Data d => d -> u) -> Match l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Match l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Match l -> c (Match l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Match l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Match l -> c (Match l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Match l -> c (Match l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Match l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Match l)
    $ctoConstr :: forall l. Data l => Match l -> Constr
    toConstr :: Match l -> Constr
    $cdataTypeOf :: forall l. Data l => Match l -> DataType
    dataTypeOf :: Match l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Match l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Match l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Match l -> Match l
    gmapT :: (forall b. Data b => b -> b) -> Match l -> Match l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Match l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Match l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Match l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Match l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match l -> m (Match l)
    Data,(forall m. Monoid m => Match m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Match a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Match a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Match a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Match a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Match a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Match a -> b)
    -> (forall a. (a -> a -> a) -> Match a -> a)
    -> (forall a. (a -> a -> a) -> Match a -> a)
    -> (forall a. Match a -> [a])
    -> (forall a. Match a -> Bool)
    -> (forall a. Match a -> Int)
    -> (forall a. Eq a => a -> Match a -> Bool)
    -> (forall a. Ord a => Match a -> a)
    -> (forall a. Ord a => Match a -> a)
    -> (forall a. Num a => Match a -> a)
    -> (forall a. Num a => Match a -> a)
    -> Foldable Match
    forall a. Eq a => a -> Match a -> Bool
    forall a. Num a => Match a -> a
    forall a. Ord a => Match a -> a
    forall m. Monoid m => Match m -> m
    forall a. Match a -> Bool
    forall a. Match a -> Int
    forall a. Match a -> [a]
    forall a. (a -> a -> a) -> Match a -> a
    forall m a. Monoid m => (a -> m) -> Match a -> m
    forall b a. (b -> a -> b) -> b -> Match a -> b
    forall a b. (a -> b -> b) -> b -> Match a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Match m -> m
    fold :: forall m. Monoid m => Match m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Match a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Match a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Match a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Match a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Match a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Match a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Match a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Match a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Match a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Match a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Match a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Match a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Match a -> a
    foldr1 :: forall a. (a -> a -> a) -> Match a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Match a -> a
    foldl1 :: forall a. (a -> a -> a) -> Match a -> a
    $ctoList :: forall a. Match a -> [a]
    toList :: forall a. Match a -> [a]
    $cnull :: forall a. Match a -> Bool
    null :: forall a. Match a -> Bool
    $clength :: forall a. Match a -> Int
    length :: forall a. Match a -> Int
    $celem :: forall a. Eq a => a -> Match a -> Bool
    elem :: forall a. Eq a => a -> Match a -> Bool
    $cmaximum :: forall a. Ord a => Match a -> a
    maximum :: forall a. Ord a => Match a -> a
    $cminimum :: forall a. Ord a => Match a -> a
    minimum :: forall a. Ord a => Match a -> a
    $csum :: forall a. Num a => Match a -> a
    sum :: forall a. Num a => Match a -> a
    $cproduct :: forall a. Num a => Match a -> a
    product :: forall a. Num a => Match a -> a
    Foldable,Functor Match
    Foldable Match
    (Functor Match, Foldable Match) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Match a -> f (Match b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Match (f a) -> f (Match a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Match a -> m (Match b))
    -> (forall (m :: * -> *) a. Monad m => Match (m a) -> m (Match a))
    -> Traversable Match
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Match (m a) -> m (Match a)
    forall (f :: * -> *) a. Applicative f => Match (f a) -> f (Match a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Match a -> m (Match b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Match a -> f (Match b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Match a -> f (Match b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Match a -> f (Match b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Match (f a) -> f (Match a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Match (f a) -> f (Match a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Match a -> m (Match b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Match a -> m (Match b)
    $csequence :: forall (m :: * -> *) a. Monad m => Match (m a) -> m (Match a)
    sequence :: forall (m :: * -> *) a. Monad m => Match (m a) -> m (Match a)
    Traversable,(forall a b. (a -> b) -> Match a -> Match b)
    -> (forall a b. a -> Match b -> Match a) -> Functor Match
    forall a b. a -> Match b -> Match a
    forall a b. (a -> b) -> Match a -> Match b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Match a -> Match b
    fmap :: forall a b. (a -> b) -> Match a -> Match b
    $c<$ :: forall a b. a -> Match b -> Match a
    <$ :: forall a b. a -> Match b -> Match a
    Functor,(forall x. Match l -> Rep (Match l) x)
    -> (forall x. Rep (Match l) x -> Match l) -> Generic (Match l)
    forall x. Rep (Match l) x -> Match l
    forall x. Match l -> Rep (Match l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Match l) x -> Match l
    forall l x. Match l -> Rep (Match l) x
    $cfrom :: forall l x. Match l -> Rep (Match l) x
    from :: forall x. Match l -> Rep (Match l) x
    $cto :: forall l x. Rep (Match l) x -> Match l
    to :: forall x. Rep (Match l) x -> Match l
    Generic)

    -- | A single constructor declaration within a data type declaration,
    --   which may have an existential quantification binding.
    data QualConDecl l
        = QualConDecl l
            {-forall-} (Maybe [TyVarBind l]) {- . -} (Maybe (Context l))
            {- => -} (ConDecl l)
      deriving (QualConDecl l -> QualConDecl l -> Bool
    (QualConDecl l -> QualConDecl l -> Bool)
    -> (QualConDecl l -> QualConDecl l -> Bool) -> Eq (QualConDecl l)
    forall l. Eq l => QualConDecl l -> QualConDecl l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => QualConDecl l -> QualConDecl l -> Bool
    == :: QualConDecl l -> QualConDecl l -> Bool
    $c/= :: forall l. Eq l => QualConDecl l -> QualConDecl l -> Bool
    /= :: QualConDecl l -> QualConDecl l -> Bool
    Eq,Eq (QualConDecl l)
    Eq (QualConDecl l) =>
    (QualConDecl l -> QualConDecl l -> Ordering)
    -> (QualConDecl l -> QualConDecl l -> Bool)
    -> (QualConDecl l -> QualConDecl l -> Bool)
    -> (QualConDecl l -> QualConDecl l -> Bool)
    -> (QualConDecl l -> QualConDecl l -> Bool)
    -> (QualConDecl l -> QualConDecl l -> QualConDecl l)
    -> (QualConDecl l -> QualConDecl l -> QualConDecl l)
    -> Ord (QualConDecl l)
    QualConDecl l -> QualConDecl l -> Bool
    QualConDecl l -> QualConDecl l -> Ordering
    QualConDecl l -> QualConDecl l -> QualConDecl l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (QualConDecl l)
    forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
    forall l. Ord l => QualConDecl l -> QualConDecl l -> Ordering
    forall l. Ord l => QualConDecl l -> QualConDecl l -> QualConDecl l
    $ccompare :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Ordering
    compare :: QualConDecl l -> QualConDecl l -> Ordering
    $c< :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
    < :: QualConDecl l -> QualConDecl l -> Bool
    $c<= :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
    <= :: QualConDecl l -> QualConDecl l -> Bool
    $c> :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
    > :: QualConDecl l -> QualConDecl l -> Bool
    $c>= :: forall l. Ord l => QualConDecl l -> QualConDecl l -> Bool
    >= :: QualConDecl l -> QualConDecl l -> Bool
    $cmax :: forall l. Ord l => QualConDecl l -> QualConDecl l -> QualConDecl l
    max :: QualConDecl l -> QualConDecl l -> QualConDecl l
    $cmin :: forall l. Ord l => QualConDecl l -> QualConDecl l -> QualConDecl l
    min :: QualConDecl l -> QualConDecl l -> QualConDecl l
    Ord,Int -> QualConDecl l -> ShowS
    [QualConDecl l] -> ShowS
    QualConDecl l -> String
    (Int -> QualConDecl l -> ShowS)
    -> (QualConDecl l -> String)
    -> ([QualConDecl l] -> ShowS)
    -> Show (QualConDecl l)
    forall l. Show l => Int -> QualConDecl l -> ShowS
    forall l. Show l => [QualConDecl l] -> ShowS
    forall l. Show l => QualConDecl l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> QualConDecl l -> ShowS
    showsPrec :: Int -> QualConDecl l -> ShowS
    $cshow :: forall l. Show l => QualConDecl l -> String
    show :: QualConDecl l -> String
    $cshowList :: forall l. Show l => [QualConDecl l] -> ShowS
    showList :: [QualConDecl l] -> ShowS
    Show,Typeable,Typeable (QualConDecl l)
    Typeable (QualConDecl l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (QualConDecl l))
    -> (QualConDecl l -> Constr)
    -> (QualConDecl l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (QualConDecl l)))
    -> ((forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> QualConDecl l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> QualConDecl l -> m (QualConDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> QualConDecl l -> m (QualConDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> QualConDecl l -> m (QualConDecl l))
    -> Data (QualConDecl l)
    QualConDecl l -> Constr
    QualConDecl l -> DataType
    (forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l
    forall l. Data l => Typeable (QualConDecl l)
    forall l. Data l => QualConDecl l -> Constr
    forall l. Data l => QualConDecl l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> QualConDecl l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualConDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualConDecl l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u
    forall u. (forall d. Data d => d -> u) -> QualConDecl l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualConDecl l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualConDecl l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualConDecl l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualConDecl l)
    $ctoConstr :: forall l. Data l => QualConDecl l -> Constr
    toConstr :: QualConDecl l -> Constr
    $cdataTypeOf :: forall l. Data l => QualConDecl l -> DataType
    dataTypeOf :: QualConDecl l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualConDecl l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualConDecl l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l
    gmapT :: (forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> QualConDecl l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> QualConDecl l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> QualConDecl l -> m (QualConDecl l)
    Data,(forall m. Monoid m => QualConDecl m -> m)
    -> (forall m a. Monoid m => (a -> m) -> QualConDecl a -> m)
    -> (forall m a. Monoid m => (a -> m) -> QualConDecl a -> m)
    -> (forall a b. (a -> b -> b) -> b -> QualConDecl a -> b)
    -> (forall a b. (a -> b -> b) -> b -> QualConDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> QualConDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> QualConDecl a -> b)
    -> (forall a. (a -> a -> a) -> QualConDecl a -> a)
    -> (forall a. (a -> a -> a) -> QualConDecl a -> a)
    -> (forall a. QualConDecl a -> [a])
    -> (forall a. QualConDecl a -> Bool)
    -> (forall a. QualConDecl a -> Int)
    -> (forall a. Eq a => a -> QualConDecl a -> Bool)
    -> (forall a. Ord a => QualConDecl a -> a)
    -> (forall a. Ord a => QualConDecl a -> a)
    -> (forall a. Num a => QualConDecl a -> a)
    -> (forall a. Num a => QualConDecl a -> a)
    -> Foldable QualConDecl
    forall a. Eq a => a -> QualConDecl a -> Bool
    forall a. Num a => QualConDecl a -> a
    forall a. Ord a => QualConDecl a -> a
    forall m. Monoid m => QualConDecl m -> m
    forall a. QualConDecl a -> Bool
    forall a. QualConDecl a -> Int
    forall a. QualConDecl a -> [a]
    forall a. (a -> a -> a) -> QualConDecl a -> a
    forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
    forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
    forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => QualConDecl m -> m
    fold :: forall m. Monoid m => QualConDecl m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> QualConDecl a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> QualConDecl a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> QualConDecl a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> QualConDecl a -> a
    foldr1 :: forall a. (a -> a -> a) -> QualConDecl a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> QualConDecl a -> a
    foldl1 :: forall a. (a -> a -> a) -> QualConDecl a -> a
    $ctoList :: forall a. QualConDecl a -> [a]
    toList :: forall a. QualConDecl a -> [a]
    $cnull :: forall a. QualConDecl a -> Bool
    null :: forall a. QualConDecl a -> Bool
    $clength :: forall a. QualConDecl a -> Int
    length :: forall a. QualConDecl a -> Int
    $celem :: forall a. Eq a => a -> QualConDecl a -> Bool
    elem :: forall a. Eq a => a -> QualConDecl a -> Bool
    $cmaximum :: forall a. Ord a => QualConDecl a -> a
    maximum :: forall a. Ord a => QualConDecl a -> a
    $cminimum :: forall a. Ord a => QualConDecl a -> a
    minimum :: forall a. Ord a => QualConDecl a -> a
    $csum :: forall a. Num a => QualConDecl a -> a
    sum :: forall a. Num a => QualConDecl a -> a
    $cproduct :: forall a. Num a => QualConDecl a -> a
    product :: forall a. Num a => QualConDecl a -> a
    Foldable,Functor QualConDecl
    Foldable QualConDecl
    (Functor QualConDecl, Foldable QualConDecl) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> QualConDecl a -> f (QualConDecl b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        QualConDecl (f a) -> f (QualConDecl a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> QualConDecl a -> m (QualConDecl b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        QualConDecl (m a) -> m (QualConDecl a))
    -> Traversable QualConDecl
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    QualConDecl (m a) -> m (QualConDecl a)
    forall (f :: * -> *) a.
    Applicative f =>
    QualConDecl (f a) -> f (QualConDecl a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QualConDecl a -> m (QualConDecl b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QualConDecl a -> f (QualConDecl b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QualConDecl a -> f (QualConDecl b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QualConDecl a -> f (QualConDecl b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    QualConDecl (f a) -> f (QualConDecl a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    QualConDecl (f a) -> f (QualConDecl a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QualConDecl a -> m (QualConDecl b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QualConDecl a -> m (QualConDecl b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    QualConDecl (m a) -> m (QualConDecl a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    QualConDecl (m a) -> m (QualConDecl a)
    Traversable,(forall a b. (a -> b) -> QualConDecl a -> QualConDecl b)
    -> (forall a b. a -> QualConDecl b -> QualConDecl a)
    -> Functor QualConDecl
    forall a b. a -> QualConDecl b -> QualConDecl a
    forall a b. (a -> b) -> QualConDecl a -> QualConDecl b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> QualConDecl a -> QualConDecl b
    fmap :: forall a b. (a -> b) -> QualConDecl a -> QualConDecl b
    $c<$ :: forall a b. a -> QualConDecl b -> QualConDecl a
    <$ :: forall a b. a -> QualConDecl b -> QualConDecl a
    Functor,(forall x. QualConDecl l -> Rep (QualConDecl l) x)
    -> (forall x. Rep (QualConDecl l) x -> QualConDecl l)
    -> Generic (QualConDecl l)
    forall x. Rep (QualConDecl l) x -> QualConDecl l
    forall x. QualConDecl l -> Rep (QualConDecl l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (QualConDecl l) x -> QualConDecl l
    forall l x. QualConDecl l -> Rep (QualConDecl l) x
    $cfrom :: forall l x. QualConDecl l -> Rep (QualConDecl l) x
    from :: forall x. QualConDecl l -> Rep (QualConDecl l) x
    $cto :: forall l x. Rep (QualConDecl l) x -> QualConDecl l
    to :: forall x. Rep (QualConDecl l) x -> QualConDecl l
    Generic)

    -- | Declaration of an ordinary data constructor.
    data ConDecl l
         = ConDecl l (Name l) [Type l]
                    -- ^ ordinary data constructor
         | InfixConDecl l (Type l) (Name l) (Type l)
                    -- ^ infix data constructor
         | RecDecl l (Name l) [FieldDecl l]
                    -- ^ record constructor
      deriving (ConDecl l -> ConDecl l -> Bool
    (ConDecl l -> ConDecl l -> Bool)
    -> (ConDecl l -> ConDecl l -> Bool) -> Eq (ConDecl l)
    forall l. Eq l => ConDecl l -> ConDecl l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ConDecl l -> ConDecl l -> Bool
    == :: ConDecl l -> ConDecl l -> Bool
    $c/= :: forall l. Eq l => ConDecl l -> ConDecl l -> Bool
    /= :: ConDecl l -> ConDecl l -> Bool
    Eq,Eq (ConDecl l)
    Eq (ConDecl l) =>
    (ConDecl l -> ConDecl l -> Ordering)
    -> (ConDecl l -> ConDecl l -> Bool)
    -> (ConDecl l -> ConDecl l -> Bool)
    -> (ConDecl l -> ConDecl l -> Bool)
    -> (ConDecl l -> ConDecl l -> Bool)
    -> (ConDecl l -> ConDecl l -> ConDecl l)
    -> (ConDecl l -> ConDecl l -> ConDecl l)
    -> Ord (ConDecl l)
    ConDecl l -> ConDecl l -> Bool
    ConDecl l -> ConDecl l -> Ordering
    ConDecl l -> ConDecl l -> ConDecl l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ConDecl l)
    forall l. Ord l => ConDecl l -> ConDecl l -> Bool
    forall l. Ord l => ConDecl l -> ConDecl l -> Ordering
    forall l. Ord l => ConDecl l -> ConDecl l -> ConDecl l
    $ccompare :: forall l. Ord l => ConDecl l -> ConDecl l -> Ordering
    compare :: ConDecl l -> ConDecl l -> Ordering
    $c< :: forall l. Ord l => ConDecl l -> ConDecl l -> Bool
    < :: ConDecl l -> ConDecl l -> Bool
    $c<= :: forall l. Ord l => ConDecl l -> ConDecl l -> Bool
    <= :: ConDecl l -> ConDecl l -> Bool
    $c> :: forall l. Ord l => ConDecl l -> ConDecl l -> Bool
    > :: ConDecl l -> ConDecl l -> Bool
    $c>= :: forall l. Ord l => ConDecl l -> ConDecl l -> Bool
    >= :: ConDecl l -> ConDecl l -> Bool
    $cmax :: forall l. Ord l => ConDecl l -> ConDecl l -> ConDecl l
    max :: ConDecl l -> ConDecl l -> ConDecl l
    $cmin :: forall l. Ord l => ConDecl l -> ConDecl l -> ConDecl l
    min :: ConDecl l -> ConDecl l -> ConDecl l
    Ord,Int -> ConDecl l -> ShowS
    [ConDecl l] -> ShowS
    ConDecl l -> String
    (Int -> ConDecl l -> ShowS)
    -> (ConDecl l -> String)
    -> ([ConDecl l] -> ShowS)
    -> Show (ConDecl l)
    forall l. Show l => Int -> ConDecl l -> ShowS
    forall l. Show l => [ConDecl l] -> ShowS
    forall l. Show l => ConDecl l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ConDecl l -> ShowS
    showsPrec :: Int -> ConDecl l -> ShowS
    $cshow :: forall l. Show l => ConDecl l -> String
    show :: ConDecl l -> String
    $cshowList :: forall l. Show l => [ConDecl l] -> ShowS
    showList :: [ConDecl l] -> ShowS
    Show,Typeable,Typeable (ConDecl l)
    Typeable (ConDecl l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ConDecl l))
    -> (ConDecl l -> Constr)
    -> (ConDecl l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ConDecl l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ConDecl l)))
    -> ((forall b. Data b => b -> b) -> ConDecl l -> ConDecl l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ConDecl l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ConDecl l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l))
    -> Data (ConDecl l)
    ConDecl l -> Constr
    ConDecl l -> DataType
    (forall b. Data b => b -> b) -> ConDecl l -> ConDecl l
    forall l. Data l => Typeable (ConDecl l)
    forall l. Data l => ConDecl l -> Constr
    forall l. Data l => ConDecl l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ConDecl l -> ConDecl l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ConDecl l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ConDecl l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ConDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ConDecl l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ConDecl l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ConDecl l -> u
    forall u. (forall d. Data d => d -> u) -> ConDecl l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ConDecl l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ConDecl l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ConDecl l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ConDecl l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ConDecl l)
    $ctoConstr :: forall l. Data l => ConDecl l -> Constr
    toConstr :: ConDecl l -> Constr
    $cdataTypeOf :: forall l. Data l => ConDecl l -> DataType
    dataTypeOf :: ConDecl l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ConDecl l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ConDecl l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ConDecl l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ConDecl l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ConDecl l -> ConDecl l
    gmapT :: (forall b. Data b => b -> b) -> ConDecl l -> ConDecl l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ConDecl l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ConDecl l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ConDecl l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConDecl l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l)
    Data,(forall m. Monoid m => ConDecl m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ConDecl a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ConDecl a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ConDecl a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ConDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ConDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ConDecl a -> b)
    -> (forall a. (a -> a -> a) -> ConDecl a -> a)
    -> (forall a. (a -> a -> a) -> ConDecl a -> a)
    -> (forall a. ConDecl a -> [a])
    -> (forall a. ConDecl a -> Bool)
    -> (forall a. ConDecl a -> Int)
    -> (forall a. Eq a => a -> ConDecl a -> Bool)
    -> (forall a. Ord a => ConDecl a -> a)
    -> (forall a. Ord a => ConDecl a -> a)
    -> (forall a. Num a => ConDecl a -> a)
    -> (forall a. Num a => ConDecl a -> a)
    -> Foldable ConDecl
    forall a. Eq a => a -> ConDecl a -> Bool
    forall a. Num a => ConDecl a -> a
    forall a. Ord a => ConDecl a -> a
    forall m. Monoid m => ConDecl m -> m
    forall a. ConDecl a -> Bool
    forall a. ConDecl a -> Int
    forall a. ConDecl a -> [a]
    forall a. (a -> a -> a) -> ConDecl a -> a
    forall m a. Monoid m => (a -> m) -> ConDecl a -> m
    forall b a. (b -> a -> b) -> b -> ConDecl a -> b
    forall a b. (a -> b -> b) -> b -> ConDecl a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ConDecl m -> m
    fold :: forall m. Monoid m => ConDecl m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ConDecl a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ConDecl a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ConDecl a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ConDecl a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ConDecl a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ConDecl a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ConDecl a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ConDecl a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ConDecl a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ConDecl a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ConDecl a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ConDecl a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ConDecl a -> a
    foldr1 :: forall a. (a -> a -> a) -> ConDecl a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ConDecl a -> a
    foldl1 :: forall a. (a -> a -> a) -> ConDecl a -> a
    $ctoList :: forall a. ConDecl a -> [a]
    toList :: forall a. ConDecl a -> [a]
    $cnull :: forall a. ConDecl a -> Bool
    null :: forall a. ConDecl a -> Bool
    $clength :: forall a. ConDecl a -> Int
    length :: forall a. ConDecl a -> Int
    $celem :: forall a. Eq a => a -> ConDecl a -> Bool
    elem :: forall a. Eq a => a -> ConDecl a -> Bool
    $cmaximum :: forall a. Ord a => ConDecl a -> a
    maximum :: forall a. Ord a => ConDecl a -> a
    $cminimum :: forall a. Ord a => ConDecl a -> a
    minimum :: forall a. Ord a => ConDecl a -> a
    $csum :: forall a. Num a => ConDecl a -> a
    sum :: forall a. Num a => ConDecl a -> a
    $cproduct :: forall a. Num a => ConDecl a -> a
    product :: forall a. Num a => ConDecl a -> a
    Foldable,Functor ConDecl
    Foldable ConDecl
    (Functor ConDecl, Foldable ConDecl) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ConDecl a -> f (ConDecl b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ConDecl (f a) -> f (ConDecl a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ConDecl a -> m (ConDecl b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ConDecl (m a) -> m (ConDecl a))
    -> Traversable ConDecl
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => ConDecl (m a) -> m (ConDecl a)
    forall (f :: * -> *) a.
    Applicative f =>
    ConDecl (f a) -> f (ConDecl a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ConDecl a -> m (ConDecl b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ConDecl a -> f (ConDecl b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ConDecl a -> f (ConDecl b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ConDecl a -> f (ConDecl b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ConDecl (f a) -> f (ConDecl a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ConDecl (f a) -> f (ConDecl a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ConDecl a -> m (ConDecl b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ConDecl a -> m (ConDecl b)
    $csequence :: forall (m :: * -> *) a. Monad m => ConDecl (m a) -> m (ConDecl a)
    sequence :: forall (m :: * -> *) a. Monad m => ConDecl (m a) -> m (ConDecl a)
    Traversable,(forall a b. (a -> b) -> ConDecl a -> ConDecl b)
    -> (forall a b. a -> ConDecl b -> ConDecl a) -> Functor ConDecl
    forall a b. a -> ConDecl b -> ConDecl a
    forall a b. (a -> b) -> ConDecl a -> ConDecl b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ConDecl a -> ConDecl b
    fmap :: forall a b. (a -> b) -> ConDecl a -> ConDecl b
    $c<$ :: forall a b. a -> ConDecl b -> ConDecl a
    <$ :: forall a b. a -> ConDecl b -> ConDecl a
    Functor,(forall x. ConDecl l -> Rep (ConDecl l) x)
    -> (forall x. Rep (ConDecl l) x -> ConDecl l)
    -> Generic (ConDecl l)
    forall x. Rep (ConDecl l) x -> ConDecl l
    forall x. ConDecl l -> Rep (ConDecl l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ConDecl l) x -> ConDecl l
    forall l x. ConDecl l -> Rep (ConDecl l) x
    $cfrom :: forall l x. ConDecl l -> Rep (ConDecl l) x
    from :: forall x. ConDecl l -> Rep (ConDecl l) x
    $cto :: forall l x. Rep (ConDecl l) x -> ConDecl l
    to :: forall x. Rep (ConDecl l) x -> ConDecl l
    Generic)

    -- | Declaration of a (list of) named field(s).
    data FieldDecl l = FieldDecl l [Name l] (Type l)
      deriving (FieldDecl l -> FieldDecl l -> Bool
    (FieldDecl l -> FieldDecl l -> Bool)
    -> (FieldDecl l -> FieldDecl l -> Bool) -> Eq (FieldDecl l)
    forall l. Eq l => FieldDecl l -> FieldDecl l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => FieldDecl l -> FieldDecl l -> Bool
    == :: FieldDecl l -> FieldDecl l -> Bool
    $c/= :: forall l. Eq l => FieldDecl l -> FieldDecl l -> Bool
    /= :: FieldDecl l -> FieldDecl l -> Bool
    Eq,Eq (FieldDecl l)
    Eq (FieldDecl l) =>
    (FieldDecl l -> FieldDecl l -> Ordering)
    -> (FieldDecl l -> FieldDecl l -> Bool)
    -> (FieldDecl l -> FieldDecl l -> Bool)
    -> (FieldDecl l -> FieldDecl l -> Bool)
    -> (FieldDecl l -> FieldDecl l -> Bool)
    -> (FieldDecl l -> FieldDecl l -> FieldDecl l)
    -> (FieldDecl l -> FieldDecl l -> FieldDecl l)
    -> Ord (FieldDecl l)
    FieldDecl l -> FieldDecl l -> Bool
    FieldDecl l -> FieldDecl l -> Ordering
    FieldDecl l -> FieldDecl l -> FieldDecl l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (FieldDecl l)
    forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
    forall l. Ord l => FieldDecl l -> FieldDecl l -> Ordering
    forall l. Ord l => FieldDecl l -> FieldDecl l -> FieldDecl l
    $ccompare :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Ordering
    compare :: FieldDecl l -> FieldDecl l -> Ordering
    $c< :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
    < :: FieldDecl l -> FieldDecl l -> Bool
    $c<= :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
    <= :: FieldDecl l -> FieldDecl l -> Bool
    $c> :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
    > :: FieldDecl l -> FieldDecl l -> Bool
    $c>= :: forall l. Ord l => FieldDecl l -> FieldDecl l -> Bool
    >= :: FieldDecl l -> FieldDecl l -> Bool
    $cmax :: forall l. Ord l => FieldDecl l -> FieldDecl l -> FieldDecl l
    max :: FieldDecl l -> FieldDecl l -> FieldDecl l
    $cmin :: forall l. Ord l => FieldDecl l -> FieldDecl l -> FieldDecl l
    min :: FieldDecl l -> FieldDecl l -> FieldDecl l
    Ord,Int -> FieldDecl l -> ShowS
    [FieldDecl l] -> ShowS
    FieldDecl l -> String
    (Int -> FieldDecl l -> ShowS)
    -> (FieldDecl l -> String)
    -> ([FieldDecl l] -> ShowS)
    -> Show (FieldDecl l)
    forall l. Show l => Int -> FieldDecl l -> ShowS
    forall l. Show l => [FieldDecl l] -> ShowS
    forall l. Show l => FieldDecl l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> FieldDecl l -> ShowS
    showsPrec :: Int -> FieldDecl l -> ShowS
    $cshow :: forall l. Show l => FieldDecl l -> String
    show :: FieldDecl l -> String
    $cshowList :: forall l. Show l => [FieldDecl l] -> ShowS
    showList :: [FieldDecl l] -> ShowS
    Show,Typeable,Typeable (FieldDecl l)
    Typeable (FieldDecl l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FieldDecl l))
    -> (FieldDecl l -> Constr)
    -> (FieldDecl l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FieldDecl l)))
    -> ((forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> FieldDecl l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l))
    -> Data (FieldDecl l)
    FieldDecl l -> Constr
    FieldDecl l -> DataType
    (forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l
    forall l. Data l => Typeable (FieldDecl l)
    forall l. Data l => FieldDecl l -> Constr
    forall l. Data l => FieldDecl l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> FieldDecl l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldDecl l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u
    forall u. (forall d. Data d => d -> u) -> FieldDecl l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldDecl l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldDecl l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldDecl l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldDecl l)
    $ctoConstr :: forall l. Data l => FieldDecl l -> Constr
    toConstr :: FieldDecl l -> Constr
    $cdataTypeOf :: forall l. Data l => FieldDecl l -> DataType
    dataTypeOf :: FieldDecl l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldDecl l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldDecl l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l
    gmapT :: (forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> FieldDecl l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FieldDecl l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l)
    Data,(forall m. Monoid m => FieldDecl m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FieldDecl a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FieldDecl a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FieldDecl a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FieldDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FieldDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FieldDecl a -> b)
    -> (forall a. (a -> a -> a) -> FieldDecl a -> a)
    -> (forall a. (a -> a -> a) -> FieldDecl a -> a)
    -> (forall a. FieldDecl a -> [a])
    -> (forall a. FieldDecl a -> Bool)
    -> (forall a. FieldDecl a -> Int)
    -> (forall a. Eq a => a -> FieldDecl a -> Bool)
    -> (forall a. Ord a => FieldDecl a -> a)
    -> (forall a. Ord a => FieldDecl a -> a)
    -> (forall a. Num a => FieldDecl a -> a)
    -> (forall a. Num a => FieldDecl a -> a)
    -> Foldable FieldDecl
    forall a. Eq a => a -> FieldDecl a -> Bool
    forall a. Num a => FieldDecl a -> a
    forall a. Ord a => FieldDecl a -> a
    forall m. Monoid m => FieldDecl m -> m
    forall a. FieldDecl a -> Bool
    forall a. FieldDecl a -> Int
    forall a. FieldDecl a -> [a]
    forall a. (a -> a -> a) -> FieldDecl a -> a
    forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
    forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
    forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => FieldDecl m -> m
    fold :: forall m. Monoid m => FieldDecl m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FieldDecl a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FieldDecl a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FieldDecl a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> FieldDecl a -> a
    foldr1 :: forall a. (a -> a -> a) -> FieldDecl a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> FieldDecl a -> a
    foldl1 :: forall a. (a -> a -> a) -> FieldDecl a -> a
    $ctoList :: forall a. FieldDecl a -> [a]
    toList :: forall a. FieldDecl a -> [a]
    $cnull :: forall a. FieldDecl a -> Bool
    null :: forall a. FieldDecl a -> Bool
    $clength :: forall a. FieldDecl a -> Int
    length :: forall a. FieldDecl a -> Int
    $celem :: forall a. Eq a => a -> FieldDecl a -> Bool
    elem :: forall a. Eq a => a -> FieldDecl a -> Bool
    $cmaximum :: forall a. Ord a => FieldDecl a -> a
    maximum :: forall a. Ord a => FieldDecl a -> a
    $cminimum :: forall a. Ord a => FieldDecl a -> a
    minimum :: forall a. Ord a => FieldDecl a -> a
    $csum :: forall a. Num a => FieldDecl a -> a
    sum :: forall a. Num a => FieldDecl a -> a
    $cproduct :: forall a. Num a => FieldDecl a -> a
    product :: forall a. Num a => FieldDecl a -> a
    Foldable,Functor FieldDecl
    Foldable FieldDecl
    (Functor FieldDecl, Foldable FieldDecl) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FieldDecl a -> f (FieldDecl b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FieldDecl (f a) -> f (FieldDecl a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FieldDecl a -> m (FieldDecl b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FieldDecl (m a) -> m (FieldDecl a))
    -> Traversable FieldDecl
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    FieldDecl (m a) -> m (FieldDecl a)
    forall (f :: * -> *) a.
    Applicative f =>
    FieldDecl (f a) -> f (FieldDecl a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FieldDecl a -> m (FieldDecl b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FieldDecl a -> f (FieldDecl b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FieldDecl a -> f (FieldDecl b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FieldDecl a -> f (FieldDecl b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FieldDecl (f a) -> f (FieldDecl a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FieldDecl (f a) -> f (FieldDecl a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FieldDecl a -> m (FieldDecl b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FieldDecl a -> m (FieldDecl b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    FieldDecl (m a) -> m (FieldDecl a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    FieldDecl (m a) -> m (FieldDecl a)
    Traversable,(forall a b. (a -> b) -> FieldDecl a -> FieldDecl b)
    -> (forall a b. a -> FieldDecl b -> FieldDecl a)
    -> Functor FieldDecl
    forall a b. a -> FieldDecl b -> FieldDecl a
    forall a b. (a -> b) -> FieldDecl a -> FieldDecl b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> FieldDecl a -> FieldDecl b
    fmap :: forall a b. (a -> b) -> FieldDecl a -> FieldDecl b
    $c<$ :: forall a b. a -> FieldDecl b -> FieldDecl a
    <$ :: forall a b. a -> FieldDecl b -> FieldDecl a
    Functor,(forall x. FieldDecl l -> Rep (FieldDecl l) x)
    -> (forall x. Rep (FieldDecl l) x -> FieldDecl l)
    -> Generic (FieldDecl l)
    forall x. Rep (FieldDecl l) x -> FieldDecl l
    forall x. FieldDecl l -> Rep (FieldDecl l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (FieldDecl l) x -> FieldDecl l
    forall l x. FieldDecl l -> Rep (FieldDecl l) x
    $cfrom :: forall l x. FieldDecl l -> Rep (FieldDecl l) x
    from :: forall x. FieldDecl l -> Rep (FieldDecl l) x
    $cto :: forall l x. Rep (FieldDecl l) x -> FieldDecl l
    to :: forall x. Rep (FieldDecl l) x -> FieldDecl l
    Generic)

    -- | A single constructor declaration in a GADT data type declaration.
    --
    -- If the GADT is declared using the record syntax, e.g.
    --
    -- >data Ty where
    -- >  TCon :: { field1 :: Int, field2 :: Bool } -> Ty
    --
    -- then the fields are stored as a list of 'FieldDecl's, and the final type
    -- (@Ty@ in the above example) is stored in the last 'Type' field.
    --
    -- If the GADT is declared using the ordinary syntax, e.g.
    --
    -- >data Ty where
    -- >  TCon :: Int -> Bool -> Ty
    --
    -- then @'Maybe' ['FieldDecl' l]@ is 'Nothing', and the whole constructor's
    -- type (such as @Int -> Bool -> Ty@) is stored in the last 'Type' field.
    data GadtDecl l
        = GadtDecl l (Name l)
            {-forall-} (Maybe [TyVarBind l]) {- . -} (Maybe (Context l))
            {- => -} (Maybe [FieldDecl l]) (Type l)
      deriving (GadtDecl l -> GadtDecl l -> Bool
    (GadtDecl l -> GadtDecl l -> Bool)
    -> (GadtDecl l -> GadtDecl l -> Bool) -> Eq (GadtDecl l)
    forall l. Eq l => GadtDecl l -> GadtDecl l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => GadtDecl l -> GadtDecl l -> Bool
    == :: GadtDecl l -> GadtDecl l -> Bool
    $c/= :: forall l. Eq l => GadtDecl l -> GadtDecl l -> Bool
    /= :: GadtDecl l -> GadtDecl l -> Bool
    Eq,Eq (GadtDecl l)
    Eq (GadtDecl l) =>
    (GadtDecl l -> GadtDecl l -> Ordering)
    -> (GadtDecl l -> GadtDecl l -> Bool)
    -> (GadtDecl l -> GadtDecl l -> Bool)
    -> (GadtDecl l -> GadtDecl l -> Bool)
    -> (GadtDecl l -> GadtDecl l -> Bool)
    -> (GadtDecl l -> GadtDecl l -> GadtDecl l)
    -> (GadtDecl l -> GadtDecl l -> GadtDecl l)
    -> Ord (GadtDecl l)
    GadtDecl l -> GadtDecl l -> Bool
    GadtDecl l -> GadtDecl l -> Ordering
    GadtDecl l -> GadtDecl l -> GadtDecl l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (GadtDecl l)
    forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
    forall l. Ord l => GadtDecl l -> GadtDecl l -> Ordering
    forall l. Ord l => GadtDecl l -> GadtDecl l -> GadtDecl l
    $ccompare :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Ordering
    compare :: GadtDecl l -> GadtDecl l -> Ordering
    $c< :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
    < :: GadtDecl l -> GadtDecl l -> Bool
    $c<= :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
    <= :: GadtDecl l -> GadtDecl l -> Bool
    $c> :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
    > :: GadtDecl l -> GadtDecl l -> Bool
    $c>= :: forall l. Ord l => GadtDecl l -> GadtDecl l -> Bool
    >= :: GadtDecl l -> GadtDecl l -> Bool
    $cmax :: forall l. Ord l => GadtDecl l -> GadtDecl l -> GadtDecl l
    max :: GadtDecl l -> GadtDecl l -> GadtDecl l
    $cmin :: forall l. Ord l => GadtDecl l -> GadtDecl l -> GadtDecl l
    min :: GadtDecl l -> GadtDecl l -> GadtDecl l
    Ord,Int -> GadtDecl l -> ShowS
    [GadtDecl l] -> ShowS
    GadtDecl l -> String
    (Int -> GadtDecl l -> ShowS)
    -> (GadtDecl l -> String)
    -> ([GadtDecl l] -> ShowS)
    -> Show (GadtDecl l)
    forall l. Show l => Int -> GadtDecl l -> ShowS
    forall l. Show l => [GadtDecl l] -> ShowS
    forall l. Show l => GadtDecl l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> GadtDecl l -> ShowS
    showsPrec :: Int -> GadtDecl l -> ShowS
    $cshow :: forall l. Show l => GadtDecl l -> String
    show :: GadtDecl l -> String
    $cshowList :: forall l. Show l => [GadtDecl l] -> ShowS
    showList :: [GadtDecl l] -> ShowS
    Show,Typeable,Typeable (GadtDecl l)
    Typeable (GadtDecl l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (GadtDecl l))
    -> (GadtDecl l -> Constr)
    -> (GadtDecl l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (GadtDecl l)))
    -> ((forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> GadtDecl l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l))
    -> Data (GadtDecl l)
    GadtDecl l -> Constr
    GadtDecl l -> DataType
    (forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l
    forall l. Data l => Typeable (GadtDecl l)
    forall l. Data l => GadtDecl l -> Constr
    forall l. Data l => GadtDecl l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> GadtDecl l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GadtDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GadtDecl l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u
    forall u. (forall d. Data d => d -> u) -> GadtDecl l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GadtDecl l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GadtDecl l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GadtDecl l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GadtDecl l)
    $ctoConstr :: forall l. Data l => GadtDecl l -> Constr
    toConstr :: GadtDecl l -> Constr
    $cdataTypeOf :: forall l. Data l => GadtDecl l -> DataType
    dataTypeOf :: GadtDecl l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GadtDecl l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GadtDecl l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l
    gmapT :: (forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> GadtDecl l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> GadtDecl l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l)
    Data,(forall m. Monoid m => GadtDecl m -> m)
    -> (forall m a. Monoid m => (a -> m) -> GadtDecl a -> m)
    -> (forall m a. Monoid m => (a -> m) -> GadtDecl a -> m)
    -> (forall a b. (a -> b -> b) -> b -> GadtDecl a -> b)
    -> (forall a b. (a -> b -> b) -> b -> GadtDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> GadtDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> GadtDecl a -> b)
    -> (forall a. (a -> a -> a) -> GadtDecl a -> a)
    -> (forall a. (a -> a -> a) -> GadtDecl a -> a)
    -> (forall a. GadtDecl a -> [a])
    -> (forall a. GadtDecl a -> Bool)
    -> (forall a. GadtDecl a -> Int)
    -> (forall a. Eq a => a -> GadtDecl a -> Bool)
    -> (forall a. Ord a => GadtDecl a -> a)
    -> (forall a. Ord a => GadtDecl a -> a)
    -> (forall a. Num a => GadtDecl a -> a)
    -> (forall a. Num a => GadtDecl a -> a)
    -> Foldable GadtDecl
    forall a. Eq a => a -> GadtDecl a -> Bool
    forall a. Num a => GadtDecl a -> a
    forall a. Ord a => GadtDecl a -> a
    forall m. Monoid m => GadtDecl m -> m
    forall a. GadtDecl a -> Bool
    forall a. GadtDecl a -> Int
    forall a. GadtDecl a -> [a]
    forall a. (a -> a -> a) -> GadtDecl a -> a
    forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
    forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
    forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => GadtDecl m -> m
    fold :: forall m. Monoid m => GadtDecl m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> GadtDecl a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> GadtDecl a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> GadtDecl a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> GadtDecl a -> a
    foldr1 :: forall a. (a -> a -> a) -> GadtDecl a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> GadtDecl a -> a
    foldl1 :: forall a. (a -> a -> a) -> GadtDecl a -> a
    $ctoList :: forall a. GadtDecl a -> [a]
    toList :: forall a. GadtDecl a -> [a]
    $cnull :: forall a. GadtDecl a -> Bool
    null :: forall a. GadtDecl a -> Bool
    $clength :: forall a. GadtDecl a -> Int
    length :: forall a. GadtDecl a -> Int
    $celem :: forall a. Eq a => a -> GadtDecl a -> Bool
    elem :: forall a. Eq a => a -> GadtDecl a -> Bool
    $cmaximum :: forall a. Ord a => GadtDecl a -> a
    maximum :: forall a. Ord a => GadtDecl a -> a
    $cminimum :: forall a. Ord a => GadtDecl a -> a
    minimum :: forall a. Ord a => GadtDecl a -> a
    $csum :: forall a. Num a => GadtDecl a -> a
    sum :: forall a. Num a => GadtDecl a -> a
    $cproduct :: forall a. Num a => GadtDecl a -> a
    product :: forall a. Num a => GadtDecl a -> a
    Foldable,Functor GadtDecl
    Foldable GadtDecl
    (Functor GadtDecl, Foldable GadtDecl) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> GadtDecl a -> f (GadtDecl b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        GadtDecl (f a) -> f (GadtDecl a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> GadtDecl a -> m (GadtDecl b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        GadtDecl (m a) -> m (GadtDecl a))
    -> Traversable GadtDecl
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => GadtDecl (m a) -> m (GadtDecl a)
    forall (f :: * -> *) a.
    Applicative f =>
    GadtDecl (f a) -> f (GadtDecl a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GadtDecl a -> m (GadtDecl b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GadtDecl a -> f (GadtDecl b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GadtDecl a -> f (GadtDecl b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GadtDecl a -> f (GadtDecl b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    GadtDecl (f a) -> f (GadtDecl a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    GadtDecl (f a) -> f (GadtDecl a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GadtDecl a -> m (GadtDecl b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GadtDecl a -> m (GadtDecl b)
    $csequence :: forall (m :: * -> *) a. Monad m => GadtDecl (m a) -> m (GadtDecl a)
    sequence :: forall (m :: * -> *) a. Monad m => GadtDecl (m a) -> m (GadtDecl a)
    Traversable,(forall a b. (a -> b) -> GadtDecl a -> GadtDecl b)
    -> (forall a b. a -> GadtDecl b -> GadtDecl a) -> Functor GadtDecl
    forall a b. a -> GadtDecl b -> GadtDecl a
    forall a b. (a -> b) -> GadtDecl a -> GadtDecl b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> GadtDecl a -> GadtDecl b
    fmap :: forall a b. (a -> b) -> GadtDecl a -> GadtDecl b
    $c<$ :: forall a b. a -> GadtDecl b -> GadtDecl a
    <$ :: forall a b. a -> GadtDecl b -> GadtDecl a
    Functor,(forall x. GadtDecl l -> Rep (GadtDecl l) x)
    -> (forall x. Rep (GadtDecl l) x -> GadtDecl l)
    -> Generic (GadtDecl l)
    forall x. Rep (GadtDecl l) x -> GadtDecl l
    forall x. GadtDecl l -> Rep (GadtDecl l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (GadtDecl l) x -> GadtDecl l
    forall l x. GadtDecl l -> Rep (GadtDecl l) x
    $cfrom :: forall l x. GadtDecl l -> Rep (GadtDecl l) x
    from :: forall x. GadtDecl l -> Rep (GadtDecl l) x
    $cto :: forall l x. Rep (GadtDecl l) x -> GadtDecl l
    to :: forall x. Rep (GadtDecl l) x -> GadtDecl l
    Generic)

    -- | Declarations inside a class declaration.
    data ClassDecl l
        = ClsDecl    l (Decl l)
                -- ^ ordinary declaration
        | ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))
                -- ^ declaration of an associated data type
        | ClsTyFam   l                     (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))
                -- ^ declaration of an associated type synonym
        | ClsTyDef   l (TypeEqn l)
                -- ^ default choice for an associated type synonym
        | ClsDefSig  l (Name l) (Type l)
                -- ^ default signature
      deriving (ClassDecl l -> ClassDecl l -> Bool
    (ClassDecl l -> ClassDecl l -> Bool)
    -> (ClassDecl l -> ClassDecl l -> Bool) -> Eq (ClassDecl l)
    forall l. Eq l => ClassDecl l -> ClassDecl l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ClassDecl l -> ClassDecl l -> Bool
    == :: ClassDecl l -> ClassDecl l -> Bool
    $c/= :: forall l. Eq l => ClassDecl l -> ClassDecl l -> Bool
    /= :: ClassDecl l -> ClassDecl l -> Bool
    Eq,Eq (ClassDecl l)
    Eq (ClassDecl l) =>
    (ClassDecl l -> ClassDecl l -> Ordering)
    -> (ClassDecl l -> ClassDecl l -> Bool)
    -> (ClassDecl l -> ClassDecl l -> Bool)
    -> (ClassDecl l -> ClassDecl l -> Bool)
    -> (ClassDecl l -> ClassDecl l -> Bool)
    -> (ClassDecl l -> ClassDecl l -> ClassDecl l)
    -> (ClassDecl l -> ClassDecl l -> ClassDecl l)
    -> Ord (ClassDecl l)
    ClassDecl l -> ClassDecl l -> Bool
    ClassDecl l -> ClassDecl l -> Ordering
    ClassDecl l -> ClassDecl l -> ClassDecl l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ClassDecl l)
    forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
    forall l. Ord l => ClassDecl l -> ClassDecl l -> Ordering
    forall l. Ord l => ClassDecl l -> ClassDecl l -> ClassDecl l
    $ccompare :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Ordering
    compare :: ClassDecl l -> ClassDecl l -> Ordering
    $c< :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
    < :: ClassDecl l -> ClassDecl l -> Bool
    $c<= :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
    <= :: ClassDecl l -> ClassDecl l -> Bool
    $c> :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
    > :: ClassDecl l -> ClassDecl l -> Bool
    $c>= :: forall l. Ord l => ClassDecl l -> ClassDecl l -> Bool
    >= :: ClassDecl l -> ClassDecl l -> Bool
    $cmax :: forall l. Ord l => ClassDecl l -> ClassDecl l -> ClassDecl l
    max :: ClassDecl l -> ClassDecl l -> ClassDecl l
    $cmin :: forall l. Ord l => ClassDecl l -> ClassDecl l -> ClassDecl l
    min :: ClassDecl l -> ClassDecl l -> ClassDecl l
    Ord,Int -> ClassDecl l -> ShowS
    [ClassDecl l] -> ShowS
    ClassDecl l -> String
    (Int -> ClassDecl l -> ShowS)
    -> (ClassDecl l -> String)
    -> ([ClassDecl l] -> ShowS)
    -> Show (ClassDecl l)
    forall l. Show l => Int -> ClassDecl l -> ShowS
    forall l. Show l => [ClassDecl l] -> ShowS
    forall l. Show l => ClassDecl l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ClassDecl l -> ShowS
    showsPrec :: Int -> ClassDecl l -> ShowS
    $cshow :: forall l. Show l => ClassDecl l -> String
    show :: ClassDecl l -> String
    $cshowList :: forall l. Show l => [ClassDecl l] -> ShowS
    showList :: [ClassDecl l] -> ShowS
    Show,Typeable,Typeable (ClassDecl l)
    Typeable (ClassDecl l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ClassDecl l))
    -> (ClassDecl l -> Constr)
    -> (ClassDecl l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ClassDecl l)))
    -> ((forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ClassDecl l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l))
    -> Data (ClassDecl l)
    ClassDecl l -> Constr
    ClassDecl l -> DataType
    (forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l
    forall l. Data l => Typeable (ClassDecl l)
    forall l. Data l => ClassDecl l -> Constr
    forall l. Data l => ClassDecl l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ClassDecl l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ClassDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ClassDecl l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u
    forall u. (forall d. Data d => d -> u) -> ClassDecl l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ClassDecl l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ClassDecl l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ClassDecl l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ClassDecl l)
    $ctoConstr :: forall l. Data l => ClassDecl l -> Constr
    toConstr :: ClassDecl l -> Constr
    $cdataTypeOf :: forall l. Data l => ClassDecl l -> DataType
    dataTypeOf :: ClassDecl l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ClassDecl l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ClassDecl l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l
    gmapT :: (forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ClassDecl l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ClassDecl l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l)
    Data,(forall m. Monoid m => ClassDecl m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ClassDecl a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ClassDecl a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ClassDecl a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ClassDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ClassDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ClassDecl a -> b)
    -> (forall a. (a -> a -> a) -> ClassDecl a -> a)
    -> (forall a. (a -> a -> a) -> ClassDecl a -> a)
    -> (forall a. ClassDecl a -> [a])
    -> (forall a. ClassDecl a -> Bool)
    -> (forall a. ClassDecl a -> Int)
    -> (forall a. Eq a => a -> ClassDecl a -> Bool)
    -> (forall a. Ord a => ClassDecl a -> a)
    -> (forall a. Ord a => ClassDecl a -> a)
    -> (forall a. Num a => ClassDecl a -> a)
    -> (forall a. Num a => ClassDecl a -> a)
    -> Foldable ClassDecl
    forall a. Eq a => a -> ClassDecl a -> Bool
    forall a. Num a => ClassDecl a -> a
    forall a. Ord a => ClassDecl a -> a
    forall m. Monoid m => ClassDecl m -> m
    forall a. ClassDecl a -> Bool
    forall a. ClassDecl a -> Int
    forall a. ClassDecl a -> [a]
    forall a. (a -> a -> a) -> ClassDecl a -> a
    forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
    forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
    forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ClassDecl m -> m
    fold :: forall m. Monoid m => ClassDecl m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ClassDecl a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ClassDecl a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ClassDecl a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ClassDecl a -> a
    foldr1 :: forall a. (a -> a -> a) -> ClassDecl a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ClassDecl a -> a
    foldl1 :: forall a. (a -> a -> a) -> ClassDecl a -> a
    $ctoList :: forall a. ClassDecl a -> [a]
    toList :: forall a. ClassDecl a -> [a]
    $cnull :: forall a. ClassDecl a -> Bool
    null :: forall a. ClassDecl a -> Bool
    $clength :: forall a. ClassDecl a -> Int
    length :: forall a. ClassDecl a -> Int
    $celem :: forall a. Eq a => a -> ClassDecl a -> Bool
    elem :: forall a. Eq a => a -> ClassDecl a -> Bool
    $cmaximum :: forall a. Ord a => ClassDecl a -> a
    maximum :: forall a. Ord a => ClassDecl a -> a
    $cminimum :: forall a. Ord a => ClassDecl a -> a
    minimum :: forall a. Ord a => ClassDecl a -> a
    $csum :: forall a. Num a => ClassDecl a -> a
    sum :: forall a. Num a => ClassDecl a -> a
    $cproduct :: forall a. Num a => ClassDecl a -> a
    product :: forall a. Num a => ClassDecl a -> a
    Foldable,Functor ClassDecl
    Foldable ClassDecl
    (Functor ClassDecl, Foldable ClassDecl) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ClassDecl a -> f (ClassDecl b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ClassDecl (f a) -> f (ClassDecl a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ClassDecl a -> m (ClassDecl b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ClassDecl (m a) -> m (ClassDecl a))
    -> Traversable ClassDecl
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ClassDecl (m a) -> m (ClassDecl a)
    forall (f :: * -> *) a.
    Applicative f =>
    ClassDecl (f a) -> f (ClassDecl a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ClassDecl a -> m (ClassDecl b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ClassDecl a -> f (ClassDecl b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ClassDecl a -> f (ClassDecl b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ClassDecl a -> f (ClassDecl b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ClassDecl (f a) -> f (ClassDecl a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ClassDecl (f a) -> f (ClassDecl a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ClassDecl a -> m (ClassDecl b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ClassDecl a -> m (ClassDecl b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ClassDecl (m a) -> m (ClassDecl a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ClassDecl (m a) -> m (ClassDecl a)
    Traversable,(forall a b. (a -> b) -> ClassDecl a -> ClassDecl b)
    -> (forall a b. a -> ClassDecl b -> ClassDecl a)
    -> Functor ClassDecl
    forall a b. a -> ClassDecl b -> ClassDecl a
    forall a b. (a -> b) -> ClassDecl a -> ClassDecl b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ClassDecl a -> ClassDecl b
    fmap :: forall a b. (a -> b) -> ClassDecl a -> ClassDecl b
    $c<$ :: forall a b. a -> ClassDecl b -> ClassDecl a
    <$ :: forall a b. a -> ClassDecl b -> ClassDecl a
    Functor,(forall x. ClassDecl l -> Rep (ClassDecl l) x)
    -> (forall x. Rep (ClassDecl l) x -> ClassDecl l)
    -> Generic (ClassDecl l)
    forall x. Rep (ClassDecl l) x -> ClassDecl l
    forall x. ClassDecl l -> Rep (ClassDecl l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ClassDecl l) x -> ClassDecl l
    forall l x. ClassDecl l -> Rep (ClassDecl l) x
    $cfrom :: forall l x. ClassDecl l -> Rep (ClassDecl l) x
    from :: forall x. ClassDecl l -> Rep (ClassDecl l) x
    $cto :: forall l x. Rep (ClassDecl l) x -> ClassDecl l
    to :: forall x. Rep (ClassDecl l) x -> ClassDecl l
    Generic)

    -- | Declarations inside an instance declaration.
    data InstDecl l
        = InsDecl   l (Decl l)
                -- ^ ordinary declaration
        | InsType   l (Type l) (Type l)
                -- ^ an associated type definition
        | InsData   l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]
                -- ^ an associated data type implementation
        | InsGData  l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]
                -- ^ an associated data type implemented using GADT style
      deriving (InstDecl l -> InstDecl l -> Bool
    (InstDecl l -> InstDecl l -> Bool)
    -> (InstDecl l -> InstDecl l -> Bool) -> Eq (InstDecl l)
    forall l. Eq l => InstDecl l -> InstDecl l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => InstDecl l -> InstDecl l -> Bool
    == :: InstDecl l -> InstDecl l -> Bool
    $c/= :: forall l. Eq l => InstDecl l -> InstDecl l -> Bool
    /= :: InstDecl l -> InstDecl l -> Bool
    Eq,Eq (InstDecl l)
    Eq (InstDecl l) =>
    (InstDecl l -> InstDecl l -> Ordering)
    -> (InstDecl l -> InstDecl l -> Bool)
    -> (InstDecl l -> InstDecl l -> Bool)
    -> (InstDecl l -> InstDecl l -> Bool)
    -> (InstDecl l -> InstDecl l -> Bool)
    -> (InstDecl l -> InstDecl l -> InstDecl l)
    -> (InstDecl l -> InstDecl l -> InstDecl l)
    -> Ord (InstDecl l)
    InstDecl l -> InstDecl l -> Bool
    InstDecl l -> InstDecl l -> Ordering
    InstDecl l -> InstDecl l -> InstDecl l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (InstDecl l)
    forall l. Ord l => InstDecl l -> InstDecl l -> Bool
    forall l. Ord l => InstDecl l -> InstDecl l -> Ordering
    forall l. Ord l => InstDecl l -> InstDecl l -> InstDecl l
    $ccompare :: forall l. Ord l => InstDecl l -> InstDecl l -> Ordering
    compare :: InstDecl l -> InstDecl l -> Ordering
    $c< :: forall l. Ord l => InstDecl l -> InstDecl l -> Bool
    < :: InstDecl l -> InstDecl l -> Bool
    $c<= :: forall l. Ord l => InstDecl l -> InstDecl l -> Bool
    <= :: InstDecl l -> InstDecl l -> Bool
    $c> :: forall l. Ord l => InstDecl l -> InstDecl l -> Bool
    > :: InstDecl l -> InstDecl l -> Bool
    $c>= :: forall l. Ord l => InstDecl l -> InstDecl l -> Bool
    >= :: InstDecl l -> InstDecl l -> Bool
    $cmax :: forall l. Ord l => InstDecl l -> InstDecl l -> InstDecl l
    max :: InstDecl l -> InstDecl l -> InstDecl l
    $cmin :: forall l. Ord l => InstDecl l -> InstDecl l -> InstDecl l
    min :: InstDecl l -> InstDecl l -> InstDecl l
    Ord,Int -> InstDecl l -> ShowS
    [InstDecl l] -> ShowS
    InstDecl l -> String
    (Int -> InstDecl l -> ShowS)
    -> (InstDecl l -> String)
    -> ([InstDecl l] -> ShowS)
    -> Show (InstDecl l)
    forall l. Show l => Int -> InstDecl l -> ShowS
    forall l. Show l => [InstDecl l] -> ShowS
    forall l. Show l => InstDecl l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> InstDecl l -> ShowS
    showsPrec :: Int -> InstDecl l -> ShowS
    $cshow :: forall l. Show l => InstDecl l -> String
    show :: InstDecl l -> String
    $cshowList :: forall l. Show l => [InstDecl l] -> ShowS
    showList :: [InstDecl l] -> ShowS
    Show,Typeable,Typeable (InstDecl l)
    Typeable (InstDecl l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (InstDecl l))
    -> (InstDecl l -> Constr)
    -> (InstDecl l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (InstDecl l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (InstDecl l)))
    -> ((forall b. Data b => b -> b) -> InstDecl l -> InstDecl l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> InstDecl l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> InstDecl l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l))
    -> Data (InstDecl l)
    InstDecl l -> Constr
    InstDecl l -> DataType
    (forall b. Data b => b -> b) -> InstDecl l -> InstDecl l
    forall l. Data l => Typeable (InstDecl l)
    forall l. Data l => InstDecl l -> Constr
    forall l. Data l => InstDecl l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> InstDecl l -> InstDecl l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> InstDecl l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> InstDecl l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstDecl l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstDecl l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstDecl l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> InstDecl l -> u
    forall u. (forall d. Data d => d -> u) -> InstDecl l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstDecl l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstDecl l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstDecl l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstDecl l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InstDecl l)
    $ctoConstr :: forall l. Data l => InstDecl l -> Constr
    toConstr :: InstDecl l -> Constr
    $cdataTypeOf :: forall l. Data l => InstDecl l -> DataType
    dataTypeOf :: InstDecl l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstDecl l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InstDecl l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstDecl l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InstDecl l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> InstDecl l -> InstDecl l
    gmapT :: (forall b. Data b => b -> b) -> InstDecl l -> InstDecl l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> InstDecl l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> InstDecl l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> InstDecl l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InstDecl l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l)
    Data,(forall m. Monoid m => InstDecl m -> m)
    -> (forall m a. Monoid m => (a -> m) -> InstDecl a -> m)
    -> (forall m a. Monoid m => (a -> m) -> InstDecl a -> m)
    -> (forall a b. (a -> b -> b) -> b -> InstDecl a -> b)
    -> (forall a b. (a -> b -> b) -> b -> InstDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> InstDecl a -> b)
    -> (forall b a. (b -> a -> b) -> b -> InstDecl a -> b)
    -> (forall a. (a -> a -> a) -> InstDecl a -> a)
    -> (forall a. (a -> a -> a) -> InstDecl a -> a)
    -> (forall a. InstDecl a -> [a])
    -> (forall a. InstDecl a -> Bool)
    -> (forall a. InstDecl a -> Int)
    -> (forall a. Eq a => a -> InstDecl a -> Bool)
    -> (forall a. Ord a => InstDecl a -> a)
    -> (forall a. Ord a => InstDecl a -> a)
    -> (forall a. Num a => InstDecl a -> a)
    -> (forall a. Num a => InstDecl a -> a)
    -> Foldable InstDecl
    forall a. Eq a => a -> InstDecl a -> Bool
    forall a. Num a => InstDecl a -> a
    forall a. Ord a => InstDecl a -> a
    forall m. Monoid m => InstDecl m -> m
    forall a. InstDecl a -> Bool
    forall a. InstDecl a -> Int
    forall a. InstDecl a -> [a]
    forall a. (a -> a -> a) -> InstDecl a -> a
    forall m a. Monoid m => (a -> m) -> InstDecl a -> m
    forall b a. (b -> a -> b) -> b -> InstDecl a -> b
    forall a b. (a -> b -> b) -> b -> InstDecl a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => InstDecl m -> m
    fold :: forall m. Monoid m => InstDecl m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> InstDecl a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> InstDecl a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> InstDecl a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> InstDecl a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> InstDecl a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> InstDecl a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> InstDecl a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> InstDecl a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> InstDecl a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> InstDecl a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> InstDecl a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> InstDecl a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> InstDecl a -> a
    foldr1 :: forall a. (a -> a -> a) -> InstDecl a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> InstDecl a -> a
    foldl1 :: forall a. (a -> a -> a) -> InstDecl a -> a
    $ctoList :: forall a. InstDecl a -> [a]
    toList :: forall a. InstDecl a -> [a]
    $cnull :: forall a. InstDecl a -> Bool
    null :: forall a. InstDecl a -> Bool
    $clength :: forall a. InstDecl a -> Int
    length :: forall a. InstDecl a -> Int
    $celem :: forall a. Eq a => a -> InstDecl a -> Bool
    elem :: forall a. Eq a => a -> InstDecl a -> Bool
    $cmaximum :: forall a. Ord a => InstDecl a -> a
    maximum :: forall a. Ord a => InstDecl a -> a
    $cminimum :: forall a. Ord a => InstDecl a -> a
    minimum :: forall a. Ord a => InstDecl a -> a
    $csum :: forall a. Num a => InstDecl a -> a
    sum :: forall a. Num a => InstDecl a -> a
    $cproduct :: forall a. Num a => InstDecl a -> a
    product :: forall a. Num a => InstDecl a -> a
    Foldable,Functor InstDecl
    Foldable InstDecl
    (Functor InstDecl, Foldable InstDecl) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> InstDecl a -> f (InstDecl b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        InstDecl (f a) -> f (InstDecl a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> InstDecl a -> m (InstDecl b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        InstDecl (m a) -> m (InstDecl a))
    -> Traversable InstDecl
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => InstDecl (m a) -> m (InstDecl a)
    forall (f :: * -> *) a.
    Applicative f =>
    InstDecl (f a) -> f (InstDecl a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstDecl a -> m (InstDecl b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstDecl a -> f (InstDecl b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstDecl a -> f (InstDecl b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> InstDecl a -> f (InstDecl b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    InstDecl (f a) -> f (InstDecl a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    InstDecl (f a) -> f (InstDecl a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstDecl a -> m (InstDecl b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InstDecl a -> m (InstDecl b)
    $csequence :: forall (m :: * -> *) a. Monad m => InstDecl (m a) -> m (InstDecl a)
    sequence :: forall (m :: * -> *) a. Monad m => InstDecl (m a) -> m (InstDecl a)
    Traversable,(forall a b. (a -> b) -> InstDecl a -> InstDecl b)
    -> (forall a b. a -> InstDecl b -> InstDecl a) -> Functor InstDecl
    forall a b. a -> InstDecl b -> InstDecl a
    forall a b. (a -> b) -> InstDecl a -> InstDecl b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> InstDecl a -> InstDecl b
    fmap :: forall a b. (a -> b) -> InstDecl a -> InstDecl b
    $c<$ :: forall a b. a -> InstDecl b -> InstDecl a
    <$ :: forall a b. a -> InstDecl b -> InstDecl a
    Functor,(forall x. InstDecl l -> Rep (InstDecl l) x)
    -> (forall x. Rep (InstDecl l) x -> InstDecl l)
    -> Generic (InstDecl l)
    forall x. Rep (InstDecl l) x -> InstDecl l
    forall x. InstDecl l -> Rep (InstDecl l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (InstDecl l) x -> InstDecl l
    forall l x. InstDecl l -> Rep (InstDecl l) x
    $cfrom :: forall l x. InstDecl l -> Rep (InstDecl l) x
    from :: forall x. InstDecl l -> Rep (InstDecl l) x
    $cto :: forall l x. Rep (InstDecl l) x -> InstDecl l
    to :: forall x. Rep (InstDecl l) x -> InstDecl l
    Generic)

    -- | The type of a constructor argument or field, optionally including
    --   a strictness annotation.
    data BangType l
         = BangedTy   l -- ^ strict component, marked with \"@!@\"
         | LazyTy     l -- ^ lazy component, marked with \"@~@\"
         | NoStrictAnnot l -- ^ No strictness information
      deriving (BangType l -> BangType l -> Bool
    (BangType l -> BangType l -> Bool)
    -> (BangType l -> BangType l -> Bool) -> Eq (BangType l)
    forall l. Eq l => BangType l -> BangType l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => BangType l -> BangType l -> Bool
    == :: BangType l -> BangType l -> Bool
    $c/= :: forall l. Eq l => BangType l -> BangType l -> Bool
    /= :: BangType l -> BangType l -> Bool
    Eq,Eq (BangType l)
    Eq (BangType l) =>
    (BangType l -> BangType l -> Ordering)
    -> (BangType l -> BangType l -> Bool)
    -> (BangType l -> BangType l -> Bool)
    -> (BangType l -> BangType l -> Bool)
    -> (BangType l -> BangType l -> Bool)
    -> (BangType l -> BangType l -> BangType l)
    -> (BangType l -> BangType l -> BangType l)
    -> Ord (BangType l)
    BangType l -> BangType l -> Bool
    BangType l -> BangType l -> Ordering
    BangType l -> BangType l -> BangType l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (BangType l)
    forall l. Ord l => BangType l -> BangType l -> Bool
    forall l. Ord l => BangType l -> BangType l -> Ordering
    forall l. Ord l => BangType l -> BangType l -> BangType l
    $ccompare :: forall l. Ord l => BangType l -> BangType l -> Ordering
    compare :: BangType l -> BangType l -> Ordering
    $c< :: forall l. Ord l => BangType l -> BangType l -> Bool
    < :: BangType l -> BangType l -> Bool
    $c<= :: forall l. Ord l => BangType l -> BangType l -> Bool
    <= :: BangType l -> BangType l -> Bool
    $c> :: forall l. Ord l => BangType l -> BangType l -> Bool
    > :: BangType l -> BangType l -> Bool
    $c>= :: forall l. Ord l => BangType l -> BangType l -> Bool
    >= :: BangType l -> BangType l -> Bool
    $cmax :: forall l. Ord l => BangType l -> BangType l -> BangType l
    max :: BangType l -> BangType l -> BangType l
    $cmin :: forall l. Ord l => BangType l -> BangType l -> BangType l
    min :: BangType l -> BangType l -> BangType l
    Ord,Int -> BangType l -> ShowS
    [BangType l] -> ShowS
    BangType l -> String
    (Int -> BangType l -> ShowS)
    -> (BangType l -> String)
    -> ([BangType l] -> ShowS)
    -> Show (BangType l)
    forall l. Show l => Int -> BangType l -> ShowS
    forall l. Show l => [BangType l] -> ShowS
    forall l. Show l => BangType l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> BangType l -> ShowS
    showsPrec :: Int -> BangType l -> ShowS
    $cshow :: forall l. Show l => BangType l -> String
    show :: BangType l -> String
    $cshowList :: forall l. Show l => [BangType l] -> ShowS
    showList :: [BangType l] -> ShowS
    Show,Typeable,Typeable (BangType l)
    Typeable (BangType l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> BangType l -> c (BangType l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (BangType l))
    -> (BangType l -> Constr)
    -> (BangType l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (BangType l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (BangType l)))
    -> ((forall b. Data b => b -> b) -> BangType l -> BangType l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> BangType l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> BangType l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> BangType l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> BangType l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> BangType l -> m (BangType l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BangType l -> m (BangType l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BangType l -> m (BangType l))
    -> Data (BangType l)
    BangType l -> Constr
    BangType l -> DataType
    (forall b. Data b => b -> b) -> BangType l -> BangType l
    forall l. Data l => Typeable (BangType l)
    forall l. Data l => BangType l -> Constr
    forall l. Data l => BangType l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> BangType l -> BangType l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> BangType l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> BangType l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BangType l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BangType l -> c (BangType l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (BangType l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BangType l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> BangType l -> u
    forall u. (forall d. Data d => d -> u) -> BangType l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BangType l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BangType l -> c (BangType l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BangType l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BangType l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BangType l -> c (BangType l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BangType l -> c (BangType l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BangType l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BangType l)
    $ctoConstr :: forall l. Data l => BangType l -> Constr
    toConstr :: BangType l -> Constr
    $cdataTypeOf :: forall l. Data l => BangType l -> DataType
    dataTypeOf :: BangType l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (BangType l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BangType l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BangType l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BangType l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> BangType l -> BangType l
    gmapT :: (forall b. Data b => b -> b) -> BangType l -> BangType l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BangType l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> BangType l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> BangType l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> BangType l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BangType l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BangType l -> m (BangType l)
    Data,(forall m. Monoid m => BangType m -> m)
    -> (forall m a. Monoid m => (a -> m) -> BangType a -> m)
    -> (forall m a. Monoid m => (a -> m) -> BangType a -> m)
    -> (forall a b. (a -> b -> b) -> b -> BangType a -> b)
    -> (forall a b. (a -> b -> b) -> b -> BangType a -> b)
    -> (forall b a. (b -> a -> b) -> b -> BangType a -> b)
    -> (forall b a. (b -> a -> b) -> b -> BangType a -> b)
    -> (forall a. (a -> a -> a) -> BangType a -> a)
    -> (forall a. (a -> a -> a) -> BangType a -> a)
    -> (forall a. BangType a -> [a])
    -> (forall a. BangType a -> Bool)
    -> (forall a. BangType a -> Int)
    -> (forall a. Eq a => a -> BangType a -> Bool)
    -> (forall a. Ord a => BangType a -> a)
    -> (forall a. Ord a => BangType a -> a)
    -> (forall a. Num a => BangType a -> a)
    -> (forall a. Num a => BangType a -> a)
    -> Foldable BangType
    forall a. Eq a => a -> BangType a -> Bool
    forall a. Num a => BangType a -> a
    forall a. Ord a => BangType a -> a
    forall m. Monoid m => BangType m -> m
    forall a. BangType a -> Bool
    forall a. BangType a -> Int
    forall a. BangType a -> [a]
    forall a. (a -> a -> a) -> BangType a -> a
    forall m a. Monoid m => (a -> m) -> BangType a -> m
    forall b a. (b -> a -> b) -> b -> BangType a -> b
    forall a b. (a -> b -> b) -> b -> BangType a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => BangType m -> m
    fold :: forall m. Monoid m => BangType m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> BangType a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> BangType a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> BangType a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> BangType a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> BangType a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> BangType a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> BangType a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> BangType a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> BangType a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> BangType a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> BangType a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> BangType a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> BangType a -> a
    foldr1 :: forall a. (a -> a -> a) -> BangType a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> BangType a -> a
    foldl1 :: forall a. (a -> a -> a) -> BangType a -> a
    $ctoList :: forall a. BangType a -> [a]
    toList :: forall a. BangType a -> [a]
    $cnull :: forall a. BangType a -> Bool
    null :: forall a. BangType a -> Bool
    $clength :: forall a. BangType a -> Int
    length :: forall a. BangType a -> Int
    $celem :: forall a. Eq a => a -> BangType a -> Bool
    elem :: forall a. Eq a => a -> BangType a -> Bool
    $cmaximum :: forall a. Ord a => BangType a -> a
    maximum :: forall a. Ord a => BangType a -> a
    $cminimum :: forall a. Ord a => BangType a -> a
    minimum :: forall a. Ord a => BangType a -> a
    $csum :: forall a. Num a => BangType a -> a
    sum :: forall a. Num a => BangType a -> a
    $cproduct :: forall a. Num a => BangType a -> a
    product :: forall a. Num a => BangType a -> a
    Foldable,Functor BangType
    Foldable BangType
    (Functor BangType, Foldable BangType) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> BangType a -> f (BangType b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        BangType (f a) -> f (BangType a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> BangType a -> m (BangType b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        BangType (m a) -> m (BangType a))
    -> Traversable BangType
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => BangType (m a) -> m (BangType a)
    forall (f :: * -> *) a.
    Applicative f =>
    BangType (f a) -> f (BangType a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BangType a -> m (BangType b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> BangType a -> f (BangType b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> BangType a -> f (BangType b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> BangType a -> f (BangType b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    BangType (f a) -> f (BangType a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    BangType (f a) -> f (BangType a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BangType a -> m (BangType b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BangType a -> m (BangType b)
    $csequence :: forall (m :: * -> *) a. Monad m => BangType (m a) -> m (BangType a)
    sequence :: forall (m :: * -> *) a. Monad m => BangType (m a) -> m (BangType a)
    Traversable,(forall a b. (a -> b) -> BangType a -> BangType b)
    -> (forall a b. a -> BangType b -> BangType a) -> Functor BangType
    forall a b. a -> BangType b -> BangType a
    forall a b. (a -> b) -> BangType a -> BangType b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> BangType a -> BangType b
    fmap :: forall a b. (a -> b) -> BangType a -> BangType b
    $c<$ :: forall a b. a -> BangType b -> BangType a
    <$ :: forall a b. a -> BangType b -> BangType a
    Functor,(forall x. BangType l -> Rep (BangType l) x)
    -> (forall x. Rep (BangType l) x -> BangType l)
    -> Generic (BangType l)
    forall x. Rep (BangType l) x -> BangType l
    forall x. BangType l -> Rep (BangType l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (BangType l) x -> BangType l
    forall l x. BangType l -> Rep (BangType l) x
    $cfrom :: forall l x. BangType l -> Rep (BangType l) x
    from :: forall x. BangType l -> Rep (BangType l) x
    $cto :: forall l x. Rep (BangType l) x -> BangType l
    to :: forall x. Rep (BangType l) x -> BangType l
    Generic)

    data Unpackedness l
        = Unpack l -- ^ \"@{-\# UNPACK \#-}@\"
        | NoUnpack l -- ^ \"@{-\# NOUNPACK \#-}@\"
        | NoUnpackPragma l -- ^ No unpack pragma
      deriving (Unpackedness l -> Unpackedness l -> Bool
    (Unpackedness l -> Unpackedness l -> Bool)
    -> (Unpackedness l -> Unpackedness l -> Bool)
    -> Eq (Unpackedness l)
    forall l. Eq l => Unpackedness l -> Unpackedness l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Unpackedness l -> Unpackedness l -> Bool
    == :: Unpackedness l -> Unpackedness l -> Bool
    $c/= :: forall l. Eq l => Unpackedness l -> Unpackedness l -> Bool
    /= :: Unpackedness l -> Unpackedness l -> Bool
    Eq,Eq (Unpackedness l)
    Eq (Unpackedness l) =>
    (Unpackedness l -> Unpackedness l -> Ordering)
    -> (Unpackedness l -> Unpackedness l -> Bool)
    -> (Unpackedness l -> Unpackedness l -> Bool)
    -> (Unpackedness l -> Unpackedness l -> Bool)
    -> (Unpackedness l -> Unpackedness l -> Bool)
    -> (Unpackedness l -> Unpackedness l -> Unpackedness l)
    -> (Unpackedness l -> Unpackedness l -> Unpackedness l)
    -> Ord (Unpackedness l)
    Unpackedness l -> Unpackedness l -> Bool
    Unpackedness l -> Unpackedness l -> Ordering
    Unpackedness l -> Unpackedness l -> Unpackedness l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Unpackedness l)
    forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
    forall l. Ord l => Unpackedness l -> Unpackedness l -> Ordering
    forall l.
    Ord l =>
    Unpackedness l -> Unpackedness l -> Unpackedness l
    $ccompare :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Ordering
    compare :: Unpackedness l -> Unpackedness l -> Ordering
    $c< :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
    < :: Unpackedness l -> Unpackedness l -> Bool
    $c<= :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
    <= :: Unpackedness l -> Unpackedness l -> Bool
    $c> :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
    > :: Unpackedness l -> Unpackedness l -> Bool
    $c>= :: forall l. Ord l => Unpackedness l -> Unpackedness l -> Bool
    >= :: Unpackedness l -> Unpackedness l -> Bool
    $cmax :: forall l.
    Ord l =>
    Unpackedness l -> Unpackedness l -> Unpackedness l
    max :: Unpackedness l -> Unpackedness l -> Unpackedness l
    $cmin :: forall l.
    Ord l =>
    Unpackedness l -> Unpackedness l -> Unpackedness l
    min :: Unpackedness l -> Unpackedness l -> Unpackedness l
    Ord,Int -> Unpackedness l -> ShowS
    [Unpackedness l] -> ShowS
    Unpackedness l -> String
    (Int -> Unpackedness l -> ShowS)
    -> (Unpackedness l -> String)
    -> ([Unpackedness l] -> ShowS)
    -> Show (Unpackedness l)
    forall l. Show l => Int -> Unpackedness l -> ShowS
    forall l. Show l => [Unpackedness l] -> ShowS
    forall l. Show l => Unpackedness l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Unpackedness l -> ShowS
    showsPrec :: Int -> Unpackedness l -> ShowS
    $cshow :: forall l. Show l => Unpackedness l -> String
    show :: Unpackedness l -> String
    $cshowList :: forall l. Show l => [Unpackedness l] -> ShowS
    showList :: [Unpackedness l] -> ShowS
    Show,Typeable,Typeable (Unpackedness l)
    Typeable (Unpackedness l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Unpackedness l))
    -> (Unpackedness l -> Constr)
    -> (Unpackedness l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Unpackedness l)))
    -> ((forall b. Data b => b -> b)
        -> Unpackedness l -> Unpackedness l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> Unpackedness l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> Unpackedness l -> m (Unpackedness l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> Unpackedness l -> m (Unpackedness l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> Unpackedness l -> m (Unpackedness l))
    -> Data (Unpackedness l)
    Unpackedness l -> Constr
    Unpackedness l -> DataType
    (forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l
    forall l. Data l => Typeable (Unpackedness l)
    forall l. Data l => Unpackedness l -> Constr
    forall l. Data l => Unpackedness l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Unpackedness l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Unpackedness l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Unpackedness l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u
    forall u. (forall d. Data d => d -> u) -> Unpackedness l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Unpackedness l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Unpackedness l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Unpackedness l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Unpackedness l)
    $ctoConstr :: forall l. Data l => Unpackedness l -> Constr
    toConstr :: Unpackedness l -> Constr
    $cdataTypeOf :: forall l. Data l => Unpackedness l -> DataType
    dataTypeOf :: Unpackedness l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Unpackedness l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Unpackedness l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l
    gmapT :: (forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Unpackedness l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Unpackedness l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Unpackedness l -> m (Unpackedness l)
    Data,(forall m. Monoid m => Unpackedness m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Unpackedness a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Unpackedness a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Unpackedness a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Unpackedness a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Unpackedness a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Unpackedness a -> b)
    -> (forall a. (a -> a -> a) -> Unpackedness a -> a)
    -> (forall a. (a -> a -> a) -> Unpackedness a -> a)
    -> (forall a. Unpackedness a -> [a])
    -> (forall a. Unpackedness a -> Bool)
    -> (forall a. Unpackedness a -> Int)
    -> (forall a. Eq a => a -> Unpackedness a -> Bool)
    -> (forall a. Ord a => Unpackedness a -> a)
    -> (forall a. Ord a => Unpackedness a -> a)
    -> (forall a. Num a => Unpackedness a -> a)
    -> (forall a. Num a => Unpackedness a -> a)
    -> Foldable Unpackedness
    forall a. Eq a => a -> Unpackedness a -> Bool
    forall a. Num a => Unpackedness a -> a
    forall a. Ord a => Unpackedness a -> a
    forall m. Monoid m => Unpackedness m -> m
    forall a. Unpackedness a -> Bool
    forall a. Unpackedness a -> Int
    forall a. Unpackedness a -> [a]
    forall a. (a -> a -> a) -> Unpackedness a -> a
    forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
    forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
    forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Unpackedness m -> m
    fold :: forall m. Monoid m => Unpackedness m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Unpackedness a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Unpackedness a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Unpackedness a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Unpackedness a -> a
    foldr1 :: forall a. (a -> a -> a) -> Unpackedness a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Unpackedness a -> a
    foldl1 :: forall a. (a -> a -> a) -> Unpackedness a -> a
    $ctoList :: forall a. Unpackedness a -> [a]
    toList :: forall a. Unpackedness a -> [a]
    $cnull :: forall a. Unpackedness a -> Bool
    null :: forall a. Unpackedness a -> Bool
    $clength :: forall a. Unpackedness a -> Int
    length :: forall a. Unpackedness a -> Int
    $celem :: forall a. Eq a => a -> Unpackedness a -> Bool
    elem :: forall a. Eq a => a -> Unpackedness a -> Bool
    $cmaximum :: forall a. Ord a => Unpackedness a -> a
    maximum :: forall a. Ord a => Unpackedness a -> a
    $cminimum :: forall a. Ord a => Unpackedness a -> a
    minimum :: forall a. Ord a => Unpackedness a -> a
    $csum :: forall a. Num a => Unpackedness a -> a
    sum :: forall a. Num a => Unpackedness a -> a
    $cproduct :: forall a. Num a => Unpackedness a -> a
    product :: forall a. Num a => Unpackedness a -> a
    Foldable,Functor Unpackedness
    Foldable Unpackedness
    (Functor Unpackedness, Foldable Unpackedness) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Unpackedness a -> f (Unpackedness b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Unpackedness (f a) -> f (Unpackedness a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Unpackedness a -> m (Unpackedness b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Unpackedness (m a) -> m (Unpackedness a))
    -> Traversable Unpackedness
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    Unpackedness (m a) -> m (Unpackedness a)
    forall (f :: * -> *) a.
    Applicative f =>
    Unpackedness (f a) -> f (Unpackedness a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Unpackedness a -> m (Unpackedness b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Unpackedness a -> f (Unpackedness b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Unpackedness a -> f (Unpackedness b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Unpackedness a -> f (Unpackedness b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Unpackedness (f a) -> f (Unpackedness a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Unpackedness (f a) -> f (Unpackedness a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Unpackedness a -> m (Unpackedness b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Unpackedness a -> m (Unpackedness b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    Unpackedness (m a) -> m (Unpackedness a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Unpackedness (m a) -> m (Unpackedness a)
    Traversable,(forall a b. (a -> b) -> Unpackedness a -> Unpackedness b)
    -> (forall a b. a -> Unpackedness b -> Unpackedness a)
    -> Functor Unpackedness
    forall a b. a -> Unpackedness b -> Unpackedness a
    forall a b. (a -> b) -> Unpackedness a -> Unpackedness b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Unpackedness a -> Unpackedness b
    fmap :: forall a b. (a -> b) -> Unpackedness a -> Unpackedness b
    $c<$ :: forall a b. a -> Unpackedness b -> Unpackedness a
    <$ :: forall a b. a -> Unpackedness b -> Unpackedness a
    Functor,(forall x. Unpackedness l -> Rep (Unpackedness l) x)
    -> (forall x. Rep (Unpackedness l) x -> Unpackedness l)
    -> Generic (Unpackedness l)
    forall x. Rep (Unpackedness l) x -> Unpackedness l
    forall x. Unpackedness l -> Rep (Unpackedness l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Unpackedness l) x -> Unpackedness l
    forall l x. Unpackedness l -> Rep (Unpackedness l) x
    $cfrom :: forall l x. Unpackedness l -> Rep (Unpackedness l) x
    from :: forall x. Unpackedness l -> Rep (Unpackedness l) x
    $cto :: forall l x. Rep (Unpackedness l) x -> Unpackedness l
    to :: forall x. Rep (Unpackedness l) x -> Unpackedness l
    Generic)

    -- | The right hand side of a function binding, pattern binding, or a case
    --   alternative.
    data Rhs l
         = UnGuardedRhs l (Exp l) -- ^ unguarded right hand side (/exp/)
         | GuardedRhss  l [GuardedRhs l]
                    -- ^ guarded right hand side (/gdrhs/)
      deriving (Rhs l -> Rhs l -> Bool
    (Rhs l -> Rhs l -> Bool) -> (Rhs l -> Rhs l -> Bool) -> Eq (Rhs l)
    forall l. Eq l => Rhs l -> Rhs l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Rhs l -> Rhs l -> Bool
    == :: Rhs l -> Rhs l -> Bool
    $c/= :: forall l. Eq l => Rhs l -> Rhs l -> Bool
    /= :: Rhs l -> Rhs l -> Bool
    Eq,Eq (Rhs l)
    Eq (Rhs l) =>
    (Rhs l -> Rhs l -> Ordering)
    -> (Rhs l -> Rhs l -> Bool)
    -> (Rhs l -> Rhs l -> Bool)
    -> (Rhs l -> Rhs l -> Bool)
    -> (Rhs l -> Rhs l -> Bool)
    -> (Rhs l -> Rhs l -> Rhs l)
    -> (Rhs l -> Rhs l -> Rhs l)
    -> Ord (Rhs l)
    Rhs l -> Rhs l -> Bool
    Rhs l -> Rhs l -> Ordering
    Rhs l -> Rhs l -> Rhs l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Rhs l)
    forall l. Ord l => Rhs l -> Rhs l -> Bool
    forall l. Ord l => Rhs l -> Rhs l -> Ordering
    forall l. Ord l => Rhs l -> Rhs l -> Rhs l
    $ccompare :: forall l. Ord l => Rhs l -> Rhs l -> Ordering
    compare :: Rhs l -> Rhs l -> Ordering
    $c< :: forall l. Ord l => Rhs l -> Rhs l -> Bool
    < :: Rhs l -> Rhs l -> Bool
    $c<= :: forall l. Ord l => Rhs l -> Rhs l -> Bool
    <= :: Rhs l -> Rhs l -> Bool
    $c> :: forall l. Ord l => Rhs l -> Rhs l -> Bool
    > :: Rhs l -> Rhs l -> Bool
    $c>= :: forall l. Ord l => Rhs l -> Rhs l -> Bool
    >= :: Rhs l -> Rhs l -> Bool
    $cmax :: forall l. Ord l => Rhs l -> Rhs l -> Rhs l
    max :: Rhs l -> Rhs l -> Rhs l
    $cmin :: forall l. Ord l => Rhs l -> Rhs l -> Rhs l
    min :: Rhs l -> Rhs l -> Rhs l
    Ord,Int -> Rhs l -> ShowS
    [Rhs l] -> ShowS
    Rhs l -> String
    (Int -> Rhs l -> ShowS)
    -> (Rhs l -> String) -> ([Rhs l] -> ShowS) -> Show (Rhs l)
    forall l. Show l => Int -> Rhs l -> ShowS
    forall l. Show l => [Rhs l] -> ShowS
    forall l. Show l => Rhs l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Rhs l -> ShowS
    showsPrec :: Int -> Rhs l -> ShowS
    $cshow :: forall l. Show l => Rhs l -> String
    show :: Rhs l -> String
    $cshowList :: forall l. Show l => [Rhs l] -> ShowS
    showList :: [Rhs l] -> ShowS
    Show,Typeable,Typeable (Rhs l)
    Typeable (Rhs l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Rhs l -> c (Rhs l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Rhs l))
    -> (Rhs l -> Constr)
    -> (Rhs l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Rhs l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l)))
    -> ((forall b. Data b => b -> b) -> Rhs l -> Rhs l)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Rhs l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Rhs l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l))
    -> Data (Rhs l)
    Rhs l -> Constr
    Rhs l -> DataType
    (forall b. Data b => b -> b) -> Rhs l -> Rhs l
    forall l. Data l => Typeable (Rhs l)
    forall l. Data l => Rhs l -> Constr
    forall l. Data l => Rhs l -> DataType
    forall l. Data l => (forall b. Data b => b -> b) -> Rhs l -> Rhs l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Rhs l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Rhs l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rhs l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rhs l -> c (Rhs l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rhs l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Rhs l -> u
    forall u. (forall d. Data d => d -> u) -> Rhs l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rhs l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rhs l -> c (Rhs l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rhs l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rhs l -> c (Rhs l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rhs l -> c (Rhs l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rhs l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rhs l)
    $ctoConstr :: forall l. Data l => Rhs l -> Constr
    toConstr :: Rhs l -> Constr
    $cdataTypeOf :: forall l. Data l => Rhs l -> DataType
    dataTypeOf :: Rhs l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rhs l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rhs l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l))
    $cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Rhs l -> Rhs l
    gmapT :: (forall b. Data b => b -> b) -> Rhs l -> Rhs l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Rhs l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Rhs l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Rhs l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rhs l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l)
    Data,(forall m. Monoid m => Rhs m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Rhs a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Rhs a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Rhs a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Rhs a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Rhs a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Rhs a -> b)
    -> (forall a. (a -> a -> a) -> Rhs a -> a)
    -> (forall a. (a -> a -> a) -> Rhs a -> a)
    -> (forall a. Rhs a -> [a])
    -> (forall a. Rhs a -> Bool)
    -> (forall a. Rhs a -> Int)
    -> (forall a. Eq a => a -> Rhs a -> Bool)
    -> (forall a. Ord a => Rhs a -> a)
    -> (forall a. Ord a => Rhs a -> a)
    -> (forall a. Num a => Rhs a -> a)
    -> (forall a. Num a => Rhs a -> a)
    -> Foldable Rhs
    forall a. Eq a => a -> Rhs a -> Bool
    forall a. Num a => Rhs a -> a
    forall a. Ord a => Rhs a -> a
    forall m. Monoid m => Rhs m -> m
    forall a. Rhs a -> Bool
    forall a. Rhs a -> Int
    forall a. Rhs a -> [a]
    forall a. (a -> a -> a) -> Rhs a -> a
    forall m a. Monoid m => (a -> m) -> Rhs a -> m
    forall b a. (b -> a -> b) -> b -> Rhs a -> b
    forall a b. (a -> b -> b) -> b -> Rhs a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Rhs m -> m
    fold :: forall m. Monoid m => Rhs m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Rhs a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Rhs a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Rhs a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Rhs a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Rhs a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Rhs a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Rhs a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Rhs a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Rhs a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Rhs a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Rhs a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Rhs a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Rhs a -> a
    foldr1 :: forall a. (a -> a -> a) -> Rhs a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Rhs a -> a
    foldl1 :: forall a. (a -> a -> a) -> Rhs a -> a
    $ctoList :: forall a. Rhs a -> [a]
    toList :: forall a. Rhs a -> [a]
    $cnull :: forall a. Rhs a -> Bool
    null :: forall a. Rhs a -> Bool
    $clength :: forall a. Rhs a -> Int
    length :: forall a. Rhs a -> Int
    $celem :: forall a. Eq a => a -> Rhs a -> Bool
    elem :: forall a. Eq a => a -> Rhs a -> Bool
    $cmaximum :: forall a. Ord a => Rhs a -> a
    maximum :: forall a. Ord a => Rhs a -> a
    $cminimum :: forall a. Ord a => Rhs a -> a
    minimum :: forall a. Ord a => Rhs a -> a
    $csum :: forall a. Num a => Rhs a -> a
    sum :: forall a. Num a => Rhs a -> a
    $cproduct :: forall a. Num a => Rhs a -> a
    product :: forall a. Num a => Rhs a -> a
    Foldable,Functor Rhs
    Foldable Rhs
    (Functor Rhs, Foldable Rhs) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Rhs a -> f (Rhs b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Rhs (f a) -> f (Rhs a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Rhs a -> m (Rhs b))
    -> (forall (m :: * -> *) a. Monad m => Rhs (m a) -> m (Rhs a))
    -> Traversable Rhs
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Rhs (m a) -> m (Rhs a)
    forall (f :: * -> *) a. Applicative f => Rhs (f a) -> f (Rhs a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Rhs a -> m (Rhs b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Rhs a -> f (Rhs b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Rhs a -> f (Rhs b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Rhs a -> f (Rhs b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Rhs (f a) -> f (Rhs a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Rhs (f a) -> f (Rhs a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Rhs a -> m (Rhs b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Rhs a -> m (Rhs b)
    $csequence :: forall (m :: * -> *) a. Monad m => Rhs (m a) -> m (Rhs a)
    sequence :: forall (m :: * -> *) a. Monad m => Rhs (m a) -> m (Rhs a)
    Traversable,(forall a b. (a -> b) -> Rhs a -> Rhs b)
    -> (forall a b. a -> Rhs b -> Rhs a) -> Functor Rhs
    forall a b. a -> Rhs b -> Rhs a
    forall a b. (a -> b) -> Rhs a -> Rhs b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Rhs a -> Rhs b
    fmap :: forall a b. (a -> b) -> Rhs a -> Rhs b
    $c<$ :: forall a b. a -> Rhs b -> Rhs a
    <$ :: forall a b. a -> Rhs b -> Rhs a
    Functor,(forall x. Rhs l -> Rep (Rhs l) x)
    -> (forall x. Rep (Rhs l) x -> Rhs l) -> Generic (Rhs l)
    forall x. Rep (Rhs l) x -> Rhs l
    forall x. Rhs l -> Rep (Rhs l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Rhs l) x -> Rhs l
    forall l x. Rhs l -> Rep (Rhs l) x
    $cfrom :: forall l x. Rhs l -> Rep (Rhs l) x
    from :: forall x. Rhs l -> Rep (Rhs l) x
    $cto :: forall l x. Rep (Rhs l) x -> Rhs l
    to :: forall x. Rep (Rhs l) x -> Rhs l
    Generic)

    -- | A guarded right hand side @|@ /stmts/ @=@ /exp/, or @|@ /stmts/ @->@ /exp/
    --   for case alternatives.
    --   The guard is a series of statements when using pattern guards,
    --   otherwise it will be a single qualifier expression.
    data GuardedRhs l
         = GuardedRhs l [Stmt l] (Exp l)
      deriving (GuardedRhs l -> GuardedRhs l -> Bool
    (GuardedRhs l -> GuardedRhs l -> Bool)
    -> (GuardedRhs l -> GuardedRhs l -> Bool) -> Eq (GuardedRhs l)
    forall l. Eq l => GuardedRhs l -> GuardedRhs l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => GuardedRhs l -> GuardedRhs l -> Bool
    == :: GuardedRhs l -> GuardedRhs l -> Bool
    $c/= :: forall l. Eq l => GuardedRhs l -> GuardedRhs l -> Bool
    /= :: GuardedRhs l -> GuardedRhs l -> Bool
    Eq,Eq (GuardedRhs l)
    Eq (GuardedRhs l) =>
    (GuardedRhs l -> GuardedRhs l -> Ordering)
    -> (GuardedRhs l -> GuardedRhs l -> Bool)
    -> (GuardedRhs l -> GuardedRhs l -> Bool)
    -> (GuardedRhs l -> GuardedRhs l -> Bool)
    -> (GuardedRhs l -> GuardedRhs l -> Bool)
    -> (GuardedRhs l -> GuardedRhs l -> GuardedRhs l)
    -> (GuardedRhs l -> GuardedRhs l -> GuardedRhs l)
    -> Ord (GuardedRhs l)
    GuardedRhs l -> GuardedRhs l -> Bool
    GuardedRhs l -> GuardedRhs l -> Ordering
    GuardedRhs l -> GuardedRhs l -> GuardedRhs l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (GuardedRhs l)
    forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
    forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Ordering
    forall l. Ord l => GuardedRhs l -> GuardedRhs l -> GuardedRhs l
    $ccompare :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Ordering
    compare :: GuardedRhs l -> GuardedRhs l -> Ordering
    $c< :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
    < :: GuardedRhs l -> GuardedRhs l -> Bool
    $c<= :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
    <= :: GuardedRhs l -> GuardedRhs l -> Bool
    $c> :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
    > :: GuardedRhs l -> GuardedRhs l -> Bool
    $c>= :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> Bool
    >= :: GuardedRhs l -> GuardedRhs l -> Bool
    $cmax :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> GuardedRhs l
    max :: GuardedRhs l -> GuardedRhs l -> GuardedRhs l
    $cmin :: forall l. Ord l => GuardedRhs l -> GuardedRhs l -> GuardedRhs l
    min :: GuardedRhs l -> GuardedRhs l -> GuardedRhs l
    Ord,Int -> GuardedRhs l -> ShowS
    [GuardedRhs l] -> ShowS
    GuardedRhs l -> String
    (Int -> GuardedRhs l -> ShowS)
    -> (GuardedRhs l -> String)
    -> ([GuardedRhs l] -> ShowS)
    -> Show (GuardedRhs l)
    forall l. Show l => Int -> GuardedRhs l -> ShowS
    forall l. Show l => [GuardedRhs l] -> ShowS
    forall l. Show l => GuardedRhs l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> GuardedRhs l -> ShowS
    showsPrec :: Int -> GuardedRhs l -> ShowS
    $cshow :: forall l. Show l => GuardedRhs l -> String
    show :: GuardedRhs l -> String
    $cshowList :: forall l. Show l => [GuardedRhs l] -> ShowS
    showList :: [GuardedRhs l] -> ShowS
    Show,Typeable,Typeable (GuardedRhs l)
    Typeable (GuardedRhs l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l))
    -> (GuardedRhs l -> Constr)
    -> (GuardedRhs l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (GuardedRhs l)))
    -> ((forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> GuardedRhs l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l))
    -> Data (GuardedRhs l)
    GuardedRhs l -> Constr
    GuardedRhs l -> DataType
    (forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l
    forall l. Data l => Typeable (GuardedRhs l)
    forall l. Data l => GuardedRhs l -> Constr
    forall l. Data l => GuardedRhs l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> GuardedRhs l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GuardedRhs l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u
    forall u. (forall d. Data d => d -> u) -> GuardedRhs l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GuardedRhs l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l)
    $ctoConstr :: forall l. Data l => GuardedRhs l -> Constr
    toConstr :: GuardedRhs l -> Constr
    $cdataTypeOf :: forall l. Data l => GuardedRhs l -> DataType
    dataTypeOf :: GuardedRhs l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GuardedRhs l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GuardedRhs l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l
    gmapT :: (forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> GuardedRhs l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> GuardedRhs l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l)
    Data,(forall m. Monoid m => GuardedRhs m -> m)
    -> (forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m)
    -> (forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m)
    -> (forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b)
    -> (forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b)
    -> (forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b)
    -> (forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b)
    -> (forall a. (a -> a -> a) -> GuardedRhs a -> a)
    -> (forall a. (a -> a -> a) -> GuardedRhs a -> a)
    -> (forall a. GuardedRhs a -> [a])
    -> (forall a. GuardedRhs a -> Bool)
    -> (forall a. GuardedRhs a -> Int)
    -> (forall a. Eq a => a -> GuardedRhs a -> Bool)
    -> (forall a. Ord a => GuardedRhs a -> a)
    -> (forall a. Ord a => GuardedRhs a -> a)
    -> (forall a. Num a => GuardedRhs a -> a)
    -> (forall a. Num a => GuardedRhs a -> a)
    -> Foldable GuardedRhs
    forall a. Eq a => a -> GuardedRhs a -> Bool
    forall a. Num a => GuardedRhs a -> a
    forall a. Ord a => GuardedRhs a -> a
    forall m. Monoid m => GuardedRhs m -> m
    forall a. GuardedRhs a -> Bool
    forall a. GuardedRhs a -> Int
    forall a. GuardedRhs a -> [a]
    forall a. (a -> a -> a) -> GuardedRhs a -> a
    forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
    forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
    forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => GuardedRhs m -> m
    fold :: forall m. Monoid m => GuardedRhs m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> GuardedRhs a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> GuardedRhs a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> GuardedRhs a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> GuardedRhs a -> a
    foldr1 :: forall a. (a -> a -> a) -> GuardedRhs a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> GuardedRhs a -> a
    foldl1 :: forall a. (a -> a -> a) -> GuardedRhs a -> a
    $ctoList :: forall a. GuardedRhs a -> [a]
    toList :: forall a. GuardedRhs a -> [a]
    $cnull :: forall a. GuardedRhs a -> Bool
    null :: forall a. GuardedRhs a -> Bool
    $clength :: forall a. GuardedRhs a -> Int
    length :: forall a. GuardedRhs a -> Int
    $celem :: forall a. Eq a => a -> GuardedRhs a -> Bool
    elem :: forall a. Eq a => a -> GuardedRhs a -> Bool
    $cmaximum :: forall a. Ord a => GuardedRhs a -> a
    maximum :: forall a. Ord a => GuardedRhs a -> a
    $cminimum :: forall a. Ord a => GuardedRhs a -> a
    minimum :: forall a. Ord a => GuardedRhs a -> a
    $csum :: forall a. Num a => GuardedRhs a -> a
    sum :: forall a. Num a => GuardedRhs a -> a
    $cproduct :: forall a. Num a => GuardedRhs a -> a
    product :: forall a. Num a => GuardedRhs a -> a
    Foldable,Functor GuardedRhs
    Foldable GuardedRhs
    (Functor GuardedRhs, Foldable GuardedRhs) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> GuardedRhs a -> f (GuardedRhs b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        GuardedRhs (f a) -> f (GuardedRhs a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> GuardedRhs a -> m (GuardedRhs b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        GuardedRhs (m a) -> m (GuardedRhs a))
    -> Traversable GuardedRhs
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    GuardedRhs (m a) -> m (GuardedRhs a)
    forall (f :: * -> *) a.
    Applicative f =>
    GuardedRhs (f a) -> f (GuardedRhs a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GuardedRhs a -> m (GuardedRhs b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GuardedRhs a -> f (GuardedRhs b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GuardedRhs a -> f (GuardedRhs b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GuardedRhs a -> f (GuardedRhs b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    GuardedRhs (f a) -> f (GuardedRhs a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    GuardedRhs (f a) -> f (GuardedRhs a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GuardedRhs a -> m (GuardedRhs b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GuardedRhs a -> m (GuardedRhs b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    GuardedRhs (m a) -> m (GuardedRhs a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    GuardedRhs (m a) -> m (GuardedRhs a)
    Traversable,(forall a b. (a -> b) -> GuardedRhs a -> GuardedRhs b)
    -> (forall a b. a -> GuardedRhs b -> GuardedRhs a)
    -> Functor GuardedRhs
    forall a b. a -> GuardedRhs b -> GuardedRhs a
    forall a b. (a -> b) -> GuardedRhs a -> GuardedRhs b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> GuardedRhs a -> GuardedRhs b
    fmap :: forall a b. (a -> b) -> GuardedRhs a -> GuardedRhs b
    $c<$ :: forall a b. a -> GuardedRhs b -> GuardedRhs a
    <$ :: forall a b. a -> GuardedRhs b -> GuardedRhs a
    Functor,(forall x. GuardedRhs l -> Rep (GuardedRhs l) x)
    -> (forall x. Rep (GuardedRhs l) x -> GuardedRhs l)
    -> Generic (GuardedRhs l)
    forall x. Rep (GuardedRhs l) x -> GuardedRhs l
    forall x. GuardedRhs l -> Rep (GuardedRhs l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (GuardedRhs l) x -> GuardedRhs l
    forall l x. GuardedRhs l -> Rep (GuardedRhs l) x
    $cfrom :: forall l x. GuardedRhs l -> Rep (GuardedRhs l) x
    from :: forall x. GuardedRhs l -> Rep (GuardedRhs l) x
    $cto :: forall l x. Rep (GuardedRhs l) x -> GuardedRhs l
    to :: forall x. Rep (GuardedRhs l) x -> GuardedRhs l
    Generic)

    -- | A type qualified with a context.
    --   An unqualified type has an empty context.
    data Type l
         = TyForall l
            (Maybe [TyVarBind l])
            (Maybe (Context l))
            (Type l)                                -- ^ qualified type
         | TyStar  l                                -- ^ @*@, the type of types
         | TyFun   l (Type l) (Type l)              -- ^ function type
         | TyTuple l Boxed [Type l]                 -- ^ tuple type, possibly boxed
         | TyUnboxedSum l [Type l]                  -- ^ unboxed tuple type
         | TyList  l (Type l)                       -- ^ list syntax, e.g. [a], as opposed to [] a
         | TyParArray  l (Type l)                   -- ^ parallel array syntax, e.g. [:a:]
         | TyApp   l (Type l) (Type l)              -- ^ application of a type constructor
         | TyVar   l (Name l)                       -- ^ type variable
         | TyCon   l (QName l)                      -- ^ named type or type constructor
         | TyParen l (Type l)                       -- ^ type surrounded by parentheses
         | TyInfix l (Type l) (MaybePromotedName l)
                              (Type l)              -- ^ infix type constructor
         | TyKind  l (Type l) (Kind l)              -- ^ type with explicit kind signature
         | TyPromoted l (Promoted l)                -- ^ @'K@, a promoted data type (-XDataKinds).
         | TyEquals l (Type l) (Type l)             -- ^ type equality predicate enabled by ConstraintKinds
         | TySplice l (Splice l)                    -- ^ template haskell splice type
         | TyBang l (BangType l) (Unpackedness l) (Type l)           -- ^ Strict type marked with \"@!@\" or type marked with UNPACK pragma.
         | TyWildCard l (Maybe (Name l))            -- ^ Either an anonymous of named type wildcard
         | TyQuasiQuote l String String             -- ^ @[$/name/| /string/ |]@
      deriving (Type l -> Type l -> Bool
    (Type l -> Type l -> Bool)
    -> (Type l -> Type l -> Bool) -> Eq (Type l)
    forall l. Eq l => Type l -> Type l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Type l -> Type l -> Bool
    == :: Type l -> Type l -> Bool
    $c/= :: forall l. Eq l => Type l -> Type l -> Bool
    /= :: Type l -> Type l -> Bool
    Eq,Eq (Type l)
    Eq (Type l) =>
    (Type l -> Type l -> Ordering)
    -> (Type l -> Type l -> Bool)
    -> (Type l -> Type l -> Bool)
    -> (Type l -> Type l -> Bool)
    -> (Type l -> Type l -> Bool)
    -> (Type l -> Type l -> Type l)
    -> (Type l -> Type l -> Type l)
    -> Ord (Type l)
    Type l -> Type l -> Bool
    Type l -> Type l -> Ordering
    Type l -> Type l -> Type l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Type l)
    forall l. Ord l => Type l -> Type l -> Bool
    forall l. Ord l => Type l -> Type l -> Ordering
    forall l. Ord l => Type l -> Type l -> Type l
    $ccompare :: forall l. Ord l => Type l -> Type l -> Ordering
    compare :: Type l -> Type l -> Ordering
    $c< :: forall l. Ord l => Type l -> Type l -> Bool
    < :: Type l -> Type l -> Bool
    $c<= :: forall l. Ord l => Type l -> Type l -> Bool
    <= :: Type l -> Type l -> Bool
    $c> :: forall l. Ord l => Type l -> Type l -> Bool
    > :: Type l -> Type l -> Bool
    $c>= :: forall l. Ord l => Type l -> Type l -> Bool
    >= :: Type l -> Type l -> Bool
    $cmax :: forall l. Ord l => Type l -> Type l -> Type l
    max :: Type l -> Type l -> Type l
    $cmin :: forall l. Ord l => Type l -> Type l -> Type l
    min :: Type l -> Type l -> Type l
    Ord,Int -> Type l -> ShowS
    [Type l] -> ShowS
    Type l -> String
    (Int -> Type l -> ShowS)
    -> (Type l -> String) -> ([Type l] -> ShowS) -> Show (Type l)
    forall l. Show l => Int -> Type l -> ShowS
    forall l. Show l => [Type l] -> ShowS
    forall l. Show l => Type l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Type l -> ShowS
    showsPrec :: Int -> Type l -> ShowS
    $cshow :: forall l. Show l => Type l -> String
    show :: Type l -> String
    $cshowList :: forall l. Show l => [Type l] -> ShowS
    showList :: [Type l] -> ShowS
    Show,Typeable,Typeable (Type l)
    Typeable (Type l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Type l -> c (Type l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Type l))
    -> (Type l -> Constr)
    -> (Type l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Type l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l)))
    -> ((forall b. Data b => b -> b) -> Type l -> Type l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Type l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Type l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Type l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Type l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Type l -> m (Type l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Type l -> m (Type l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Type l -> m (Type l))
    -> Data (Type l)
    Type l -> Constr
    Type l -> DataType
    (forall b. Data b => b -> b) -> Type l -> Type l
    forall l. Data l => Typeable (Type l)
    forall l. Data l => Type l -> Constr
    forall l. Data l => Type l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Type l -> Type l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Type l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Type l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Type l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type l -> c (Type l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Type l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Type l -> u
    forall u. (forall d. Data d => d -> u) -> Type l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Type l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type l -> c (Type l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Type l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type l -> c (Type l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type l -> c (Type l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Type l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Type l)
    $ctoConstr :: forall l. Data l => Type l -> Constr
    toConstr :: Type l -> Constr
    $cdataTypeOf :: forall l. Data l => Type l -> DataType
    dataTypeOf :: Type l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Type l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Type l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Type l -> Type l
    gmapT :: (forall b. Data b => b -> b) -> Type l -> Type l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Type l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Type l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Type l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type l -> m (Type l)
    Data,(forall m. Monoid m => Type m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Type a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Type a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Type a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Type a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Type a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Type a -> b)
    -> (forall a. (a -> a -> a) -> Type a -> a)
    -> (forall a. (a -> a -> a) -> Type a -> a)
    -> (forall a. Type a -> [a])
    -> (forall a. Type a -> Bool)
    -> (forall a. Type a -> Int)
    -> (forall a. Eq a => a -> Type a -> Bool)
    -> (forall a. Ord a => Type a -> a)
    -> (forall a. Ord a => Type a -> a)
    -> (forall a. Num a => Type a -> a)
    -> (forall a. Num a => Type a -> a)
    -> Foldable Type
    forall a. Eq a => a -> Type a -> Bool
    forall a. Num a => Type a -> a
    forall a. Ord a => Type a -> a
    forall m. Monoid m => Type m -> m
    forall a. Type a -> Bool
    forall a. Type a -> Int
    forall a. Type a -> [a]
    forall a. (a -> a -> a) -> Type a -> a
    forall m a. Monoid m => (a -> m) -> Type a -> m
    forall b a. (b -> a -> b) -> b -> Type a -> b
    forall a b. (a -> b -> b) -> b -> Type a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Type m -> m
    fold :: forall m. Monoid m => Type m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Type a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Type a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Type a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Type a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Type a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Type a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Type a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Type a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Type a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Type a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Type a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Type a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Type a -> a
    foldr1 :: forall a. (a -> a -> a) -> Type a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Type a -> a
    foldl1 :: forall a. (a -> a -> a) -> Type a -> a
    $ctoList :: forall a. Type a -> [a]
    toList :: forall a. Type a -> [a]
    $cnull :: forall a. Type a -> Bool
    null :: forall a. Type a -> Bool
    $clength :: forall a. Type a -> Int
    length :: forall a. Type a -> Int
    $celem :: forall a. Eq a => a -> Type a -> Bool
    elem :: forall a. Eq a => a -> Type a -> Bool
    $cmaximum :: forall a. Ord a => Type a -> a
    maximum :: forall a. Ord a => Type a -> a
    $cminimum :: forall a. Ord a => Type a -> a
    minimum :: forall a. Ord a => Type a -> a
    $csum :: forall a. Num a => Type a -> a
    sum :: forall a. Num a => Type a -> a
    $cproduct :: forall a. Num a => Type a -> a
    product :: forall a. Num a => Type a -> a
    Foldable,Functor Type
    Foldable Type
    (Functor Type, Foldable Type) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Type a -> f (Type b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Type (f a) -> f (Type a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Type a -> m (Type b))
    -> (forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a))
    -> Traversable Type
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a)
    forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Type a -> m (Type b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Type a -> f (Type b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Type a -> f (Type b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Type a -> f (Type b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Type a -> m (Type b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Type a -> m (Type b)
    $csequence :: forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a)
    sequence :: forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a)
    Traversable,(forall a b. (a -> b) -> Type a -> Type b)
    -> (forall a b. a -> Type b -> Type a) -> Functor Type
    forall a b. a -> Type b -> Type a
    forall a b. (a -> b) -> Type a -> Type b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Type a -> Type b
    fmap :: forall a b. (a -> b) -> Type a -> Type b
    $c<$ :: forall a b. a -> Type b -> Type a
    <$ :: forall a b. a -> Type b -> Type a
    Functor,(forall x. Type l -> Rep (Type l) x)
    -> (forall x. Rep (Type l) x -> Type l) -> Generic (Type l)
    forall x. Rep (Type l) x -> Type l
    forall x. Type l -> Rep (Type l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Type l) x -> Type l
    forall l x. Type l -> Rep (Type l) x
    $cfrom :: forall l x. Type l -> Rep (Type l) x
    from :: forall x. Type l -> Rep (Type l) x
    $cto :: forall l x. Rep (Type l) x -> Type l
    to :: forall x. Rep (Type l) x -> Type l
    Generic)

    data MaybePromotedName l = PromotedName l (QName l) | UnpromotedName l (QName l)
      deriving (MaybePromotedName l -> MaybePromotedName l -> Bool
    (MaybePromotedName l -> MaybePromotedName l -> Bool)
    -> (MaybePromotedName l -> MaybePromotedName l -> Bool)
    -> Eq (MaybePromotedName l)
    forall l.
    Eq l =>
    MaybePromotedName l -> MaybePromotedName l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l.
    Eq l =>
    MaybePromotedName l -> MaybePromotedName l -> Bool
    == :: MaybePromotedName l -> MaybePromotedName l -> Bool
    $c/= :: forall l.
    Eq l =>
    MaybePromotedName l -> MaybePromotedName l -> Bool
    /= :: MaybePromotedName l -> MaybePromotedName l -> Bool
    Eq,Eq (MaybePromotedName l)
    Eq (MaybePromotedName l) =>
    (MaybePromotedName l -> MaybePromotedName l -> Ordering)
    -> (MaybePromotedName l -> MaybePromotedName l -> Bool)
    -> (MaybePromotedName l -> MaybePromotedName l -> Bool)
    -> (MaybePromotedName l -> MaybePromotedName l -> Bool)
    -> (MaybePromotedName l -> MaybePromotedName l -> Bool)
    -> (MaybePromotedName l
        -> MaybePromotedName l -> MaybePromotedName l)
    -> (MaybePromotedName l
        -> MaybePromotedName l -> MaybePromotedName l)
    -> Ord (MaybePromotedName l)
    MaybePromotedName l -> MaybePromotedName l -> Bool
    MaybePromotedName l -> MaybePromotedName l -> Ordering
    MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (MaybePromotedName l)
    forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> Bool
    forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> Ordering
    forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
    $ccompare :: forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> Ordering
    compare :: MaybePromotedName l -> MaybePromotedName l -> Ordering
    $c< :: forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> Bool
    < :: MaybePromotedName l -> MaybePromotedName l -> Bool
    $c<= :: forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> Bool
    <= :: MaybePromotedName l -> MaybePromotedName l -> Bool
    $c> :: forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> Bool
    > :: MaybePromotedName l -> MaybePromotedName l -> Bool
    $c>= :: forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> Bool
    >= :: MaybePromotedName l -> MaybePromotedName l -> Bool
    $cmax :: forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
    max :: MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
    $cmin :: forall l.
    Ord l =>
    MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
    min :: MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l
    Ord,Int -> MaybePromotedName l -> ShowS
    [MaybePromotedName l] -> ShowS
    MaybePromotedName l -> String
    (Int -> MaybePromotedName l -> ShowS)
    -> (MaybePromotedName l -> String)
    -> ([MaybePromotedName l] -> ShowS)
    -> Show (MaybePromotedName l)
    forall l. Show l => Int -> MaybePromotedName l -> ShowS
    forall l. Show l => [MaybePromotedName l] -> ShowS
    forall l. Show l => MaybePromotedName l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> MaybePromotedName l -> ShowS
    showsPrec :: Int -> MaybePromotedName l -> ShowS
    $cshow :: forall l. Show l => MaybePromotedName l -> String
    show :: MaybePromotedName l -> String
    $cshowList :: forall l. Show l => [MaybePromotedName l] -> ShowS
    showList :: [MaybePromotedName l] -> ShowS
    Show,Typeable,Typeable (MaybePromotedName l)
    Typeable (MaybePromotedName l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> MaybePromotedName l
     -> c (MaybePromotedName l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l))
    -> (MaybePromotedName l -> Constr)
    -> (MaybePromotedName l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (MaybePromotedName l)))
    -> ((forall b. Data b => b -> b)
        -> MaybePromotedName l -> MaybePromotedName l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> MaybePromotedName l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> MaybePromotedName l -> m (MaybePromotedName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> MaybePromotedName l -> m (MaybePromotedName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> MaybePromotedName l -> m (MaybePromotedName l))
    -> Data (MaybePromotedName l)
    MaybePromotedName l -> Constr
    MaybePromotedName l -> DataType
    (forall b. Data b => b -> b)
    -> MaybePromotedName l -> MaybePromotedName l
    forall l. Data l => Typeable (MaybePromotedName l)
    forall l. Data l => MaybePromotedName l -> Constr
    forall l. Data l => MaybePromotedName l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> MaybePromotedName l -> MaybePromotedName l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> MaybePromotedName l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> MaybePromotedName l
    -> c (MaybePromotedName l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (MaybePromotedName l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u
    forall u.
    (forall d. Data d => d -> u) -> MaybePromotedName l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> MaybePromotedName l
    -> c (MaybePromotedName l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (MaybePromotedName l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> MaybePromotedName l
    -> c (MaybePromotedName l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> MaybePromotedName l
    -> c (MaybePromotedName l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l)
    $ctoConstr :: forall l. Data l => MaybePromotedName l -> Constr
    toConstr :: MaybePromotedName l -> Constr
    $cdataTypeOf :: forall l. Data l => MaybePromotedName l -> DataType
    dataTypeOf :: MaybePromotedName l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (MaybePromotedName l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (MaybePromotedName l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b)
    -> MaybePromotedName l -> MaybePromotedName l
    gmapT :: (forall b. Data b => b -> b)
    -> MaybePromotedName l -> MaybePromotedName l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> MaybePromotedName l -> [u]
    gmapQ :: forall u.
    (forall d. Data d => d -> u) -> MaybePromotedName l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MaybePromotedName l -> m (MaybePromotedName l)
    Data,(forall m. Monoid m => MaybePromotedName m -> m)
    -> (forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m)
    -> (forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m)
    -> (forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b)
    -> (forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b)
    -> (forall a. (a -> a -> a) -> MaybePromotedName a -> a)
    -> (forall a. (a -> a -> a) -> MaybePromotedName a -> a)
    -> (forall a. MaybePromotedName a -> [a])
    -> (forall a. MaybePromotedName a -> Bool)
    -> (forall a. MaybePromotedName a -> Int)
    -> (forall a. Eq a => a -> MaybePromotedName a -> Bool)
    -> (forall a. Ord a => MaybePromotedName a -> a)
    -> (forall a. Ord a => MaybePromotedName a -> a)
    -> (forall a. Num a => MaybePromotedName a -> a)
    -> (forall a. Num a => MaybePromotedName a -> a)
    -> Foldable MaybePromotedName
    forall a. Eq a => a -> MaybePromotedName a -> Bool
    forall a. Num a => MaybePromotedName a -> a
    forall a. Ord a => MaybePromotedName a -> a
    forall m. Monoid m => MaybePromotedName m -> m
    forall a. MaybePromotedName a -> Bool
    forall a. MaybePromotedName a -> Int
    forall a. MaybePromotedName a -> [a]
    forall a. (a -> a -> a) -> MaybePromotedName a -> a
    forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
    forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
    forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => MaybePromotedName m -> m
    fold :: forall m. Monoid m => MaybePromotedName m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> MaybePromotedName a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> MaybePromotedName a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> MaybePromotedName a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> MaybePromotedName a -> a
    foldr1 :: forall a. (a -> a -> a) -> MaybePromotedName a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> MaybePromotedName a -> a
    foldl1 :: forall a. (a -> a -> a) -> MaybePromotedName a -> a
    $ctoList :: forall a. MaybePromotedName a -> [a]
    toList :: forall a. MaybePromotedName a -> [a]
    $cnull :: forall a. MaybePromotedName a -> Bool
    null :: forall a. MaybePromotedName a -> Bool
    $clength :: forall a. MaybePromotedName a -> Int
    length :: forall a. MaybePromotedName a -> Int
    $celem :: forall a. Eq a => a -> MaybePromotedName a -> Bool
    elem :: forall a. Eq a => a -> MaybePromotedName a -> Bool
    $cmaximum :: forall a. Ord a => MaybePromotedName a -> a
    maximum :: forall a. Ord a => MaybePromotedName a -> a
    $cminimum :: forall a. Ord a => MaybePromotedName a -> a
    minimum :: forall a. Ord a => MaybePromotedName a -> a
    $csum :: forall a. Num a => MaybePromotedName a -> a
    sum :: forall a. Num a => MaybePromotedName a -> a
    $cproduct :: forall a. Num a => MaybePromotedName a -> a
    product :: forall a. Num a => MaybePromotedName a -> a
    Foldable,Functor MaybePromotedName
    Foldable MaybePromotedName
    (Functor MaybePromotedName, Foldable MaybePromotedName) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        MaybePromotedName (f a) -> f (MaybePromotedName a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        MaybePromotedName (m a) -> m (MaybePromotedName a))
    -> Traversable MaybePromotedName
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    MaybePromotedName (m a) -> m (MaybePromotedName a)
    forall (f :: * -> *) a.
    Applicative f =>
    MaybePromotedName (f a) -> f (MaybePromotedName a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    MaybePromotedName (f a) -> f (MaybePromotedName a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    MaybePromotedName (f a) -> f (MaybePromotedName a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    MaybePromotedName (m a) -> m (MaybePromotedName a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    MaybePromotedName (m a) -> m (MaybePromotedName a)
    Traversable,(forall a b.
     (a -> b) -> MaybePromotedName a -> MaybePromotedName b)
    -> (forall a b. a -> MaybePromotedName b -> MaybePromotedName a)
    -> Functor MaybePromotedName
    forall a b. a -> MaybePromotedName b -> MaybePromotedName a
    forall a b. (a -> b) -> MaybePromotedName a -> MaybePromotedName b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> MaybePromotedName a -> MaybePromotedName b
    fmap :: forall a b. (a -> b) -> MaybePromotedName a -> MaybePromotedName b
    $c<$ :: forall a b. a -> MaybePromotedName b -> MaybePromotedName a
    <$ :: forall a b. a -> MaybePromotedName b -> MaybePromotedName a
    Functor,(forall x. MaybePromotedName l -> Rep (MaybePromotedName l) x)
    -> (forall x. Rep (MaybePromotedName l) x -> MaybePromotedName l)
    -> Generic (MaybePromotedName l)
    forall x. Rep (MaybePromotedName l) x -> MaybePromotedName l
    forall x. MaybePromotedName l -> Rep (MaybePromotedName l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (MaybePromotedName l) x -> MaybePromotedName l
    forall l x. MaybePromotedName l -> Rep (MaybePromotedName l) x
    $cfrom :: forall l x. MaybePromotedName l -> Rep (MaybePromotedName l) x
    from :: forall x. MaybePromotedName l -> Rep (MaybePromotedName l) x
    $cto :: forall l x. Rep (MaybePromotedName l) x -> MaybePromotedName l
    to :: forall x. Rep (MaybePromotedName l) x -> MaybePromotedName l
    Generic)

    -- | Bools here are True if there was a leading quote which may be
    -- left out. For example @'[k1,k2]@ means the same thing as @[k1,k2]@.
    data Promoted l
            = PromotedInteger l Integer String -- ^ parsed value and raw string
            | PromotedString l String String -- ^ parsed value and raw string
            | PromotedCon l Bool (QName l)
            | PromotedList l Bool [Type l]
            | PromotedTuple l [Type l]
            | PromotedUnit l
      deriving (Promoted l -> Promoted l -> Bool
    (Promoted l -> Promoted l -> Bool)
    -> (Promoted l -> Promoted l -> Bool) -> Eq (Promoted l)
    forall l. Eq l => Promoted l -> Promoted l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Promoted l -> Promoted l -> Bool
    == :: Promoted l -> Promoted l -> Bool
    $c/= :: forall l. Eq l => Promoted l -> Promoted l -> Bool
    /= :: Promoted l -> Promoted l -> Bool
    Eq,Eq (Promoted l)
    Eq (Promoted l) =>
    (Promoted l -> Promoted l -> Ordering)
    -> (Promoted l -> Promoted l -> Bool)
    -> (Promoted l -> Promoted l -> Bool)
    -> (Promoted l -> Promoted l -> Bool)
    -> (Promoted l -> Promoted l -> Bool)
    -> (Promoted l -> Promoted l -> Promoted l)
    -> (Promoted l -> Promoted l -> Promoted l)
    -> Ord (Promoted l)
    Promoted l -> Promoted l -> Bool
    Promoted l -> Promoted l -> Ordering
    Promoted l -> Promoted l -> Promoted l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Promoted l)
    forall l. Ord l => Promoted l -> Promoted l -> Bool
    forall l. Ord l => Promoted l -> Promoted l -> Ordering
    forall l. Ord l => Promoted l -> Promoted l -> Promoted l
    $ccompare :: forall l. Ord l => Promoted l -> Promoted l -> Ordering
    compare :: Promoted l -> Promoted l -> Ordering
    $c< :: forall l. Ord l => Promoted l -> Promoted l -> Bool
    < :: Promoted l -> Promoted l -> Bool
    $c<= :: forall l. Ord l => Promoted l -> Promoted l -> Bool
    <= :: Promoted l -> Promoted l -> Bool
    $c> :: forall l. Ord l => Promoted l -> Promoted l -> Bool
    > :: Promoted l -> Promoted l -> Bool
    $c>= :: forall l. Ord l => Promoted l -> Promoted l -> Bool
    >= :: Promoted l -> Promoted l -> Bool
    $cmax :: forall l. Ord l => Promoted l -> Promoted l -> Promoted l
    max :: Promoted l -> Promoted l -> Promoted l
    $cmin :: forall l. Ord l => Promoted l -> Promoted l -> Promoted l
    min :: Promoted l -> Promoted l -> Promoted l
    Ord,Int -> Promoted l -> ShowS
    [Promoted l] -> ShowS
    Promoted l -> String
    (Int -> Promoted l -> ShowS)
    -> (Promoted l -> String)
    -> ([Promoted l] -> ShowS)
    -> Show (Promoted l)
    forall l. Show l => Int -> Promoted l -> ShowS
    forall l. Show l => [Promoted l] -> ShowS
    forall l. Show l => Promoted l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Promoted l -> ShowS
    showsPrec :: Int -> Promoted l -> ShowS
    $cshow :: forall l. Show l => Promoted l -> String
    show :: Promoted l -> String
    $cshowList :: forall l. Show l => [Promoted l] -> ShowS
    showList :: [Promoted l] -> ShowS
    Show,Typeable,Typeable (Promoted l)
    Typeable (Promoted l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Promoted l -> c (Promoted l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Promoted l))
    -> (Promoted l -> Constr)
    -> (Promoted l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Promoted l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Promoted l)))
    -> ((forall b. Data b => b -> b) -> Promoted l -> Promoted l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Promoted l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Promoted l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Promoted l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Promoted l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l))
    -> Data (Promoted l)
    Promoted l -> Constr
    Promoted l -> DataType
    (forall b. Data b => b -> b) -> Promoted l -> Promoted l
    forall l. Data l => Typeable (Promoted l)
    forall l. Data l => Promoted l -> Constr
    forall l. Data l => Promoted l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Promoted l -> Promoted l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Promoted l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Promoted l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Promoted l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Promoted l -> c (Promoted l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Promoted l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Promoted l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Promoted l -> u
    forall u. (forall d. Data d => d -> u) -> Promoted l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Promoted l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Promoted l -> c (Promoted l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Promoted l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Promoted l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Promoted l -> c (Promoted l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Promoted l -> c (Promoted l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Promoted l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Promoted l)
    $ctoConstr :: forall l. Data l => Promoted l -> Constr
    toConstr :: Promoted l -> Constr
    $cdataTypeOf :: forall l. Data l => Promoted l -> DataType
    dataTypeOf :: Promoted l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Promoted l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Promoted l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Promoted l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Promoted l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Promoted l -> Promoted l
    gmapT :: (forall b. Data b => b -> b) -> Promoted l -> Promoted l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Promoted l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Promoted l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Promoted l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Promoted l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Promoted l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l)
    Data,(forall m. Monoid m => Promoted m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Promoted a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Promoted a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Promoted a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Promoted a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Promoted a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Promoted a -> b)
    -> (forall a. (a -> a -> a) -> Promoted a -> a)
    -> (forall a. (a -> a -> a) -> Promoted a -> a)
    -> (forall a. Promoted a -> [a])
    -> (forall a. Promoted a -> Bool)
    -> (forall a. Promoted a -> Int)
    -> (forall a. Eq a => a -> Promoted a -> Bool)
    -> (forall a. Ord a => Promoted a -> a)
    -> (forall a. Ord a => Promoted a -> a)
    -> (forall a. Num a => Promoted a -> a)
    -> (forall a. Num a => Promoted a -> a)
    -> Foldable Promoted
    forall a. Eq a => a -> Promoted a -> Bool
    forall a. Num a => Promoted a -> a
    forall a. Ord a => Promoted a -> a
    forall m. Monoid m => Promoted m -> m
    forall a. Promoted a -> Bool
    forall a. Promoted a -> Int
    forall a. Promoted a -> [a]
    forall a. (a -> a -> a) -> Promoted a -> a
    forall m a. Monoid m => (a -> m) -> Promoted a -> m
    forall b a. (b -> a -> b) -> b -> Promoted a -> b
    forall a b. (a -> b -> b) -> b -> Promoted a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Promoted m -> m
    fold :: forall m. Monoid m => Promoted m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Promoted a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Promoted a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Promoted a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Promoted a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Promoted a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Promoted a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Promoted a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Promoted a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Promoted a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Promoted a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Promoted a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Promoted a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Promoted a -> a
    foldr1 :: forall a. (a -> a -> a) -> Promoted a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Promoted a -> a
    foldl1 :: forall a. (a -> a -> a) -> Promoted a -> a
    $ctoList :: forall a. Promoted a -> [a]
    toList :: forall a. Promoted a -> [a]
    $cnull :: forall a. Promoted a -> Bool
    null :: forall a. Promoted a -> Bool
    $clength :: forall a. Promoted a -> Int
    length :: forall a. Promoted a -> Int
    $celem :: forall a. Eq a => a -> Promoted a -> Bool
    elem :: forall a. Eq a => a -> Promoted a -> Bool
    $cmaximum :: forall a. Ord a => Promoted a -> a
    maximum :: forall a. Ord a => Promoted a -> a
    $cminimum :: forall a. Ord a => Promoted a -> a
    minimum :: forall a. Ord a => Promoted a -> a
    $csum :: forall a. Num a => Promoted a -> a
    sum :: forall a. Num a => Promoted a -> a
    $cproduct :: forall a. Num a => Promoted a -> a
    product :: forall a. Num a => Promoted a -> a
    Foldable,Functor Promoted
    Foldable Promoted
    (Functor Promoted, Foldable Promoted) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Promoted a -> f (Promoted b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Promoted (f a) -> f (Promoted a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Promoted a -> m (Promoted b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Promoted (m a) -> m (Promoted a))
    -> Traversable Promoted
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Promoted (m a) -> m (Promoted a)
    forall (f :: * -> *) a.
    Applicative f =>
    Promoted (f a) -> f (Promoted a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Promoted a -> m (Promoted b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Promoted a -> f (Promoted b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Promoted a -> f (Promoted b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Promoted a -> f (Promoted b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Promoted (f a) -> f (Promoted a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Promoted (f a) -> f (Promoted a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Promoted a -> m (Promoted b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Promoted a -> m (Promoted b)
    $csequence :: forall (m :: * -> *) a. Monad m => Promoted (m a) -> m (Promoted a)
    sequence :: forall (m :: * -> *) a. Monad m => Promoted (m a) -> m (Promoted a)
    Traversable,(forall a b. (a -> b) -> Promoted a -> Promoted b)
    -> (forall a b. a -> Promoted b -> Promoted a) -> Functor Promoted
    forall a b. a -> Promoted b -> Promoted a
    forall a b. (a -> b) -> Promoted a -> Promoted b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Promoted a -> Promoted b
    fmap :: forall a b. (a -> b) -> Promoted a -> Promoted b
    $c<$ :: forall a b. a -> Promoted b -> Promoted a
    <$ :: forall a b. a -> Promoted b -> Promoted a
    Functor,(forall x. Promoted l -> Rep (Promoted l) x)
    -> (forall x. Rep (Promoted l) x -> Promoted l)
    -> Generic (Promoted l)
    forall x. Rep (Promoted l) x -> Promoted l
    forall x. Promoted l -> Rep (Promoted l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Promoted l) x -> Promoted l
    forall l x. Promoted l -> Rep (Promoted l) x
    $cfrom :: forall l x. Promoted l -> Rep (Promoted l) x
    from :: forall x. Promoted l -> Rep (Promoted l) x
    $cto :: forall l x. Rep (Promoted l) x -> Promoted l
    to :: forall x. Rep (Promoted l) x -> Promoted l
    Generic)

    -- | Flag denoting whether a tuple is boxed or unboxed.
    data Boxed = Boxed | Unboxed
      deriving (Boxed -> Boxed -> Bool
    (Boxed -> Boxed -> Bool) -> (Boxed -> Boxed -> Bool) -> Eq Boxed
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Boxed -> Boxed -> Bool
    == :: Boxed -> Boxed -> Bool
    $c/= :: Boxed -> Boxed -> Bool
    /= :: Boxed -> Boxed -> Bool
    Eq,Eq Boxed
    Eq Boxed =>
    (Boxed -> Boxed -> Ordering)
    -> (Boxed -> Boxed -> Bool)
    -> (Boxed -> Boxed -> Bool)
    -> (Boxed -> Boxed -> Bool)
    -> (Boxed -> Boxed -> Bool)
    -> (Boxed -> Boxed -> Boxed)
    -> (Boxed -> Boxed -> Boxed)
    -> Ord Boxed
    Boxed -> Boxed -> Bool
    Boxed -> Boxed -> Ordering
    Boxed -> Boxed -> Boxed
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Boxed -> Boxed -> Ordering
    compare :: Boxed -> Boxed -> Ordering
    $c< :: Boxed -> Boxed -> Bool
    < :: Boxed -> Boxed -> Bool
    $c<= :: Boxed -> Boxed -> Bool
    <= :: Boxed -> Boxed -> Bool
    $c> :: Boxed -> Boxed -> Bool
    > :: Boxed -> Boxed -> Bool
    $c>= :: Boxed -> Boxed -> Bool
    >= :: Boxed -> Boxed -> Bool
    $cmax :: Boxed -> Boxed -> Boxed
    max :: Boxed -> Boxed -> Boxed
    $cmin :: Boxed -> Boxed -> Boxed
    min :: Boxed -> Boxed -> Boxed
    Ord,Int -> Boxed -> ShowS
    [Boxed] -> ShowS
    Boxed -> String
    (Int -> Boxed -> ShowS)
    -> (Boxed -> String) -> ([Boxed] -> ShowS) -> Show Boxed
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Boxed -> ShowS
    showsPrec :: Int -> Boxed -> ShowS
    $cshow :: Boxed -> String
    show :: Boxed -> String
    $cshowList :: [Boxed] -> ShowS
    showList :: [Boxed] -> ShowS
    Show,Typeable,Typeable Boxed
    Typeable Boxed =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Boxed -> c Boxed)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Boxed)
    -> (Boxed -> Constr)
    -> (Boxed -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Boxed))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed))
    -> ((forall b. Data b => b -> b) -> Boxed -> Boxed)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Boxed -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Boxed -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Boxed -> m Boxed)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Boxed -> m Boxed)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Boxed -> m Boxed)
    -> Data Boxed
    Boxed -> Constr
    Boxed -> DataType
    (forall b. Data b => b -> b) -> Boxed -> Boxed
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Boxed -> u
    forall u. (forall d. Data d => d -> u) -> Boxed -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Boxed
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Boxed -> c Boxed
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Boxed)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Boxed -> c Boxed
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Boxed -> c Boxed
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Boxed
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Boxed
    $ctoConstr :: Boxed -> Constr
    toConstr :: Boxed -> Constr
    $cdataTypeOf :: Boxed -> DataType
    dataTypeOf :: Boxed -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Boxed)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Boxed)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed)
    $cgmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed
    gmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Boxed -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Boxed -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Boxed -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Boxed -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Boxed -> m Boxed
    Data,(forall x. Boxed -> Rep Boxed x)
    -> (forall x. Rep Boxed x -> Boxed) -> Generic Boxed
    forall x. Rep Boxed x -> Boxed
    forall x. Boxed -> Rep Boxed x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Boxed -> Rep Boxed x
    from :: forall x. Boxed -> Rep Boxed x
    $cto :: forall x. Rep Boxed x -> Boxed
    to :: forall x. Rep Boxed x -> Boxed
    Generic)

    -- | A type variable declaration, optionally with an explicit kind annotation.
    data TyVarBind l
        = KindedVar   l (Name l) (Kind l)  -- ^ variable binding with kind annotation
        | UnkindedVar l (Name l)           -- ^ ordinary variable binding
      deriving (TyVarBind l -> TyVarBind l -> Bool
    (TyVarBind l -> TyVarBind l -> Bool)
    -> (TyVarBind l -> TyVarBind l -> Bool) -> Eq (TyVarBind l)
    forall l. Eq l => TyVarBind l -> TyVarBind l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => TyVarBind l -> TyVarBind l -> Bool
    == :: TyVarBind l -> TyVarBind l -> Bool
    $c/= :: forall l. Eq l => TyVarBind l -> TyVarBind l -> Bool
    /= :: TyVarBind l -> TyVarBind l -> Bool
    Eq,Eq (TyVarBind l)
    Eq (TyVarBind l) =>
    (TyVarBind l -> TyVarBind l -> Ordering)
    -> (TyVarBind l -> TyVarBind l -> Bool)
    -> (TyVarBind l -> TyVarBind l -> Bool)
    -> (TyVarBind l -> TyVarBind l -> Bool)
    -> (TyVarBind l -> TyVarBind l -> Bool)
    -> (TyVarBind l -> TyVarBind l -> TyVarBind l)
    -> (TyVarBind l -> TyVarBind l -> TyVarBind l)
    -> Ord (TyVarBind l)
    TyVarBind l -> TyVarBind l -> Bool
    TyVarBind l -> TyVarBind l -> Ordering
    TyVarBind l -> TyVarBind l -> TyVarBind l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (TyVarBind l)
    forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
    forall l. Ord l => TyVarBind l -> TyVarBind l -> Ordering
    forall l. Ord l => TyVarBind l -> TyVarBind l -> TyVarBind l
    $ccompare :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Ordering
    compare :: TyVarBind l -> TyVarBind l -> Ordering
    $c< :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
    < :: TyVarBind l -> TyVarBind l -> Bool
    $c<= :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
    <= :: TyVarBind l -> TyVarBind l -> Bool
    $c> :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
    > :: TyVarBind l -> TyVarBind l -> Bool
    $c>= :: forall l. Ord l => TyVarBind l -> TyVarBind l -> Bool
    >= :: TyVarBind l -> TyVarBind l -> Bool
    $cmax :: forall l. Ord l => TyVarBind l -> TyVarBind l -> TyVarBind l
    max :: TyVarBind l -> TyVarBind l -> TyVarBind l
    $cmin :: forall l. Ord l => TyVarBind l -> TyVarBind l -> TyVarBind l
    min :: TyVarBind l -> TyVarBind l -> TyVarBind l
    Ord,Int -> TyVarBind l -> ShowS
    [TyVarBind l] -> ShowS
    TyVarBind l -> String
    (Int -> TyVarBind l -> ShowS)
    -> (TyVarBind l -> String)
    -> ([TyVarBind l] -> ShowS)
    -> Show (TyVarBind l)
    forall l. Show l => Int -> TyVarBind l -> ShowS
    forall l. Show l => [TyVarBind l] -> ShowS
    forall l. Show l => TyVarBind l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> TyVarBind l -> ShowS
    showsPrec :: Int -> TyVarBind l -> ShowS
    $cshow :: forall l. Show l => TyVarBind l -> String
    show :: TyVarBind l -> String
    $cshowList :: forall l. Show l => [TyVarBind l] -> ShowS
    showList :: [TyVarBind l] -> ShowS
    Show,Typeable,Typeable (TyVarBind l)
    Typeable (TyVarBind l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (TyVarBind l))
    -> (TyVarBind l -> Constr)
    -> (TyVarBind l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (TyVarBind l)))
    -> ((forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TyVarBind l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l))
    -> Data (TyVarBind l)
    TyVarBind l -> Constr
    TyVarBind l -> DataType
    (forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l
    forall l. Data l => Typeable (TyVarBind l)
    forall l. Data l => TyVarBind l -> Constr
    forall l. Data l => TyVarBind l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> TyVarBind l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBind l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBind l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u
    forall u. (forall d. Data d => d -> u) -> TyVarBind l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBind l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBind l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBind l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TyVarBind l)
    $ctoConstr :: forall l. Data l => TyVarBind l -> Constr
    toConstr :: TyVarBind l -> Constr
    $cdataTypeOf :: forall l. Data l => TyVarBind l -> DataType
    dataTypeOf :: TyVarBind l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBind l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TyVarBind l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l
    gmapT :: (forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> TyVarBind l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TyVarBind l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l)
    Data,(forall m. Monoid m => TyVarBind m -> m)
    -> (forall m a. Monoid m => (a -> m) -> TyVarBind a -> m)
    -> (forall m a. Monoid m => (a -> m) -> TyVarBind a -> m)
    -> (forall a b. (a -> b -> b) -> b -> TyVarBind a -> b)
    -> (forall a b. (a -> b -> b) -> b -> TyVarBind a -> b)
    -> (forall b a. (b -> a -> b) -> b -> TyVarBind a -> b)
    -> (forall b a. (b -> a -> b) -> b -> TyVarBind a -> b)
    -> (forall a. (a -> a -> a) -> TyVarBind a -> a)
    -> (forall a. (a -> a -> a) -> TyVarBind a -> a)
    -> (forall a. TyVarBind a -> [a])
    -> (forall a. TyVarBind a -> Bool)
    -> (forall a. TyVarBind a -> Int)
    -> (forall a. Eq a => a -> TyVarBind a -> Bool)
    -> (forall a. Ord a => TyVarBind a -> a)
    -> (forall a. Ord a => TyVarBind a -> a)
    -> (forall a. Num a => TyVarBind a -> a)
    -> (forall a. Num a => TyVarBind a -> a)
    -> Foldable TyVarBind
    forall a. Eq a => a -> TyVarBind a -> Bool
    forall a. Num a => TyVarBind a -> a
    forall a. Ord a => TyVarBind a -> a
    forall m. Monoid m => TyVarBind m -> m
    forall a. TyVarBind a -> Bool
    forall a. TyVarBind a -> Int
    forall a. TyVarBind a -> [a]
    forall a. (a -> a -> a) -> TyVarBind a -> a
    forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
    forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
    forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => TyVarBind m -> m
    fold :: forall m. Monoid m => TyVarBind m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> TyVarBind a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> TyVarBind a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> TyVarBind a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> TyVarBind a -> a
    foldr1 :: forall a. (a -> a -> a) -> TyVarBind a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> TyVarBind a -> a
    foldl1 :: forall a. (a -> a -> a) -> TyVarBind a -> a
    $ctoList :: forall a. TyVarBind a -> [a]
    toList :: forall a. TyVarBind a -> [a]
    $cnull :: forall a. TyVarBind a -> Bool
    null :: forall a. TyVarBind a -> Bool
    $clength :: forall a. TyVarBind a -> Int
    length :: forall a. TyVarBind a -> Int
    $celem :: forall a. Eq a => a -> TyVarBind a -> Bool
    elem :: forall a. Eq a => a -> TyVarBind a -> Bool
    $cmaximum :: forall a. Ord a => TyVarBind a -> a
    maximum :: forall a. Ord a => TyVarBind a -> a
    $cminimum :: forall a. Ord a => TyVarBind a -> a
    minimum :: forall a. Ord a => TyVarBind a -> a
    $csum :: forall a. Num a => TyVarBind a -> a
    sum :: forall a. Num a => TyVarBind a -> a
    $cproduct :: forall a. Num a => TyVarBind a -> a
    product :: forall a. Num a => TyVarBind a -> a
    Foldable,Functor TyVarBind
    Foldable TyVarBind
    (Functor TyVarBind, Foldable TyVarBind) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> TyVarBind a -> f (TyVarBind b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        TyVarBind (f a) -> f (TyVarBind a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> TyVarBind a -> m (TyVarBind b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        TyVarBind (m a) -> m (TyVarBind a))
    -> Traversable TyVarBind
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    TyVarBind (m a) -> m (TyVarBind a)
    forall (f :: * -> *) a.
    Applicative f =>
    TyVarBind (f a) -> f (TyVarBind a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TyVarBind a -> m (TyVarBind b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TyVarBind a -> f (TyVarBind b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TyVarBind a -> f (TyVarBind b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> TyVarBind a -> f (TyVarBind b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    TyVarBind (f a) -> f (TyVarBind a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    TyVarBind (f a) -> f (TyVarBind a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TyVarBind a -> m (TyVarBind b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TyVarBind a -> m (TyVarBind b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    TyVarBind (m a) -> m (TyVarBind a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    TyVarBind (m a) -> m (TyVarBind a)
    Traversable,(forall a b. (a -> b) -> TyVarBind a -> TyVarBind b)
    -> (forall a b. a -> TyVarBind b -> TyVarBind a)
    -> Functor TyVarBind
    forall a b. a -> TyVarBind b -> TyVarBind a
    forall a b. (a -> b) -> TyVarBind a -> TyVarBind b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> TyVarBind a -> TyVarBind b
    fmap :: forall a b. (a -> b) -> TyVarBind a -> TyVarBind b
    $c<$ :: forall a b. a -> TyVarBind b -> TyVarBind a
    <$ :: forall a b. a -> TyVarBind b -> TyVarBind a
    Functor,(forall x. TyVarBind l -> Rep (TyVarBind l) x)
    -> (forall x. Rep (TyVarBind l) x -> TyVarBind l)
    -> Generic (TyVarBind l)
    forall x. Rep (TyVarBind l) x -> TyVarBind l
    forall x. TyVarBind l -> Rep (TyVarBind l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (TyVarBind l) x -> TyVarBind l
    forall l x. TyVarBind l -> Rep (TyVarBind l) x
    $cfrom :: forall l x. TyVarBind l -> Rep (TyVarBind l) x
    from :: forall x. TyVarBind l -> Rep (TyVarBind l) x
    $cto :: forall l x. Rep (TyVarBind l) x -> TyVarBind l
    to :: forall x. Rep (TyVarBind l) x -> TyVarBind l
    Generic)

    -- | An explicit kind annotation.
    type Kind = Type

    -- | A functional dependency, given on the form
    --   l1 l2 ... ln -> r2 r3 .. rn
    data FunDep l
        = FunDep l [Name l] [Name l]
      deriving (FunDep l -> FunDep l -> Bool
    (FunDep l -> FunDep l -> Bool)
    -> (FunDep l -> FunDep l -> Bool) -> Eq (FunDep l)
    forall l. Eq l => FunDep l -> FunDep l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => FunDep l -> FunDep l -> Bool
    == :: FunDep l -> FunDep l -> Bool
    $c/= :: forall l. Eq l => FunDep l -> FunDep l -> Bool
    /= :: FunDep l -> FunDep l -> Bool
    Eq,Eq (FunDep l)
    Eq (FunDep l) =>
    (FunDep l -> FunDep l -> Ordering)
    -> (FunDep l -> FunDep l -> Bool)
    -> (FunDep l -> FunDep l -> Bool)
    -> (FunDep l -> FunDep l -> Bool)
    -> (FunDep l -> FunDep l -> Bool)
    -> (FunDep l -> FunDep l -> FunDep l)
    -> (FunDep l -> FunDep l -> FunDep l)
    -> Ord (FunDep l)
    FunDep l -> FunDep l -> Bool
    FunDep l -> FunDep l -> Ordering
    FunDep l -> FunDep l -> FunDep l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (FunDep l)
    forall l. Ord l => FunDep l -> FunDep l -> Bool
    forall l. Ord l => FunDep l -> FunDep l -> Ordering
    forall l. Ord l => FunDep l -> FunDep l -> FunDep l
    $ccompare :: forall l. Ord l => FunDep l -> FunDep l -> Ordering
    compare :: FunDep l -> FunDep l -> Ordering
    $c< :: forall l. Ord l => FunDep l -> FunDep l -> Bool
    < :: FunDep l -> FunDep l -> Bool
    $c<= :: forall l. Ord l => FunDep l -> FunDep l -> Bool
    <= :: FunDep l -> FunDep l -> Bool
    $c> :: forall l. Ord l => FunDep l -> FunDep l -> Bool
    > :: FunDep l -> FunDep l -> Bool
    $c>= :: forall l. Ord l => FunDep l -> FunDep l -> Bool
    >= :: FunDep l -> FunDep l -> Bool
    $cmax :: forall l. Ord l => FunDep l -> FunDep l -> FunDep l
    max :: FunDep l -> FunDep l -> FunDep l
    $cmin :: forall l. Ord l => FunDep l -> FunDep l -> FunDep l
    min :: FunDep l -> FunDep l -> FunDep l
    Ord,Int -> FunDep l -> ShowS
    [FunDep l] -> ShowS
    FunDep l -> String
    (Int -> FunDep l -> ShowS)
    -> (FunDep l -> String) -> ([FunDep l] -> ShowS) -> Show (FunDep l)
    forall l. Show l => Int -> FunDep l -> ShowS
    forall l. Show l => [FunDep l] -> ShowS
    forall l. Show l => FunDep l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> FunDep l -> ShowS
    showsPrec :: Int -> FunDep l -> ShowS
    $cshow :: forall l. Show l => FunDep l -> String
    show :: FunDep l -> String
    $cshowList :: forall l. Show l => [FunDep l] -> ShowS
    showList :: [FunDep l] -> ShowS
    Show,Typeable,Typeable (FunDep l)
    Typeable (FunDep l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> FunDep l -> c (FunDep l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FunDep l))
    -> (FunDep l -> Constr)
    -> (FunDep l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FunDep l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FunDep l)))
    -> ((forall b. Data b => b -> b) -> FunDep l -> FunDep l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FunDep l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FunDep l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> FunDep l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> FunDep l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l))
    -> Data (FunDep l)
    FunDep l -> Constr
    FunDep l -> DataType
    (forall b. Data b => b -> b) -> FunDep l -> FunDep l
    forall l. Data l => Typeable (FunDep l)
    forall l. Data l => FunDep l -> Constr
    forall l. Data l => FunDep l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> FunDep l -> FunDep l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> FunDep l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> FunDep l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FunDep l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunDep l -> c (FunDep l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FunDep l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> FunDep l -> u
    forall u. (forall d. Data d => d -> u) -> FunDep l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FunDep l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunDep l -> c (FunDep l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FunDep l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunDep l -> c (FunDep l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunDep l -> c (FunDep l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FunDep l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FunDep l)
    $ctoConstr :: forall l. Data l => FunDep l -> Constr
    toConstr :: FunDep l -> Constr
    $cdataTypeOf :: forall l. Data l => FunDep l -> DataType
    dataTypeOf :: FunDep l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FunDep l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FunDep l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> FunDep l -> FunDep l
    gmapT :: (forall b. Data b => b -> b) -> FunDep l -> FunDep l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunDep l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> FunDep l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FunDep l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> FunDep l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunDep l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l)
    Data,(forall m. Monoid m => FunDep m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FunDep a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FunDep a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FunDep a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FunDep a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FunDep a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FunDep a -> b)
    -> (forall a. (a -> a -> a) -> FunDep a -> a)
    -> (forall a. (a -> a -> a) -> FunDep a -> a)
    -> (forall a. FunDep a -> [a])
    -> (forall a. FunDep a -> Bool)
    -> (forall a. FunDep a -> Int)
    -> (forall a. Eq a => a -> FunDep a -> Bool)
    -> (forall a. Ord a => FunDep a -> a)
    -> (forall a. Ord a => FunDep a -> a)
    -> (forall a. Num a => FunDep a -> a)
    -> (forall a. Num a => FunDep a -> a)
    -> Foldable FunDep
    forall a. Eq a => a -> FunDep a -> Bool
    forall a. Num a => FunDep a -> a
    forall a. Ord a => FunDep a -> a
    forall m. Monoid m => FunDep m -> m
    forall a. FunDep a -> Bool
    forall a. FunDep a -> Int
    forall a. FunDep a -> [a]
    forall a. (a -> a -> a) -> FunDep a -> a
    forall m a. Monoid m => (a -> m) -> FunDep a -> m
    forall b a. (b -> a -> b) -> b -> FunDep a -> b
    forall a b. (a -> b -> b) -> b -> FunDep a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => FunDep m -> m
    fold :: forall m. Monoid m => FunDep m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> FunDep a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FunDep a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> FunDep a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FunDep a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> FunDep a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FunDep a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> FunDep a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FunDep a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> FunDep a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FunDep a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> FunDep a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FunDep a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> FunDep a -> a
    foldr1 :: forall a. (a -> a -> a) -> FunDep a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> FunDep a -> a
    foldl1 :: forall a. (a -> a -> a) -> FunDep a -> a
    $ctoList :: forall a. FunDep a -> [a]
    toList :: forall a. FunDep a -> [a]
    $cnull :: forall a. FunDep a -> Bool
    null :: forall a. FunDep a -> Bool
    $clength :: forall a. FunDep a -> Int
    length :: forall a. FunDep a -> Int
    $celem :: forall a. Eq a => a -> FunDep a -> Bool
    elem :: forall a. Eq a => a -> FunDep a -> Bool
    $cmaximum :: forall a. Ord a => FunDep a -> a
    maximum :: forall a. Ord a => FunDep a -> a
    $cminimum :: forall a. Ord a => FunDep a -> a
    minimum :: forall a. Ord a => FunDep a -> a
    $csum :: forall a. Num a => FunDep a -> a
    sum :: forall a. Num a => FunDep a -> a
    $cproduct :: forall a. Num a => FunDep a -> a
    product :: forall a. Num a => FunDep a -> a
    Foldable,Functor FunDep
    Foldable FunDep
    (Functor FunDep, Foldable FunDep) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FunDep a -> f (FunDep b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FunDep (f a) -> f (FunDep a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FunDep a -> m (FunDep b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FunDep (m a) -> m (FunDep a))
    -> Traversable FunDep
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => FunDep (m a) -> m (FunDep a)
    forall (f :: * -> *) a.
    Applicative f =>
    FunDep (f a) -> f (FunDep a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FunDep a -> m (FunDep b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FunDep a -> f (FunDep b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FunDep a -> f (FunDep b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FunDep a -> f (FunDep b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FunDep (f a) -> f (FunDep a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FunDep (f a) -> f (FunDep a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FunDep a -> m (FunDep b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FunDep a -> m (FunDep b)
    $csequence :: forall (m :: * -> *) a. Monad m => FunDep (m a) -> m (FunDep a)
    sequence :: forall (m :: * -> *) a. Monad m => FunDep (m a) -> m (FunDep a)
    Traversable,(forall a b. (a -> b) -> FunDep a -> FunDep b)
    -> (forall a b. a -> FunDep b -> FunDep a) -> Functor FunDep
    forall a b. a -> FunDep b -> FunDep a
    forall a b. (a -> b) -> FunDep a -> FunDep b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> FunDep a -> FunDep b
    fmap :: forall a b. (a -> b) -> FunDep a -> FunDep b
    $c<$ :: forall a b. a -> FunDep b -> FunDep a
    <$ :: forall a b. a -> FunDep b -> FunDep a
    Functor,(forall x. FunDep l -> Rep (FunDep l) x)
    -> (forall x. Rep (FunDep l) x -> FunDep l) -> Generic (FunDep l)
    forall x. Rep (FunDep l) x -> FunDep l
    forall x. FunDep l -> Rep (FunDep l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (FunDep l) x -> FunDep l
    forall l x. FunDep l -> Rep (FunDep l) x
    $cfrom :: forall l x. FunDep l -> Rep (FunDep l) x
    from :: forall x. FunDep l -> Rep (FunDep l) x
    $cto :: forall l x. Rep (FunDep l) x -> FunDep l
    to :: forall x. Rep (FunDep l) x -> FunDep l
    Generic)

    -- | A context is a set of assertions
    data Context l
        = CxSingle l (Asst l)
        | CxTuple  l [Asst l]
        | CxEmpty  l
      deriving (Context l -> Context l -> Bool
    (Context l -> Context l -> Bool)
    -> (Context l -> Context l -> Bool) -> Eq (Context l)
    forall l. Eq l => Context l -> Context l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Context l -> Context l -> Bool
    == :: Context l -> Context l -> Bool
    $c/= :: forall l. Eq l => Context l -> Context l -> Bool
    /= :: Context l -> Context l -> Bool
    Eq,Eq (Context l)
    Eq (Context l) =>
    (Context l -> Context l -> Ordering)
    -> (Context l -> Context l -> Bool)
    -> (Context l -> Context l -> Bool)
    -> (Context l -> Context l -> Bool)
    -> (Context l -> Context l -> Bool)
    -> (Context l -> Context l -> Context l)
    -> (Context l -> Context l -> Context l)
    -> Ord (Context l)
    Context l -> Context l -> Bool
    Context l -> Context l -> Ordering
    Context l -> Context l -> Context l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Context l)
    forall l. Ord l => Context l -> Context l -> Bool
    forall l. Ord l => Context l -> Context l -> Ordering
    forall l. Ord l => Context l -> Context l -> Context l
    $ccompare :: forall l. Ord l => Context l -> Context l -> Ordering
    compare :: Context l -> Context l -> Ordering
    $c< :: forall l. Ord l => Context l -> Context l -> Bool
    < :: Context l -> Context l -> Bool
    $c<= :: forall l. Ord l => Context l -> Context l -> Bool
    <= :: Context l -> Context l -> Bool
    $c> :: forall l. Ord l => Context l -> Context l -> Bool
    > :: Context l -> Context l -> Bool
    $c>= :: forall l. Ord l => Context l -> Context l -> Bool
    >= :: Context l -> Context l -> Bool
    $cmax :: forall l. Ord l => Context l -> Context l -> Context l
    max :: Context l -> Context l -> Context l
    $cmin :: forall l. Ord l => Context l -> Context l -> Context l
    min :: Context l -> Context l -> Context l
    Ord,Int -> Context l -> ShowS
    [Context l] -> ShowS
    Context l -> String
    (Int -> Context l -> ShowS)
    -> (Context l -> String)
    -> ([Context l] -> ShowS)
    -> Show (Context l)
    forall l. Show l => Int -> Context l -> ShowS
    forall l. Show l => [Context l] -> ShowS
    forall l. Show l => Context l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Context l -> ShowS
    showsPrec :: Int -> Context l -> ShowS
    $cshow :: forall l. Show l => Context l -> String
    show :: Context l -> String
    $cshowList :: forall l. Show l => [Context l] -> ShowS
    showList :: [Context l] -> ShowS
    Show,Typeable,Typeable (Context l)
    Typeable (Context l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Context l -> c (Context l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Context l))
    -> (Context l -> Constr)
    -> (Context l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Context l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Context l)))
    -> ((forall b. Data b => b -> b) -> Context l -> Context l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Context l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Context l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Context l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Context l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Context l -> m (Context l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Context l -> m (Context l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Context l -> m (Context l))
    -> Data (Context l)
    Context l -> Constr
    Context l -> DataType
    (forall b. Data b => b -> b) -> Context l -> Context l
    forall l. Data l => Typeable (Context l)
    forall l. Data l => Context l -> Constr
    forall l. Data l => Context l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Context l -> Context l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Context l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Context l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Context l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Context l -> c (Context l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Context l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Context l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Context l -> u
    forall u. (forall d. Data d => d -> u) -> Context l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Context l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Context l -> c (Context l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Context l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Context l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Context l -> c (Context l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Context l -> c (Context l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Context l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Context l)
    $ctoConstr :: forall l. Data l => Context l -> Constr
    toConstr :: Context l -> Constr
    $cdataTypeOf :: forall l. Data l => Context l -> DataType
    dataTypeOf :: Context l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Context l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Context l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Context l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Context l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Context l -> Context l
    gmapT :: (forall b. Data b => b -> b) -> Context l -> Context l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Context l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Context l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Context l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Context l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Context l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Context l -> m (Context l)
    Data,(forall m. Monoid m => Context m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Context a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Context a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Context a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Context a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Context a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Context a -> b)
    -> (forall a. (a -> a -> a) -> Context a -> a)
    -> (forall a. (a -> a -> a) -> Context a -> a)
    -> (forall a. Context a -> [a])
    -> (forall a. Context a -> Bool)
    -> (forall a. Context a -> Int)
    -> (forall a. Eq a => a -> Context a -> Bool)
    -> (forall a. Ord a => Context a -> a)
    -> (forall a. Ord a => Context a -> a)
    -> (forall a. Num a => Context a -> a)
    -> (forall a. Num a => Context a -> a)
    -> Foldable Context
    forall a. Eq a => a -> Context a -> Bool
    forall a. Num a => Context a -> a
    forall a. Ord a => Context a -> a
    forall m. Monoid m => Context m -> m
    forall a. Context a -> Bool
    forall a. Context a -> Int
    forall a. Context a -> [a]
    forall a. (a -> a -> a) -> Context a -> a
    forall m a. Monoid m => (a -> m) -> Context a -> m
    forall b a. (b -> a -> b) -> b -> Context a -> b
    forall a b. (a -> b -> b) -> b -> Context a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Context m -> m
    fold :: forall m. Monoid m => Context m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Context a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Context a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Context a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Context a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Context a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Context a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Context a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Context a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Context a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Context a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Context a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Context a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Context a -> a
    foldr1 :: forall a. (a -> a -> a) -> Context a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Context a -> a
    foldl1 :: forall a. (a -> a -> a) -> Context a -> a
    $ctoList :: forall a. Context a -> [a]
    toList :: forall a. Context a -> [a]
    $cnull :: forall a. Context a -> Bool
    null :: forall a. Context a -> Bool
    $clength :: forall a. Context a -> Int
    length :: forall a. Context a -> Int
    $celem :: forall a. Eq a => a -> Context a -> Bool
    elem :: forall a. Eq a => a -> Context a -> Bool
    $cmaximum :: forall a. Ord a => Context a -> a
    maximum :: forall a. Ord a => Context a -> a
    $cminimum :: forall a. Ord a => Context a -> a
    minimum :: forall a. Ord a => Context a -> a
    $csum :: forall a. Num a => Context a -> a
    sum :: forall a. Num a => Context a -> a
    $cproduct :: forall a. Num a => Context a -> a
    product :: forall a. Num a => Context a -> a
    Foldable,Functor Context
    Foldable Context
    (Functor Context, Foldable Context) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Context a -> f (Context b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Context (f a) -> f (Context a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Context a -> m (Context b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Context (m a) -> m (Context a))
    -> Traversable Context
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Context (m a) -> m (Context a)
    forall (f :: * -> *) a.
    Applicative f =>
    Context (f a) -> f (Context a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Context a -> m (Context b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Context a -> f (Context b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Context a -> f (Context b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Context a -> f (Context b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Context (f a) -> f (Context a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Context (f a) -> f (Context a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Context a -> m (Context b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Context a -> m (Context b)
    $csequence :: forall (m :: * -> *) a. Monad m => Context (m a) -> m (Context a)
    sequence :: forall (m :: * -> *) a. Monad m => Context (m a) -> m (Context a)
    Traversable,(forall a b. (a -> b) -> Context a -> Context b)
    -> (forall a b. a -> Context b -> Context a) -> Functor Context
    forall a b. a -> Context b -> Context a
    forall a b. (a -> b) -> Context a -> Context b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Context a -> Context b
    fmap :: forall a b. (a -> b) -> Context a -> Context b
    $c<$ :: forall a b. a -> Context b -> Context a
    <$ :: forall a b. a -> Context b -> Context a
    Functor,(forall x. Context l -> Rep (Context l) x)
    -> (forall x. Rep (Context l) x -> Context l)
    -> Generic (Context l)
    forall x. Rep (Context l) x -> Context l
    forall x. Context l -> Rep (Context l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Context l) x -> Context l
    forall l x. Context l -> Rep (Context l) x
    $cfrom :: forall l x. Context l -> Rep (Context l) x
    from :: forall x. Context l -> Rep (Context l) x
    $cto :: forall l x. Rep (Context l) x -> Context l
    to :: forall x. Rep (Context l) x -> Context l
    Generic)

    -- | Class assertions.
    data Asst l
            = TypeA l (Type l)                      -- ^ type assertion
            | IParam l (IPName l) (Type l)          -- ^ implicit parameter assertion
            | ParenA l (Asst l)                     -- ^ parenthesised class assertion
      deriving (Asst l -> Asst l -> Bool
    (Asst l -> Asst l -> Bool)
    -> (Asst l -> Asst l -> Bool) -> Eq (Asst l)
    forall l. Eq l => Asst l -> Asst l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Asst l -> Asst l -> Bool
    == :: Asst l -> Asst l -> Bool
    $c/= :: forall l. Eq l => Asst l -> Asst l -> Bool
    /= :: Asst l -> Asst l -> Bool
    Eq,Eq (Asst l)
    Eq (Asst l) =>
    (Asst l -> Asst l -> Ordering)
    -> (Asst l -> Asst l -> Bool)
    -> (Asst l -> Asst l -> Bool)
    -> (Asst l -> Asst l -> Bool)
    -> (Asst l -> Asst l -> Bool)
    -> (Asst l -> Asst l -> Asst l)
    -> (Asst l -> Asst l -> Asst l)
    -> Ord (Asst l)
    Asst l -> Asst l -> Bool
    Asst l -> Asst l -> Ordering
    Asst l -> Asst l -> Asst l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Asst l)
    forall l. Ord l => Asst l -> Asst l -> Bool
    forall l. Ord l => Asst l -> Asst l -> Ordering
    forall l. Ord l => Asst l -> Asst l -> Asst l
    $ccompare :: forall l. Ord l => Asst l -> Asst l -> Ordering
    compare :: Asst l -> Asst l -> Ordering
    $c< :: forall l. Ord l => Asst l -> Asst l -> Bool
    < :: Asst l -> Asst l -> Bool
    $c<= :: forall l. Ord l => Asst l -> Asst l -> Bool
    <= :: Asst l -> Asst l -> Bool
    $c> :: forall l. Ord l => Asst l -> Asst l -> Bool
    > :: Asst l -> Asst l -> Bool
    $c>= :: forall l. Ord l => Asst l -> Asst l -> Bool
    >= :: Asst l -> Asst l -> Bool
    $cmax :: forall l. Ord l => Asst l -> Asst l -> Asst l
    max :: Asst l -> Asst l -> Asst l
    $cmin :: forall l. Ord l => Asst l -> Asst l -> Asst l
    min :: Asst l -> Asst l -> Asst l
    Ord,Int -> Asst l -> ShowS
    [Asst l] -> ShowS
    Asst l -> String
    (Int -> Asst l -> ShowS)
    -> (Asst l -> String) -> ([Asst l] -> ShowS) -> Show (Asst l)
    forall l. Show l => Int -> Asst l -> ShowS
    forall l. Show l => [Asst l] -> ShowS
    forall l. Show l => Asst l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Asst l -> ShowS
    showsPrec :: Int -> Asst l -> ShowS
    $cshow :: forall l. Show l => Asst l -> String
    show :: Asst l -> String
    $cshowList :: forall l. Show l => [Asst l] -> ShowS
    showList :: [Asst l] -> ShowS
    Show,Typeable,Typeable (Asst l)
    Typeable (Asst l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Asst l -> c (Asst l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Asst l))
    -> (Asst l -> Constr)
    -> (Asst l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Asst l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l)))
    -> ((forall b. Data b => b -> b) -> Asst l -> Asst l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Asst l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Asst l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Asst l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Asst l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Asst l -> m (Asst l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Asst l -> m (Asst l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Asst l -> m (Asst l))
    -> Data (Asst l)
    Asst l -> Constr
    Asst l -> DataType
    (forall b. Data b => b -> b) -> Asst l -> Asst l
    forall l. Data l => Typeable (Asst l)
    forall l. Data l => Asst l -> Constr
    forall l. Data l => Asst l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Asst l -> Asst l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Asst l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Asst l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Asst l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Asst l -> c (Asst l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Asst l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Asst l -> u
    forall u. (forall d. Data d => d -> u) -> Asst l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Asst l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Asst l -> c (Asst l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Asst l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Asst l -> c (Asst l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Asst l -> c (Asst l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Asst l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Asst l)
    $ctoConstr :: forall l. Data l => Asst l -> Constr
    toConstr :: Asst l -> Constr
    $cdataTypeOf :: forall l. Data l => Asst l -> DataType
    dataTypeOf :: Asst l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Asst l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Asst l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Asst l -> Asst l
    gmapT :: (forall b. Data b => b -> b) -> Asst l -> Asst l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Asst l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Asst l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Asst l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Asst l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Asst l -> m (Asst l)
    Data,(forall m. Monoid m => Asst m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Asst a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Asst a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Asst a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Asst a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Asst a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Asst a -> b)
    -> (forall a. (a -> a -> a) -> Asst a -> a)
    -> (forall a. (a -> a -> a) -> Asst a -> a)
    -> (forall a. Asst a -> [a])
    -> (forall a. Asst a -> Bool)
    -> (forall a. Asst a -> Int)
    -> (forall a. Eq a => a -> Asst a -> Bool)
    -> (forall a. Ord a => Asst a -> a)
    -> (forall a. Ord a => Asst a -> a)
    -> (forall a. Num a => Asst a -> a)
    -> (forall a. Num a => Asst a -> a)
    -> Foldable Asst
    forall a. Eq a => a -> Asst a -> Bool
    forall a. Num a => Asst a -> a
    forall a. Ord a => Asst a -> a
    forall m. Monoid m => Asst m -> m
    forall a. Asst a -> Bool
    forall a. Asst a -> Int
    forall a. Asst a -> [a]
    forall a. (a -> a -> a) -> Asst a -> a
    forall m a. Monoid m => (a -> m) -> Asst a -> m
    forall b a. (b -> a -> b) -> b -> Asst a -> b
    forall a b. (a -> b -> b) -> b -> Asst a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Asst m -> m
    fold :: forall m. Monoid m => Asst m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Asst a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Asst a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Asst a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Asst a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Asst a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Asst a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Asst a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Asst a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Asst a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Asst a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Asst a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Asst a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Asst a -> a
    foldr1 :: forall a. (a -> a -> a) -> Asst a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Asst a -> a
    foldl1 :: forall a. (a -> a -> a) -> Asst a -> a
    $ctoList :: forall a. Asst a -> [a]
    toList :: forall a. Asst a -> [a]
    $cnull :: forall a. Asst a -> Bool
    null :: forall a. Asst a -> Bool
    $clength :: forall a. Asst a -> Int
    length :: forall a. Asst a -> Int
    $celem :: forall a. Eq a => a -> Asst a -> Bool
    elem :: forall a. Eq a => a -> Asst a -> Bool
    $cmaximum :: forall a. Ord a => Asst a -> a
    maximum :: forall a. Ord a => Asst a -> a
    $cminimum :: forall a. Ord a => Asst a -> a
    minimum :: forall a. Ord a => Asst a -> a
    $csum :: forall a. Num a => Asst a -> a
    sum :: forall a. Num a => Asst a -> a
    $cproduct :: forall a. Num a => Asst a -> a
    product :: forall a. Num a => Asst a -> a
    Foldable,Functor Asst
    Foldable Asst
    (Functor Asst, Foldable Asst) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Asst a -> f (Asst b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Asst (f a) -> f (Asst a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Asst a -> m (Asst b))
    -> (forall (m :: * -> *) a. Monad m => Asst (m a) -> m (Asst a))
    -> Traversable Asst
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Asst (m a) -> m (Asst a)
    forall (f :: * -> *) a. Applicative f => Asst (f a) -> f (Asst a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Asst a -> m (Asst b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Asst a -> f (Asst b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Asst a -> f (Asst b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Asst a -> f (Asst b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Asst (f a) -> f (Asst a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Asst (f a) -> f (Asst a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Asst a -> m (Asst b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Asst a -> m (Asst b)
    $csequence :: forall (m :: * -> *) a. Monad m => Asst (m a) -> m (Asst a)
    sequence :: forall (m :: * -> *) a. Monad m => Asst (m a) -> m (Asst a)
    Traversable,(forall a b. (a -> b) -> Asst a -> Asst b)
    -> (forall a b. a -> Asst b -> Asst a) -> Functor Asst
    forall a b. a -> Asst b -> Asst a
    forall a b. (a -> b) -> Asst a -> Asst b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Asst a -> Asst b
    fmap :: forall a b. (a -> b) -> Asst a -> Asst b
    $c<$ :: forall a b. a -> Asst b -> Asst a
    <$ :: forall a b. a -> Asst b -> Asst a
    Functor,(forall x. Asst l -> Rep (Asst l) x)
    -> (forall x. Rep (Asst l) x -> Asst l) -> Generic (Asst l)
    forall x. Rep (Asst l) x -> Asst l
    forall x. Asst l -> Rep (Asst l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Asst l) x -> Asst l
    forall l x. Asst l -> Rep (Asst l) x
    $cfrom :: forall l x. Asst l -> Rep (Asst l) x
    from :: forall x. Asst l -> Rep (Asst l) x
    $cto :: forall l x. Rep (Asst l) x -> Asst l
    to :: forall x. Rep (Asst l) x -> Asst l
    Generic)

    -- | /literal/
    -- Values of this type hold the abstract value of the literal, along with the
    -- precise string representation used.  For example, @10@, @0o12@ and @0xa@
    -- have the same value representation, but each carry a different string representation.
    data Literal l
        = Char       l Char     String     -- ^ character literal
        | String     l String   String     -- ^ string literal
        | Int        l Integer  String     -- ^ integer literal
        | Frac       l Rational String     -- ^ floating point literal
        | PrimInt    l Integer  String     -- ^ unboxed integer literal
        | PrimWord   l Integer  String     -- ^ unboxed word literal
        | PrimFloat  l Rational String     -- ^ unboxed float literal
        | PrimDouble l Rational String     -- ^ unboxed double literal
        | PrimChar   l Char     String     -- ^ unboxed character literal
        | PrimString l String   String     -- ^ unboxed string literal
      deriving (Literal l -> Literal l -> Bool
    (Literal l -> Literal l -> Bool)
    -> (Literal l -> Literal l -> Bool) -> Eq (Literal l)
    forall l. Eq l => Literal l -> Literal l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Literal l -> Literal l -> Bool
    == :: Literal l -> Literal l -> Bool
    $c/= :: forall l. Eq l => Literal l -> Literal l -> Bool
    /= :: Literal l -> Literal l -> Bool
    Eq,Eq (Literal l)
    Eq (Literal l) =>
    (Literal l -> Literal l -> Ordering)
    -> (Literal l -> Literal l -> Bool)
    -> (Literal l -> Literal l -> Bool)
    -> (Literal l -> Literal l -> Bool)
    -> (Literal l -> Literal l -> Bool)
    -> (Literal l -> Literal l -> Literal l)
    -> (Literal l -> Literal l -> Literal l)
    -> Ord (Literal l)
    Literal l -> Literal l -> Bool
    Literal l -> Literal l -> Ordering
    Literal l -> Literal l -> Literal l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Literal l)
    forall l. Ord l => Literal l -> Literal l -> Bool
    forall l. Ord l => Literal l -> Literal l -> Ordering
    forall l. Ord l => Literal l -> Literal l -> Literal l
    $ccompare :: forall l. Ord l => Literal l -> Literal l -> Ordering
    compare :: Literal l -> Literal l -> Ordering
    $c< :: forall l. Ord l => Literal l -> Literal l -> Bool
    < :: Literal l -> Literal l -> Bool
    $c<= :: forall l. Ord l => Literal l -> Literal l -> Bool
    <= :: Literal l -> Literal l -> Bool
    $c> :: forall l. Ord l => Literal l -> Literal l -> Bool
    > :: Literal l -> Literal l -> Bool
    $c>= :: forall l. Ord l => Literal l -> Literal l -> Bool
    >= :: Literal l -> Literal l -> Bool
    $cmax :: forall l. Ord l => Literal l -> Literal l -> Literal l
    max :: Literal l -> Literal l -> Literal l
    $cmin :: forall l. Ord l => Literal l -> Literal l -> Literal l
    min :: Literal l -> Literal l -> Literal l
    Ord,Int -> Literal l -> ShowS
    [Literal l] -> ShowS
    Literal l -> String
    (Int -> Literal l -> ShowS)
    -> (Literal l -> String)
    -> ([Literal l] -> ShowS)
    -> Show (Literal l)
    forall l. Show l => Int -> Literal l -> ShowS
    forall l. Show l => [Literal l] -> ShowS
    forall l. Show l => Literal l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Literal l -> ShowS
    showsPrec :: Int -> Literal l -> ShowS
    $cshow :: forall l. Show l => Literal l -> String
    show :: Literal l -> String
    $cshowList :: forall l. Show l => [Literal l] -> ShowS
    showList :: [Literal l] -> ShowS
    Show,Typeable,Typeable (Literal l)
    Typeable (Literal l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Literal l -> c (Literal l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Literal l))
    -> (Literal l -> Constr)
    -> (Literal l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Literal l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Literal l)))
    -> ((forall b. Data b => b -> b) -> Literal l -> Literal l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Literal l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Literal l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Literal l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Literal l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Literal l -> m (Literal l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Literal l -> m (Literal l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Literal l -> m (Literal l))
    -> Data (Literal l)
    Literal l -> Constr
    Literal l -> DataType
    (forall b. Data b => b -> b) -> Literal l -> Literal l
    forall l. Data l => Typeable (Literal l)
    forall l. Data l => Literal l -> Constr
    forall l. Data l => Literal l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Literal l -> Literal l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Literal l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Literal l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Literal l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal l -> c (Literal l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Literal l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Literal l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Literal l -> u
    forall u. (forall d. Data d => d -> u) -> Literal l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Literal l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal l -> c (Literal l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Literal l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Literal l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal l -> c (Literal l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal l -> c (Literal l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Literal l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Literal l)
    $ctoConstr :: forall l. Data l => Literal l -> Constr
    toConstr :: Literal l -> Constr
    $cdataTypeOf :: forall l. Data l => Literal l -> DataType
    dataTypeOf :: Literal l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Literal l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Literal l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Literal l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Literal l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Literal l -> Literal l
    gmapT :: (forall b. Data b => b -> b) -> Literal l -> Literal l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Literal l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Literal l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Literal l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal l -> m (Literal l)
    Data,(forall m. Monoid m => Literal m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Literal a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Literal a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Literal a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Literal a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Literal a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Literal a -> b)
    -> (forall a. (a -> a -> a) -> Literal a -> a)
    -> (forall a. (a -> a -> a) -> Literal a -> a)
    -> (forall a. Literal a -> [a])
    -> (forall a. Literal a -> Bool)
    -> (forall a. Literal a -> Int)
    -> (forall a. Eq a => a -> Literal a -> Bool)
    -> (forall a. Ord a => Literal a -> a)
    -> (forall a. Ord a => Literal a -> a)
    -> (forall a. Num a => Literal a -> a)
    -> (forall a. Num a => Literal a -> a)
    -> Foldable Literal
    forall a. Eq a => a -> Literal a -> Bool
    forall a. Num a => Literal a -> a
    forall a. Ord a => Literal a -> a
    forall m. Monoid m => Literal m -> m
    forall a. Literal a -> Bool
    forall a. Literal a -> Int
    forall a. Literal a -> [a]
    forall a. (a -> a -> a) -> Literal a -> a
    forall m a. Monoid m => (a -> m) -> Literal a -> m
    forall b a. (b -> a -> b) -> b -> Literal a -> b
    forall a b. (a -> b -> b) -> b -> Literal a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Literal m -> m
    fold :: forall m. Monoid m => Literal m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Literal a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Literal a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Literal a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Literal a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Literal a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Literal a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Literal a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Literal a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Literal a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Literal a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Literal a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Literal a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Literal a -> a
    foldr1 :: forall a. (a -> a -> a) -> Literal a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Literal a -> a
    foldl1 :: forall a. (a -> a -> a) -> Literal a -> a
    $ctoList :: forall a. Literal a -> [a]
    toList :: forall a. Literal a -> [a]
    $cnull :: forall a. Literal a -> Bool
    null :: forall a. Literal a -> Bool
    $clength :: forall a. Literal a -> Int
    length :: forall a. Literal a -> Int
    $celem :: forall a. Eq a => a -> Literal a -> Bool
    elem :: forall a. Eq a => a -> Literal a -> Bool
    $cmaximum :: forall a. Ord a => Literal a -> a
    maximum :: forall a. Ord a => Literal a -> a
    $cminimum :: forall a. Ord a => Literal a -> a
    minimum :: forall a. Ord a => Literal a -> a
    $csum :: forall a. Num a => Literal a -> a
    sum :: forall a. Num a => Literal a -> a
    $cproduct :: forall a. Num a => Literal a -> a
    product :: forall a. Num a => Literal a -> a
    Foldable,Functor Literal
    Foldable Literal
    (Functor Literal, Foldable Literal) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Literal a -> f (Literal b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Literal (f a) -> f (Literal a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Literal a -> m (Literal b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Literal (m a) -> m (Literal a))
    -> Traversable Literal
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Literal (m a) -> m (Literal a)
    forall (f :: * -> *) a.
    Applicative f =>
    Literal (f a) -> f (Literal a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Literal a -> m (Literal b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Literal a -> f (Literal b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Literal a -> f (Literal b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Literal a -> f (Literal b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Literal (f a) -> f (Literal a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Literal (f a) -> f (Literal a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Literal a -> m (Literal b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Literal a -> m (Literal b)
    $csequence :: forall (m :: * -> *) a. Monad m => Literal (m a) -> m (Literal a)
    sequence :: forall (m :: * -> *) a. Monad m => Literal (m a) -> m (Literal a)
    Traversable,(forall a b. (a -> b) -> Literal a -> Literal b)
    -> (forall a b. a -> Literal b -> Literal a) -> Functor Literal
    forall a b. a -> Literal b -> Literal a
    forall a b. (a -> b) -> Literal a -> Literal b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Literal a -> Literal b
    fmap :: forall a b. (a -> b) -> Literal a -> Literal b
    $c<$ :: forall a b. a -> Literal b -> Literal a
    <$ :: forall a b. a -> Literal b -> Literal a
    Functor,(forall x. Literal l -> Rep (Literal l) x)
    -> (forall x. Rep (Literal l) x -> Literal l)
    -> Generic (Literal l)
    forall x. Rep (Literal l) x -> Literal l
    forall x. Literal l -> Rep (Literal l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Literal l) x -> Literal l
    forall l x. Literal l -> Rep (Literal l) x
    $cfrom :: forall l x. Literal l -> Rep (Literal l) x
    from :: forall x. Literal l -> Rep (Literal l) x
    $cto :: forall l x. Rep (Literal l) x -> Literal l
    to :: forall x. Rep (Literal l) x -> Literal l
    Generic)

    -- | An indication whether a literal pattern has been negated or not.
    data Sign l
        = Signless l
        | Negative l
      deriving (Sign l -> Sign l -> Bool
    (Sign l -> Sign l -> Bool)
    -> (Sign l -> Sign l -> Bool) -> Eq (Sign l)
    forall l. Eq l => Sign l -> Sign l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Sign l -> Sign l -> Bool
    == :: Sign l -> Sign l -> Bool
    $c/= :: forall l. Eq l => Sign l -> Sign l -> Bool
    /= :: Sign l -> Sign l -> Bool
    Eq,Eq (Sign l)
    Eq (Sign l) =>
    (Sign l -> Sign l -> Ordering)
    -> (Sign l -> Sign l -> Bool)
    -> (Sign l -> Sign l -> Bool)
    -> (Sign l -> Sign l -> Bool)
    -> (Sign l -> Sign l -> Bool)
    -> (Sign l -> Sign l -> Sign l)
    -> (Sign l -> Sign l -> Sign l)
    -> Ord (Sign l)
    Sign l -> Sign l -> Bool
    Sign l -> Sign l -> Ordering
    Sign l -> Sign l -> Sign l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Sign l)
    forall l. Ord l => Sign l -> Sign l -> Bool
    forall l. Ord l => Sign l -> Sign l -> Ordering
    forall l. Ord l => Sign l -> Sign l -> Sign l
    $ccompare :: forall l. Ord l => Sign l -> Sign l -> Ordering
    compare :: Sign l -> Sign l -> Ordering
    $c< :: forall l. Ord l => Sign l -> Sign l -> Bool
    < :: Sign l -> Sign l -> Bool
    $c<= :: forall l. Ord l => Sign l -> Sign l -> Bool
    <= :: Sign l -> Sign l -> Bool
    $c> :: forall l. Ord l => Sign l -> Sign l -> Bool
    > :: Sign l -> Sign l -> Bool
    $c>= :: forall l. Ord l => Sign l -> Sign l -> Bool
    >= :: Sign l -> Sign l -> Bool
    $cmax :: forall l. Ord l => Sign l -> Sign l -> Sign l
    max :: Sign l -> Sign l -> Sign l
    $cmin :: forall l. Ord l => Sign l -> Sign l -> Sign l
    min :: Sign l -> Sign l -> Sign l
    Ord,Int -> Sign l -> ShowS
    [Sign l] -> ShowS
    Sign l -> String
    (Int -> Sign l -> ShowS)
    -> (Sign l -> String) -> ([Sign l] -> ShowS) -> Show (Sign l)
    forall l. Show l => Int -> Sign l -> ShowS
    forall l. Show l => [Sign l] -> ShowS
    forall l. Show l => Sign l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Sign l -> ShowS
    showsPrec :: Int -> Sign l -> ShowS
    $cshow :: forall l. Show l => Sign l -> String
    show :: Sign l -> String
    $cshowList :: forall l. Show l => [Sign l] -> ShowS
    showList :: [Sign l] -> ShowS
    Show,Typeable,Typeable (Sign l)
    Typeable (Sign l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Sign l -> c (Sign l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Sign l))
    -> (Sign l -> Constr)
    -> (Sign l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Sign l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l)))
    -> ((forall b. Data b => b -> b) -> Sign l -> Sign l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Sign l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Sign l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Sign l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Sign l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Sign l -> m (Sign l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Sign l -> m (Sign l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Sign l -> m (Sign l))
    -> Data (Sign l)
    Sign l -> Constr
    Sign l -> DataType
    (forall b. Data b => b -> b) -> Sign l -> Sign l
    forall l. Data l => Typeable (Sign l)
    forall l. Data l => Sign l -> Constr
    forall l. Data l => Sign l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Sign l -> Sign l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Sign l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Sign l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Sign l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Sign l -> c (Sign l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Sign l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Sign l -> u
    forall u. (forall d. Data d => d -> u) -> Sign l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Sign l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Sign l -> c (Sign l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Sign l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Sign l -> c (Sign l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Sign l -> c (Sign l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Sign l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Sign l)
    $ctoConstr :: forall l. Data l => Sign l -> Constr
    toConstr :: Sign l -> Constr
    $cdataTypeOf :: forall l. Data l => Sign l -> DataType
    dataTypeOf :: Sign l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Sign l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Sign l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Sign l -> Sign l
    gmapT :: (forall b. Data b => b -> b) -> Sign l -> Sign l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Sign l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Sign l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Sign l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign l -> m (Sign l)
    Data,(forall m. Monoid m => Sign m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Sign a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Sign a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Sign a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Sign a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Sign a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Sign a -> b)
    -> (forall a. (a -> a -> a) -> Sign a -> a)
    -> (forall a. (a -> a -> a) -> Sign a -> a)
    -> (forall a. Sign a -> [a])
    -> (forall a. Sign a -> Bool)
    -> (forall a. Sign a -> Int)
    -> (forall a. Eq a => a -> Sign a -> Bool)
    -> (forall a. Ord a => Sign a -> a)
    -> (forall a. Ord a => Sign a -> a)
    -> (forall a. Num a => Sign a -> a)
    -> (forall a. Num a => Sign a -> a)
    -> Foldable Sign
    forall a. Eq a => a -> Sign a -> Bool
    forall a. Num a => Sign a -> a
    forall a. Ord a => Sign a -> a
    forall m. Monoid m => Sign m -> m
    forall a. Sign a -> Bool
    forall a. Sign a -> Int
    forall a. Sign a -> [a]
    forall a. (a -> a -> a) -> Sign a -> a
    forall m a. Monoid m => (a -> m) -> Sign a -> m
    forall b a. (b -> a -> b) -> b -> Sign a -> b
    forall a b. (a -> b -> b) -> b -> Sign a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Sign m -> m
    fold :: forall m. Monoid m => Sign m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Sign a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Sign a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Sign a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Sign a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Sign a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Sign a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Sign a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Sign a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Sign a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Sign a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Sign a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Sign a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Sign a -> a
    foldr1 :: forall a. (a -> a -> a) -> Sign a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Sign a -> a
    foldl1 :: forall a. (a -> a -> a) -> Sign a -> a
    $ctoList :: forall a. Sign a -> [a]
    toList :: forall a. Sign a -> [a]
    $cnull :: forall a. Sign a -> Bool
    null :: forall a. Sign a -> Bool
    $clength :: forall a. Sign a -> Int
    length :: forall a. Sign a -> Int
    $celem :: forall a. Eq a => a -> Sign a -> Bool
    elem :: forall a. Eq a => a -> Sign a -> Bool
    $cmaximum :: forall a. Ord a => Sign a -> a
    maximum :: forall a. Ord a => Sign a -> a
    $cminimum :: forall a. Ord a => Sign a -> a
    minimum :: forall a. Ord a => Sign a -> a
    $csum :: forall a. Num a => Sign a -> a
    sum :: forall a. Num a => Sign a -> a
    $cproduct :: forall a. Num a => Sign a -> a
    product :: forall a. Num a => Sign a -> a
    Foldable,Functor Sign
    Foldable Sign
    (Functor Sign, Foldable Sign) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Sign a -> f (Sign b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Sign (f a) -> f (Sign a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Sign a -> m (Sign b))
    -> (forall (m :: * -> *) a. Monad m => Sign (m a) -> m (Sign a))
    -> Traversable Sign
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Sign (m a) -> m (Sign a)
    forall (f :: * -> *) a. Applicative f => Sign (f a) -> f (Sign a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Sign a -> m (Sign b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Sign a -> f (Sign b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Sign a -> f (Sign b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Sign a -> f (Sign b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Sign (f a) -> f (Sign a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Sign (f a) -> f (Sign a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Sign a -> m (Sign b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Sign a -> m (Sign b)
    $csequence :: forall (m :: * -> *) a. Monad m => Sign (m a) -> m (Sign a)
    sequence :: forall (m :: * -> *) a. Monad m => Sign (m a) -> m (Sign a)
    Traversable,(forall a b. (a -> b) -> Sign a -> Sign b)
    -> (forall a b. a -> Sign b -> Sign a) -> Functor Sign
    forall a b. a -> Sign b -> Sign a
    forall a b. (a -> b) -> Sign a -> Sign b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Sign a -> Sign b
    fmap :: forall a b. (a -> b) -> Sign a -> Sign b
    $c<$ :: forall a b. a -> Sign b -> Sign a
    <$ :: forall a b. a -> Sign b -> Sign a
    Functor,(forall x. Sign l -> Rep (Sign l) x)
    -> (forall x. Rep (Sign l) x -> Sign l) -> Generic (Sign l)
    forall x. Rep (Sign l) x -> Sign l
    forall x. Sign l -> Rep (Sign l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Sign l) x -> Sign l
    forall l x. Sign l -> Rep (Sign l) x
    $cfrom :: forall l x. Sign l -> Rep (Sign l) x
    from :: forall x. Sign l -> Rep (Sign l) x
    $cto :: forall l x. Rep (Sign l) x -> Sign l
    to :: forall x. Rep (Sign l) x -> Sign l
    Generic)

    -- | Haskell expressions.
    data Exp l
        = Var l (QName l)                       -- ^ variable
        | OverloadedLabel l String              -- ^ Overloaded label #foo
        | IPVar l (IPName l)                    -- ^ implicit parameter variable
        | Con l (QName l)                       -- ^ data constructor
        | Lit l (Literal l)                     -- ^ literal constant
        | InfixApp l (Exp l) (QOp l) (Exp l)    -- ^ infix application
        | App l (Exp l) (Exp l)                 -- ^ ordinary application
        | NegApp l (Exp l)                      -- ^ negation expression @-/exp/@ (unary minus)
        | Lambda l [Pat l] (Exp l)              -- ^ lambda expression
        | Let l (Binds l) (Exp l)               -- ^ local declarations with @let@ ... @in@ ...
        | If l (Exp l) (Exp l) (Exp l)          -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/
        | MultiIf l [GuardedRhs l]              -- ^ @if@ @|@ /stmts/ @->@ /exp/ ...
        | Case l (Exp l) [Alt l]                -- ^ @case@ /exp/ @of@ /alts/
        | Do l [Stmt l]                         -- ^ @do@-expression:
                                                --   the last statement in the list
                                                --   should be an expression.
        | MDo l [Stmt l]                        -- ^ @mdo@-expression
        | Tuple l Boxed [Exp l]                 -- ^ tuple expression
        | UnboxedSum l Int Int (Exp l)          -- ^ unboxed sum
        | TupleSection l Boxed [Maybe (Exp l)]  -- ^ tuple section expression, e.g. @(,,3)@
        | List l [Exp l]                        -- ^ list expression
        | ParArray l [Exp l]                    -- ^ parallel array expression
        | Paren l (Exp l)                       -- ^ parenthesised expression
        | LeftSection l (Exp l) (QOp l)         -- ^ left section @(@/exp/ /qop/@)@
        | RightSection l (QOp l) (Exp l)        -- ^ right section @(@/qop/ /exp/@)@
        | RecConstr l (QName l) [FieldUpdate l] -- ^ record construction expression
        | RecUpdate l (Exp l)   [FieldUpdate l] -- ^ record update expression
        | EnumFrom l (Exp l)                    -- ^ unbounded arithmetic sequence,
                                                --   incrementing by 1: @[from ..]@
        | EnumFromTo l (Exp l) (Exp l)          -- ^ bounded arithmetic sequence,
                                                --   incrementing by 1 @[from .. to]@
        | EnumFromThen l (Exp l) (Exp l)        -- ^ unbounded arithmetic sequence,
                                                --   with first two elements given @[from, then ..]@
        | EnumFromThenTo l (Exp l) (Exp l) (Exp l)
                                                -- ^ bounded arithmetic sequence,
                                                --   with first two elements given @[from, then .. to]@
        | ParArrayFromTo l (Exp l) (Exp l)      -- ^ Parallel array bounded arithmetic sequence,
                                                --   incrementing by 1 @[:from .. to:]@
        | ParArrayFromThenTo l (Exp l) (Exp l) (Exp l)
                                                -- ^ bounded arithmetic sequence,
                                                --   with first two elements given @[:from, then .. to:]@
        | ListComp l (Exp l) [QualStmt l]       -- ^ ordinary list comprehension
        | ParComp  l (Exp l) [[QualStmt l]]     -- ^ parallel list comprehension
        | ParArrayComp  l (Exp l) [[QualStmt l]] -- ^ parallel array comprehension
        | ExpTypeSig l (Exp l) (Type l)         -- ^ expression with explicit type signature

        | VarQuote l (QName l)                  -- ^ @'x@ for template haskell reifying of expressions
        | TypQuote l (QName l)                  -- ^ @''T@ for template haskell reifying of types
        | BracketExp l (Bracket l)              -- ^ template haskell bracket expression
        | SpliceExp l (Splice l)                -- ^ template haskell splice expression
        | QuasiQuote l String String            -- ^ quasi-quotaion: @[$/name/| /string/ |]@
        | TypeApp l (Type l)                    -- ^ Visible type application

    -- Hsx
        | XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
                                                -- ^ xml element, with attributes and children
        | XETag l (XName l) [XAttr l] (Maybe (Exp l))
                                                -- ^ empty xml element, with attributes
        | XPcdata l String                      -- ^ PCDATA child element
        | XExpTag l (Exp l)                     -- ^ escaped haskell expression inside xml
        | XChildTag l [Exp l]                   -- ^ children of an xml element

    -- Pragmas
        | CorePragma l      String (Exp l)      -- ^ CORE pragma
        | SCCPragma  l      String (Exp l)      -- ^ SCC pragma
        | GenPragma  l      String (Int, Int) (Int, Int) (Exp l)
                                                -- ^ GENERATED pragma

    -- Arrows
        | Proc            l (Pat l) (Exp l)     -- ^ arrows proc: @proc@ /pat/ @->@ /exp/
        | LeftArrApp      l (Exp l) (Exp l)     -- ^ arrow application (from left): /exp/ @-<@ /exp/
        | RightArrApp     l (Exp l) (Exp l)     -- ^ arrow application (from right): /exp/ @>-@ /exp/
        | LeftArrHighApp  l (Exp l) (Exp l)     -- ^ higher-order arrow application (from left): /exp/ @-<<@ /exp/
        | RightArrHighApp l (Exp l) (Exp l)     -- ^ higher-order arrow application (from right): /exp/ @>>-@ /exp/
        | ArrOp           l (Exp l)             -- ^ arrow control operators: @(| /exp/ |)@

    -- LambdaCase
        | LCase l [Alt l]                       -- ^ @\case@ /alts/

      deriving (Exp l -> Exp l -> Bool
    (Exp l -> Exp l -> Bool) -> (Exp l -> Exp l -> Bool) -> Eq (Exp l)
    forall l. Eq l => Exp l -> Exp l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Exp l -> Exp l -> Bool
    == :: Exp l -> Exp l -> Bool
    $c/= :: forall l. Eq l => Exp l -> Exp l -> Bool
    /= :: Exp l -> Exp l -> Bool
    Eq,Eq (Exp l)
    Eq (Exp l) =>
    (Exp l -> Exp l -> Ordering)
    -> (Exp l -> Exp l -> Bool)
    -> (Exp l -> Exp l -> Bool)
    -> (Exp l -> Exp l -> Bool)
    -> (Exp l -> Exp l -> Bool)
    -> (Exp l -> Exp l -> Exp l)
    -> (Exp l -> Exp l -> Exp l)
    -> Ord (Exp l)
    Exp l -> Exp l -> Bool
    Exp l -> Exp l -> Ordering
    Exp l -> Exp l -> Exp l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Exp l)
    forall l. Ord l => Exp l -> Exp l -> Bool
    forall l. Ord l => Exp l -> Exp l -> Ordering
    forall l. Ord l => Exp l -> Exp l -> Exp l
    $ccompare :: forall l. Ord l => Exp l -> Exp l -> Ordering
    compare :: Exp l -> Exp l -> Ordering
    $c< :: forall l. Ord l => Exp l -> Exp l -> Bool
    < :: Exp l -> Exp l -> Bool
    $c<= :: forall l. Ord l => Exp l -> Exp l -> Bool
    <= :: Exp l -> Exp l -> Bool
    $c> :: forall l. Ord l => Exp l -> Exp l -> Bool
    > :: Exp l -> Exp l -> Bool
    $c>= :: forall l. Ord l => Exp l -> Exp l -> Bool
    >= :: Exp l -> Exp l -> Bool
    $cmax :: forall l. Ord l => Exp l -> Exp l -> Exp l
    max :: Exp l -> Exp l -> Exp l
    $cmin :: forall l. Ord l => Exp l -> Exp l -> Exp l
    min :: Exp l -> Exp l -> Exp l
    Ord,Int -> Exp l -> ShowS
    [Exp l] -> ShowS
    Exp l -> String
    (Int -> Exp l -> ShowS)
    -> (Exp l -> String) -> ([Exp l] -> ShowS) -> Show (Exp l)
    forall l. Show l => Int -> Exp l -> ShowS
    forall l. Show l => [Exp l] -> ShowS
    forall l. Show l => Exp l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Exp l -> ShowS
    showsPrec :: Int -> Exp l -> ShowS
    $cshow :: forall l. Show l => Exp l -> String
    show :: Exp l -> String
    $cshowList :: forall l. Show l => [Exp l] -> ShowS
    showList :: [Exp l] -> ShowS
    Show,Typeable,Typeable (Exp l)
    Typeable (Exp l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Exp l -> c (Exp l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Exp l))
    -> (Exp l -> Constr)
    -> (Exp l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Exp l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l)))
    -> ((forall b. Data b => b -> b) -> Exp l -> Exp l)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Exp l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Exp l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Exp l -> m (Exp l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Exp l -> m (Exp l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Exp l -> m (Exp l))
    -> Data (Exp l)
    Exp l -> Constr
    Exp l -> DataType
    (forall b. Data b => b -> b) -> Exp l -> Exp l
    forall l. Data l => Typeable (Exp l)
    forall l. Data l => Exp l -> Constr
    forall l. Data l => Exp l -> DataType
    forall l. Data l => (forall b. Data b => b -> b) -> Exp l -> Exp l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Exp l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Exp l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Exp l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Exp l -> c (Exp l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Exp l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Exp l -> u
    forall u. (forall d. Data d => d -> u) -> Exp l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Exp l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Exp l -> c (Exp l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Exp l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Exp l -> c (Exp l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Exp l -> c (Exp l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Exp l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Exp l)
    $ctoConstr :: forall l. Data l => Exp l -> Constr
    toConstr :: Exp l -> Constr
    $cdataTypeOf :: forall l. Data l => Exp l -> DataType
    dataTypeOf :: Exp l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Exp l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Exp l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l))
    $cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Exp l -> Exp l
    gmapT :: (forall b. Data b => b -> b) -> Exp l -> Exp l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Exp l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Exp l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Exp l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
    Data,(forall m. Monoid m => Exp m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Exp a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Exp a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Exp a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Exp a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Exp a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Exp a -> b)
    -> (forall a. (a -> a -> a) -> Exp a -> a)
    -> (forall a. (a -> a -> a) -> Exp a -> a)
    -> (forall a. Exp a -> [a])
    -> (forall a. Exp a -> Bool)
    -> (forall a. Exp a -> Int)
    -> (forall a. Eq a => a -> Exp a -> Bool)
    -> (forall a. Ord a => Exp a -> a)
    -> (forall a. Ord a => Exp a -> a)
    -> (forall a. Num a => Exp a -> a)
    -> (forall a. Num a => Exp a -> a)
    -> Foldable Exp
    forall a. Eq a => a -> Exp a -> Bool
    forall a. Num a => Exp a -> a
    forall a. Ord a => Exp a -> a
    forall m. Monoid m => Exp m -> m
    forall a. Exp a -> Bool
    forall a. Exp a -> Int
    forall a. Exp a -> [a]
    forall a. (a -> a -> a) -> Exp a -> a
    forall m a. Monoid m => (a -> m) -> Exp a -> m
    forall b a. (b -> a -> b) -> b -> Exp a -> b
    forall a b. (a -> b -> b) -> b -> Exp a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Exp m -> m
    fold :: forall m. Monoid m => Exp m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Exp a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Exp a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Exp a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Exp a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Exp a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Exp a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Exp a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Exp a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Exp a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Exp a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Exp a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Exp a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Exp a -> a
    foldr1 :: forall a. (a -> a -> a) -> Exp a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Exp a -> a
    foldl1 :: forall a. (a -> a -> a) -> Exp a -> a
    $ctoList :: forall a. Exp a -> [a]
    toList :: forall a. Exp a -> [a]
    $cnull :: forall a. Exp a -> Bool
    null :: forall a. Exp a -> Bool
    $clength :: forall a. Exp a -> Int
    length :: forall a. Exp a -> Int
    $celem :: forall a. Eq a => a -> Exp a -> Bool
    elem :: forall a. Eq a => a -> Exp a -> Bool
    $cmaximum :: forall a. Ord a => Exp a -> a
    maximum :: forall a. Ord a => Exp a -> a
    $cminimum :: forall a. Ord a => Exp a -> a
    minimum :: forall a. Ord a => Exp a -> a
    $csum :: forall a. Num a => Exp a -> a
    sum :: forall a. Num a => Exp a -> a
    $cproduct :: forall a. Num a => Exp a -> a
    product :: forall a. Num a => Exp a -> a
    Foldable,Functor Exp
    Foldable Exp
    (Functor Exp, Foldable Exp) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Exp a -> f (Exp b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Exp (f a) -> f (Exp a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Exp a -> m (Exp b))
    -> (forall (m :: * -> *) a. Monad m => Exp (m a) -> m (Exp a))
    -> Traversable Exp
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Exp (m a) -> m (Exp a)
    forall (f :: * -> *) a. Applicative f => Exp (f a) -> f (Exp a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Exp a -> m (Exp b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Exp a -> f (Exp b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Exp a -> f (Exp b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Exp a -> f (Exp b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Exp (f a) -> f (Exp a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Exp (f a) -> f (Exp a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Exp a -> m (Exp b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Exp a -> m (Exp b)
    $csequence :: forall (m :: * -> *) a. Monad m => Exp (m a) -> m (Exp a)
    sequence :: forall (m :: * -> *) a. Monad m => Exp (m a) -> m (Exp a)
    Traversable,(forall a b. (a -> b) -> Exp a -> Exp b)
    -> (forall a b. a -> Exp b -> Exp a) -> Functor Exp
    forall a b. a -> Exp b -> Exp a
    forall a b. (a -> b) -> Exp a -> Exp b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Exp a -> Exp b
    fmap :: forall a b. (a -> b) -> Exp a -> Exp b
    $c<$ :: forall a b. a -> Exp b -> Exp a
    <$ :: forall a b. a -> Exp b -> Exp a
    Functor,(forall x. Exp l -> Rep (Exp l) x)
    -> (forall x. Rep (Exp l) x -> Exp l) -> Generic (Exp l)
    forall x. Rep (Exp l) x -> Exp l
    forall x. Exp l -> Rep (Exp l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Exp l) x -> Exp l
    forall l x. Exp l -> Rep (Exp l) x
    $cfrom :: forall l x. Exp l -> Rep (Exp l) x
    from :: forall x. Exp l -> Rep (Exp l) x
    $cto :: forall l x. Rep (Exp l) x -> Exp l
    to :: forall x. Rep (Exp l) x -> Exp l
    Generic)

    -- | The name of an xml element or attribute,
    --   possibly qualified with a namespace.
    data XName l
        = XName l String              -- <name ...
        | XDomName l String String    -- <dom:name ...
      deriving (XName l -> XName l -> Bool
    (XName l -> XName l -> Bool)
    -> (XName l -> XName l -> Bool) -> Eq (XName l)
    forall l. Eq l => XName l -> XName l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => XName l -> XName l -> Bool
    == :: XName l -> XName l -> Bool
    $c/= :: forall l. Eq l => XName l -> XName l -> Bool
    /= :: XName l -> XName l -> Bool
    Eq,Eq (XName l)
    Eq (XName l) =>
    (XName l -> XName l -> Ordering)
    -> (XName l -> XName l -> Bool)
    -> (XName l -> XName l -> Bool)
    -> (XName l -> XName l -> Bool)
    -> (XName l -> XName l -> Bool)
    -> (XName l -> XName l -> XName l)
    -> (XName l -> XName l -> XName l)
    -> Ord (XName l)
    XName l -> XName l -> Bool
    XName l -> XName l -> Ordering
    XName l -> XName l -> XName l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (XName l)
    forall l. Ord l => XName l -> XName l -> Bool
    forall l. Ord l => XName l -> XName l -> Ordering
    forall l. Ord l => XName l -> XName l -> XName l
    $ccompare :: forall l. Ord l => XName l -> XName l -> Ordering
    compare :: XName l -> XName l -> Ordering
    $c< :: forall l. Ord l => XName l -> XName l -> Bool
    < :: XName l -> XName l -> Bool
    $c<= :: forall l. Ord l => XName l -> XName l -> Bool
    <= :: XName l -> XName l -> Bool
    $c> :: forall l. Ord l => XName l -> XName l -> Bool
    > :: XName l -> XName l -> Bool
    $c>= :: forall l. Ord l => XName l -> XName l -> Bool
    >= :: XName l -> XName l -> Bool
    $cmax :: forall l. Ord l => XName l -> XName l -> XName l
    max :: XName l -> XName l -> XName l
    $cmin :: forall l. Ord l => XName l -> XName l -> XName l
    min :: XName l -> XName l -> XName l
    Ord,Int -> XName l -> ShowS
    [XName l] -> ShowS
    XName l -> String
    (Int -> XName l -> ShowS)
    -> (XName l -> String) -> ([XName l] -> ShowS) -> Show (XName l)
    forall l. Show l => Int -> XName l -> ShowS
    forall l. Show l => [XName l] -> ShowS
    forall l. Show l => XName l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> XName l -> ShowS
    showsPrec :: Int -> XName l -> ShowS
    $cshow :: forall l. Show l => XName l -> String
    show :: XName l -> String
    $cshowList :: forall l. Show l => [XName l] -> ShowS
    showList :: [XName l] -> ShowS
    Show,Typeable,Typeable (XName l)
    Typeable (XName l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> XName l -> c (XName l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (XName l))
    -> (XName l -> Constr)
    -> (XName l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (XName l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l)))
    -> ((forall b. Data b => b -> b) -> XName l -> XName l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> XName l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> XName l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> XName l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> XName l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> XName l -> m (XName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> XName l -> m (XName l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> XName l -> m (XName l))
    -> Data (XName l)
    XName l -> Constr
    XName l -> DataType
    (forall b. Data b => b -> b) -> XName l -> XName l
    forall l. Data l => Typeable (XName l)
    forall l. Data l => XName l -> Constr
    forall l. Data l => XName l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> XName l -> XName l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> XName l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> XName l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XName l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> XName l -> c (XName l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (XName l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> XName l -> u
    forall u. (forall d. Data d => d -> u) -> XName l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XName l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> XName l -> c (XName l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (XName l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> XName l -> c (XName l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> XName l -> c (XName l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XName l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XName l)
    $ctoConstr :: forall l. Data l => XName l -> Constr
    toConstr :: XName l -> Constr
    $cdataTypeOf :: forall l. Data l => XName l -> DataType
    dataTypeOf :: XName l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (XName l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (XName l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> XName l -> XName l
    gmapT :: (forall b. Data b => b -> b) -> XName l -> XName l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XName l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> XName l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> XName l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> XName l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> XName l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XName l -> m (XName l)
    Data,(forall m. Monoid m => XName m -> m)
    -> (forall m a. Monoid m => (a -> m) -> XName a -> m)
    -> (forall m a. Monoid m => (a -> m) -> XName a -> m)
    -> (forall a b. (a -> b -> b) -> b -> XName a -> b)
    -> (forall a b. (a -> b -> b) -> b -> XName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> XName a -> b)
    -> (forall b a. (b -> a -> b) -> b -> XName a -> b)
    -> (forall a. (a -> a -> a) -> XName a -> a)
    -> (forall a. (a -> a -> a) -> XName a -> a)
    -> (forall a. XName a -> [a])
    -> (forall a. XName a -> Bool)
    -> (forall a. XName a -> Int)
    -> (forall a. Eq a => a -> XName a -> Bool)
    -> (forall a. Ord a => XName a -> a)
    -> (forall a. Ord a => XName a -> a)
    -> (forall a. Num a => XName a -> a)
    -> (forall a. Num a => XName a -> a)
    -> Foldable XName
    forall a. Eq a => a -> XName a -> Bool
    forall a. Num a => XName a -> a
    forall a. Ord a => XName a -> a
    forall m. Monoid m => XName m -> m
    forall a. XName a -> Bool
    forall a. XName a -> Int
    forall a. XName a -> [a]
    forall a. (a -> a -> a) -> XName a -> a
    forall m a. Monoid m => (a -> m) -> XName a -> m
    forall b a. (b -> a -> b) -> b -> XName a -> b
    forall a b. (a -> b -> b) -> b -> XName a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => XName m -> m
    fold :: forall m. Monoid m => XName m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> XName a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> XName a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> XName a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> XName a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> XName a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> XName a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> XName a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> XName a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> XName a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> XName a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> XName a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> XName a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> XName a -> a
    foldr1 :: forall a. (a -> a -> a) -> XName a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> XName a -> a
    foldl1 :: forall a. (a -> a -> a) -> XName a -> a
    $ctoList :: forall a. XName a -> [a]
    toList :: forall a. XName a -> [a]
    $cnull :: forall a. XName a -> Bool
    null :: forall a. XName a -> Bool
    $clength :: forall a. XName a -> Int
    length :: forall a. XName a -> Int
    $celem :: forall a. Eq a => a -> XName a -> Bool
    elem :: forall a. Eq a => a -> XName a -> Bool
    $cmaximum :: forall a. Ord a => XName a -> a
    maximum :: forall a. Ord a => XName a -> a
    $cminimum :: forall a. Ord a => XName a -> a
    minimum :: forall a. Ord a => XName a -> a
    $csum :: forall a. Num a => XName a -> a
    sum :: forall a. Num a => XName a -> a
    $cproduct :: forall a. Num a => XName a -> a
    product :: forall a. Num a => XName a -> a
    Foldable,Functor XName
    Foldable XName
    (Functor XName, Foldable XName) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> XName a -> f (XName b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        XName (f a) -> f (XName a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> XName a -> m (XName b))
    -> (forall (m :: * -> *) a. Monad m => XName (m a) -> m (XName a))
    -> Traversable XName
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => XName (m a) -> m (XName a)
    forall (f :: * -> *) a. Applicative f => XName (f a) -> f (XName a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> XName a -> m (XName b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> XName a -> f (XName b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> XName a -> f (XName b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> XName a -> f (XName b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => XName (f a) -> f (XName a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => XName (f a) -> f (XName a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> XName a -> m (XName b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> XName a -> m (XName b)
    $csequence :: forall (m :: * -> *) a. Monad m => XName (m a) -> m (XName a)
    sequence :: forall (m :: * -> *) a. Monad m => XName (m a) -> m (XName a)
    Traversable,(forall a b. (a -> b) -> XName a -> XName b)
    -> (forall a b. a -> XName b -> XName a) -> Functor XName
    forall a b. a -> XName b -> XName a
    forall a b. (a -> b) -> XName a -> XName b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> XName a -> XName b
    fmap :: forall a b. (a -> b) -> XName a -> XName b
    $c<$ :: forall a b. a -> XName b -> XName a
    <$ :: forall a b. a -> XName b -> XName a
    Functor,(forall x. XName l -> Rep (XName l) x)
    -> (forall x. Rep (XName l) x -> XName l) -> Generic (XName l)
    forall x. Rep (XName l) x -> XName l
    forall x. XName l -> Rep (XName l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (XName l) x -> XName l
    forall l x. XName l -> Rep (XName l) x
    $cfrom :: forall l x. XName l -> Rep (XName l) x
    from :: forall x. XName l -> Rep (XName l) x
    $cto :: forall l x. Rep (XName l) x -> XName l
    to :: forall x. Rep (XName l) x -> XName l
    Generic)

    -- | An xml attribute, which is a name-expression pair.
    data XAttr l = XAttr l (XName l) (Exp l)
      deriving (XAttr l -> XAttr l -> Bool
    (XAttr l -> XAttr l -> Bool)
    -> (XAttr l -> XAttr l -> Bool) -> Eq (XAttr l)
    forall l. Eq l => XAttr l -> XAttr l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => XAttr l -> XAttr l -> Bool
    == :: XAttr l -> XAttr l -> Bool
    $c/= :: forall l. Eq l => XAttr l -> XAttr l -> Bool
    /= :: XAttr l -> XAttr l -> Bool
    Eq,Eq (XAttr l)
    Eq (XAttr l) =>
    (XAttr l -> XAttr l -> Ordering)
    -> (XAttr l -> XAttr l -> Bool)
    -> (XAttr l -> XAttr l -> Bool)
    -> (XAttr l -> XAttr l -> Bool)
    -> (XAttr l -> XAttr l -> Bool)
    -> (XAttr l -> XAttr l -> XAttr l)
    -> (XAttr l -> XAttr l -> XAttr l)
    -> Ord (XAttr l)
    XAttr l -> XAttr l -> Bool
    XAttr l -> XAttr l -> Ordering
    XAttr l -> XAttr l -> XAttr l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (XAttr l)
    forall l. Ord l => XAttr l -> XAttr l -> Bool
    forall l. Ord l => XAttr l -> XAttr l -> Ordering
    forall l. Ord l => XAttr l -> XAttr l -> XAttr l
    $ccompare :: forall l. Ord l => XAttr l -> XAttr l -> Ordering
    compare :: XAttr l -> XAttr l -> Ordering
    $c< :: forall l. Ord l => XAttr l -> XAttr l -> Bool
    < :: XAttr l -> XAttr l -> Bool
    $c<= :: forall l. Ord l => XAttr l -> XAttr l -> Bool
    <= :: XAttr l -> XAttr l -> Bool
    $c> :: forall l. Ord l => XAttr l -> XAttr l -> Bool
    > :: XAttr l -> XAttr l -> Bool
    $c>= :: forall l. Ord l => XAttr l -> XAttr l -> Bool
    >= :: XAttr l -> XAttr l -> Bool
    $cmax :: forall l. Ord l => XAttr l -> XAttr l -> XAttr l
    max :: XAttr l -> XAttr l -> XAttr l
    $cmin :: forall l. Ord l => XAttr l -> XAttr l -> XAttr l
    min :: XAttr l -> XAttr l -> XAttr l
    Ord,Int -> XAttr l -> ShowS
    [XAttr l] -> ShowS
    XAttr l -> String
    (Int -> XAttr l -> ShowS)
    -> (XAttr l -> String) -> ([XAttr l] -> ShowS) -> Show (XAttr l)
    forall l. Show l => Int -> XAttr l -> ShowS
    forall l. Show l => [XAttr l] -> ShowS
    forall l. Show l => XAttr l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> XAttr l -> ShowS
    showsPrec :: Int -> XAttr l -> ShowS
    $cshow :: forall l. Show l => XAttr l -> String
    show :: XAttr l -> String
    $cshowList :: forall l. Show l => [XAttr l] -> ShowS
    showList :: [XAttr l] -> ShowS
    Show,Typeable,Typeable (XAttr l)
    Typeable (XAttr l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> XAttr l -> c (XAttr l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (XAttr l))
    -> (XAttr l -> Constr)
    -> (XAttr l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (XAttr l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l)))
    -> ((forall b. Data b => b -> b) -> XAttr l -> XAttr l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> XAttr l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> XAttr l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> XAttr l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> XAttr l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l))
    -> Data (XAttr l)
    XAttr l -> Constr
    XAttr l -> DataType
    (forall b. Data b => b -> b) -> XAttr l -> XAttr l
    forall l. Data l => Typeable (XAttr l)
    forall l. Data l => XAttr l -> Constr
    forall l. Data l => XAttr l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> XAttr l -> XAttr l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> XAttr l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> XAttr l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XAttr l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> XAttr l -> c (XAttr l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (XAttr l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> XAttr l -> u
    forall u. (forall d. Data d => d -> u) -> XAttr l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XAttr l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> XAttr l -> c (XAttr l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (XAttr l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> XAttr l -> c (XAttr l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> XAttr l -> c (XAttr l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XAttr l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (XAttr l)
    $ctoConstr :: forall l. Data l => XAttr l -> Constr
    toConstr :: XAttr l -> Constr
    $cdataTypeOf :: forall l. Data l => XAttr l -> DataType
    dataTypeOf :: XAttr l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (XAttr l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (XAttr l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> XAttr l -> XAttr l
    gmapT :: (forall b. Data b => b -> b) -> XAttr l -> XAttr l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> XAttr l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> XAttr l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> XAttr l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> XAttr l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> XAttr l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l)
    Data,(forall m. Monoid m => XAttr m -> m)
    -> (forall m a. Monoid m => (a -> m) -> XAttr a -> m)
    -> (forall m a. Monoid m => (a -> m) -> XAttr a -> m)
    -> (forall a b. (a -> b -> b) -> b -> XAttr a -> b)
    -> (forall a b. (a -> b -> b) -> b -> XAttr a -> b)
    -> (forall b a. (b -> a -> b) -> b -> XAttr a -> b)
    -> (forall b a. (b -> a -> b) -> b -> XAttr a -> b)
    -> (forall a. (a -> a -> a) -> XAttr a -> a)
    -> (forall a. (a -> a -> a) -> XAttr a -> a)
    -> (forall a. XAttr a -> [a])
    -> (forall a. XAttr a -> Bool)
    -> (forall a. XAttr a -> Int)
    -> (forall a. Eq a => a -> XAttr a -> Bool)
    -> (forall a. Ord a => XAttr a -> a)
    -> (forall a. Ord a => XAttr a -> a)
    -> (forall a. Num a => XAttr a -> a)
    -> (forall a. Num a => XAttr a -> a)
    -> Foldable XAttr
    forall a. Eq a => a -> XAttr a -> Bool
    forall a. Num a => XAttr a -> a
    forall a. Ord a => XAttr a -> a
    forall m. Monoid m => XAttr m -> m
    forall a. XAttr a -> Bool
    forall a. XAttr a -> Int
    forall a. XAttr a -> [a]
    forall a. (a -> a -> a) -> XAttr a -> a
    forall m a. Monoid m => (a -> m) -> XAttr a -> m
    forall b a. (b -> a -> b) -> b -> XAttr a -> b
    forall a b. (a -> b -> b) -> b -> XAttr a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => XAttr m -> m
    fold :: forall m. Monoid m => XAttr m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> XAttr a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> XAttr a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> XAttr a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> XAttr a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> XAttr a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> XAttr a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> XAttr a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> XAttr a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> XAttr a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> XAttr a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> XAttr a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> XAttr a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> XAttr a -> a
    foldr1 :: forall a. (a -> a -> a) -> XAttr a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> XAttr a -> a
    foldl1 :: forall a. (a -> a -> a) -> XAttr a -> a
    $ctoList :: forall a. XAttr a -> [a]
    toList :: forall a. XAttr a -> [a]
    $cnull :: forall a. XAttr a -> Bool
    null :: forall a. XAttr a -> Bool
    $clength :: forall a. XAttr a -> Int
    length :: forall a. XAttr a -> Int
    $celem :: forall a. Eq a => a -> XAttr a -> Bool
    elem :: forall a. Eq a => a -> XAttr a -> Bool
    $cmaximum :: forall a. Ord a => XAttr a -> a
    maximum :: forall a. Ord a => XAttr a -> a
    $cminimum :: forall a. Ord a => XAttr a -> a
    minimum :: forall a. Ord a => XAttr a -> a
    $csum :: forall a. Num a => XAttr a -> a
    sum :: forall a. Num a => XAttr a -> a
    $cproduct :: forall a. Num a => XAttr a -> a
    product :: forall a. Num a => XAttr a -> a
    Foldable,Functor XAttr
    Foldable XAttr
    (Functor XAttr, Foldable XAttr) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> XAttr a -> f (XAttr b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        XAttr (f a) -> f (XAttr a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> XAttr a -> m (XAttr b))
    -> (forall (m :: * -> *) a. Monad m => XAttr (m a) -> m (XAttr a))
    -> Traversable XAttr
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => XAttr (m a) -> m (XAttr a)
    forall (f :: * -> *) a. Applicative f => XAttr (f a) -> f (XAttr a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> XAttr a -> m (XAttr b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> XAttr a -> f (XAttr b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> XAttr a -> f (XAttr b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> XAttr a -> f (XAttr b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => XAttr (f a) -> f (XAttr a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => XAttr (f a) -> f (XAttr a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> XAttr a -> m (XAttr b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> XAttr a -> m (XAttr b)
    $csequence :: forall (m :: * -> *) a. Monad m => XAttr (m a) -> m (XAttr a)
    sequence :: forall (m :: * -> *) a. Monad m => XAttr (m a) -> m (XAttr a)
    Traversable,(forall a b. (a -> b) -> XAttr a -> XAttr b)
    -> (forall a b. a -> XAttr b -> XAttr a) -> Functor XAttr
    forall a b. a -> XAttr b -> XAttr a
    forall a b. (a -> b) -> XAttr a -> XAttr b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> XAttr a -> XAttr b
    fmap :: forall a b. (a -> b) -> XAttr a -> XAttr b
    $c<$ :: forall a b. a -> XAttr b -> XAttr a
    <$ :: forall a b. a -> XAttr b -> XAttr a
    Functor,(forall x. XAttr l -> Rep (XAttr l) x)
    -> (forall x. Rep (XAttr l) x -> XAttr l) -> Generic (XAttr l)
    forall x. Rep (XAttr l) x -> XAttr l
    forall x. XAttr l -> Rep (XAttr l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (XAttr l) x -> XAttr l
    forall l x. XAttr l -> Rep (XAttr l) x
    $cfrom :: forall l x. XAttr l -> Rep (XAttr l) x
    from :: forall x. XAttr l -> Rep (XAttr l) x
    $cto :: forall l x. Rep (XAttr l) x -> XAttr l
    to :: forall x. Rep (XAttr l) x -> XAttr l
    Generic)

    -- | A template haskell bracket expression.
    data Bracket l
        = ExpBracket l (Exp l)        -- ^ expression bracket: @[| ... |]@
        | TExpBracket l (Exp l)       -- ^ typed expression bracket: @[|| ... ||]@
        | PatBracket l (Pat l)        -- ^ pattern bracket: @[p| ... |]@
        | TypeBracket l (Type l)      -- ^ type bracket: @[t| ... |]@
        | DeclBracket l [Decl l]      -- ^ declaration bracket: @[d| ... |]@
      deriving (Bracket l -> Bracket l -> Bool
    (Bracket l -> Bracket l -> Bool)
    -> (Bracket l -> Bracket l -> Bool) -> Eq (Bracket l)
    forall l. Eq l => Bracket l -> Bracket l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Bracket l -> Bracket l -> Bool
    == :: Bracket l -> Bracket l -> Bool
    $c/= :: forall l. Eq l => Bracket l -> Bracket l -> Bool
    /= :: Bracket l -> Bracket l -> Bool
    Eq,Eq (Bracket l)
    Eq (Bracket l) =>
    (Bracket l -> Bracket l -> Ordering)
    -> (Bracket l -> Bracket l -> Bool)
    -> (Bracket l -> Bracket l -> Bool)
    -> (Bracket l -> Bracket l -> Bool)
    -> (Bracket l -> Bracket l -> Bool)
    -> (Bracket l -> Bracket l -> Bracket l)
    -> (Bracket l -> Bracket l -> Bracket l)
    -> Ord (Bracket l)
    Bracket l -> Bracket l -> Bool
    Bracket l -> Bracket l -> Ordering
    Bracket l -> Bracket l -> Bracket l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Bracket l)
    forall l. Ord l => Bracket l -> Bracket l -> Bool
    forall l. Ord l => Bracket l -> Bracket l -> Ordering
    forall l. Ord l => Bracket l -> Bracket l -> Bracket l
    $ccompare :: forall l. Ord l => Bracket l -> Bracket l -> Ordering
    compare :: Bracket l -> Bracket l -> Ordering
    $c< :: forall l. Ord l => Bracket l -> Bracket l -> Bool
    < :: Bracket l -> Bracket l -> Bool
    $c<= :: forall l. Ord l => Bracket l -> Bracket l -> Bool
    <= :: Bracket l -> Bracket l -> Bool
    $c> :: forall l. Ord l => Bracket l -> Bracket l -> Bool
    > :: Bracket l -> Bracket l -> Bool
    $c>= :: forall l. Ord l => Bracket l -> Bracket l -> Bool
    >= :: Bracket l -> Bracket l -> Bool
    $cmax :: forall l. Ord l => Bracket l -> Bracket l -> Bracket l
    max :: Bracket l -> Bracket l -> Bracket l
    $cmin :: forall l. Ord l => Bracket l -> Bracket l -> Bracket l
    min :: Bracket l -> Bracket l -> Bracket l
    Ord,Int -> Bracket l -> ShowS
    [Bracket l] -> ShowS
    Bracket l -> String
    (Int -> Bracket l -> ShowS)
    -> (Bracket l -> String)
    -> ([Bracket l] -> ShowS)
    -> Show (Bracket l)
    forall l. Show l => Int -> Bracket l -> ShowS
    forall l. Show l => [Bracket l] -> ShowS
    forall l. Show l => Bracket l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Bracket l -> ShowS
    showsPrec :: Int -> Bracket l -> ShowS
    $cshow :: forall l. Show l => Bracket l -> String
    show :: Bracket l -> String
    $cshowList :: forall l. Show l => [Bracket l] -> ShowS
    showList :: [Bracket l] -> ShowS
    Show,Typeable,Typeable (Bracket l)
    Typeable (Bracket l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Bracket l -> c (Bracket l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Bracket l))
    -> (Bracket l -> Constr)
    -> (Bracket l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Bracket l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Bracket l)))
    -> ((forall b. Data b => b -> b) -> Bracket l -> Bracket l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Bracket l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Bracket l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Bracket l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Bracket l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l))
    -> Data (Bracket l)
    Bracket l -> Constr
    Bracket l -> DataType
    (forall b. Data b => b -> b) -> Bracket l -> Bracket l
    forall l. Data l => Typeable (Bracket l)
    forall l. Data l => Bracket l -> Constr
    forall l. Data l => Bracket l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Bracket l -> Bracket l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Bracket l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Bracket l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bracket l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bracket l -> c (Bracket l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bracket l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bracket l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Bracket l -> u
    forall u. (forall d. Data d => d -> u) -> Bracket l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bracket l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bracket l -> c (Bracket l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bracket l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bracket l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bracket l -> c (Bracket l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bracket l -> c (Bracket l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bracket l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Bracket l)
    $ctoConstr :: forall l. Data l => Bracket l -> Constr
    toConstr :: Bracket l -> Constr
    $cdataTypeOf :: forall l. Data l => Bracket l -> DataType
    dataTypeOf :: Bracket l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bracket l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Bracket l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bracket l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Bracket l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Bracket l -> Bracket l
    gmapT :: (forall b. Data b => b -> b) -> Bracket l -> Bracket l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bracket l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Bracket l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Bracket l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Bracket l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bracket l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l)
    Data,(forall m. Monoid m => Bracket m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Bracket a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Bracket a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Bracket a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Bracket a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Bracket a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Bracket a -> b)
    -> (forall a. (a -> a -> a) -> Bracket a -> a)
    -> (forall a. (a -> a -> a) -> Bracket a -> a)
    -> (forall a. Bracket a -> [a])
    -> (forall a. Bracket a -> Bool)
    -> (forall a. Bracket a -> Int)
    -> (forall a. Eq a => a -> Bracket a -> Bool)
    -> (forall a. Ord a => Bracket a -> a)
    -> (forall a. Ord a => Bracket a -> a)
    -> (forall a. Num a => Bracket a -> a)
    -> (forall a. Num a => Bracket a -> a)
    -> Foldable Bracket
    forall a. Eq a => a -> Bracket a -> Bool
    forall a. Num a => Bracket a -> a
    forall a. Ord a => Bracket a -> a
    forall m. Monoid m => Bracket m -> m
    forall a. Bracket a -> Bool
    forall a. Bracket a -> Int
    forall a. Bracket a -> [a]
    forall a. (a -> a -> a) -> Bracket a -> a
    forall m a. Monoid m => (a -> m) -> Bracket a -> m
    forall b a. (b -> a -> b) -> b -> Bracket a -> b
    forall a b. (a -> b -> b) -> b -> Bracket a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Bracket m -> m
    fold :: forall m. Monoid m => Bracket m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Bracket a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Bracket a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Bracket a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Bracket a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Bracket a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Bracket a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Bracket a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Bracket a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Bracket a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Bracket a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Bracket a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Bracket a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Bracket a -> a
    foldr1 :: forall a. (a -> a -> a) -> Bracket a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Bracket a -> a
    foldl1 :: forall a. (a -> a -> a) -> Bracket a -> a
    $ctoList :: forall a. Bracket a -> [a]
    toList :: forall a. Bracket a -> [a]
    $cnull :: forall a. Bracket a -> Bool
    null :: forall a. Bracket a -> Bool
    $clength :: forall a. Bracket a -> Int
    length :: forall a. Bracket a -> Int
    $celem :: forall a. Eq a => a -> Bracket a -> Bool
    elem :: forall a. Eq a => a -> Bracket a -> Bool
    $cmaximum :: forall a. Ord a => Bracket a -> a
    maximum :: forall a. Ord a => Bracket a -> a
    $cminimum :: forall a. Ord a => Bracket a -> a
    minimum :: forall a. Ord a => Bracket a -> a
    $csum :: forall a. Num a => Bracket a -> a
    sum :: forall a. Num a => Bracket a -> a
    $cproduct :: forall a. Num a => Bracket a -> a
    product :: forall a. Num a => Bracket a -> a
    Foldable,Functor Bracket
    Foldable Bracket
    (Functor Bracket, Foldable Bracket) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Bracket a -> f (Bracket b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Bracket (f a) -> f (Bracket a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Bracket a -> m (Bracket b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Bracket (m a) -> m (Bracket a))
    -> Traversable Bracket
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Bracket (m a) -> m (Bracket a)
    forall (f :: * -> *) a.
    Applicative f =>
    Bracket (f a) -> f (Bracket a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bracket a -> m (Bracket b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Bracket a -> f (Bracket b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Bracket a -> f (Bracket b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Bracket a -> f (Bracket b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Bracket (f a) -> f (Bracket a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Bracket (f a) -> f (Bracket a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bracket a -> m (Bracket b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bracket a -> m (Bracket b)
    $csequence :: forall (m :: * -> *) a. Monad m => Bracket (m a) -> m (Bracket a)
    sequence :: forall (m :: * -> *) a. Monad m => Bracket (m a) -> m (Bracket a)
    Traversable,(forall a b. (a -> b) -> Bracket a -> Bracket b)
    -> (forall a b. a -> Bracket b -> Bracket a) -> Functor Bracket
    forall a b. a -> Bracket b -> Bracket a
    forall a b. (a -> b) -> Bracket a -> Bracket b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Bracket a -> Bracket b
    fmap :: forall a b. (a -> b) -> Bracket a -> Bracket b
    $c<$ :: forall a b. a -> Bracket b -> Bracket a
    <$ :: forall a b. a -> Bracket b -> Bracket a
    Functor,(forall x. Bracket l -> Rep (Bracket l) x)
    -> (forall x. Rep (Bracket l) x -> Bracket l)
    -> Generic (Bracket l)
    forall x. Rep (Bracket l) x -> Bracket l
    forall x. Bracket l -> Rep (Bracket l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Bracket l) x -> Bracket l
    forall l x. Bracket l -> Rep (Bracket l) x
    $cfrom :: forall l x. Bracket l -> Rep (Bracket l) x
    from :: forall x. Bracket l -> Rep (Bracket l) x
    $cto :: forall l x. Rep (Bracket l) x -> Bracket l
    to :: forall x. Rep (Bracket l) x -> Bracket l
    Generic)

    -- | A template haskell splice expression
    data Splice l
        = IdSplice l String           -- ^ variable splice: @$var@
        | TIdSplice l String          -- ^ typed variable splice: @$$var@
        | ParenSplice l (Exp l)       -- ^ parenthesised expression splice: @$(/exp/)@
        | TParenSplice l (Exp l)      -- ^ parenthesised typed expression splice: @$$(/exp/)@
      deriving (Splice l -> Splice l -> Bool
    (Splice l -> Splice l -> Bool)
    -> (Splice l -> Splice l -> Bool) -> Eq (Splice l)
    forall l. Eq l => Splice l -> Splice l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Splice l -> Splice l -> Bool
    == :: Splice l -> Splice l -> Bool
    $c/= :: forall l. Eq l => Splice l -> Splice l -> Bool
    /= :: Splice l -> Splice l -> Bool
    Eq,Eq (Splice l)
    Eq (Splice l) =>
    (Splice l -> Splice l -> Ordering)
    -> (Splice l -> Splice l -> Bool)
    -> (Splice l -> Splice l -> Bool)
    -> (Splice l -> Splice l -> Bool)
    -> (Splice l -> Splice l -> Bool)
    -> (Splice l -> Splice l -> Splice l)
    -> (Splice l -> Splice l -> Splice l)
    -> Ord (Splice l)
    Splice l -> Splice l -> Bool
    Splice l -> Splice l -> Ordering
    Splice l -> Splice l -> Splice l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Splice l)
    forall l. Ord l => Splice l -> Splice l -> Bool
    forall l. Ord l => Splice l -> Splice l -> Ordering
    forall l. Ord l => Splice l -> Splice l -> Splice l
    $ccompare :: forall l. Ord l => Splice l -> Splice l -> Ordering
    compare :: Splice l -> Splice l -> Ordering
    $c< :: forall l. Ord l => Splice l -> Splice l -> Bool
    < :: Splice l -> Splice l -> Bool
    $c<= :: forall l. Ord l => Splice l -> Splice l -> Bool
    <= :: Splice l -> Splice l -> Bool
    $c> :: forall l. Ord l => Splice l -> Splice l -> Bool
    > :: Splice l -> Splice l -> Bool
    $c>= :: forall l. Ord l => Splice l -> Splice l -> Bool
    >= :: Splice l -> Splice l -> Bool
    $cmax :: forall l. Ord l => Splice l -> Splice l -> Splice l
    max :: Splice l -> Splice l -> Splice l
    $cmin :: forall l. Ord l => Splice l -> Splice l -> Splice l
    min :: Splice l -> Splice l -> Splice l
    Ord,Int -> Splice l -> ShowS
    [Splice l] -> ShowS
    Splice l -> String
    (Int -> Splice l -> ShowS)
    -> (Splice l -> String) -> ([Splice l] -> ShowS) -> Show (Splice l)
    forall l. Show l => Int -> Splice l -> ShowS
    forall l. Show l => [Splice l] -> ShowS
    forall l. Show l => Splice l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Splice l -> ShowS
    showsPrec :: Int -> Splice l -> ShowS
    $cshow :: forall l. Show l => Splice l -> String
    show :: Splice l -> String
    $cshowList :: forall l. Show l => [Splice l] -> ShowS
    showList :: [Splice l] -> ShowS
    Show,Typeable,Typeable (Splice l)
    Typeable (Splice l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Splice l -> c (Splice l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Splice l))
    -> (Splice l -> Constr)
    -> (Splice l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Splice l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Splice l)))
    -> ((forall b. Data b => b -> b) -> Splice l -> Splice l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Splice l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Splice l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Splice l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Splice l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Splice l -> m (Splice l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Splice l -> m (Splice l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Splice l -> m (Splice l))
    -> Data (Splice l)
    Splice l -> Constr
    Splice l -> DataType
    (forall b. Data b => b -> b) -> Splice l -> Splice l
    forall l. Data l => Typeable (Splice l)
    forall l. Data l => Splice l -> Constr
    forall l. Data l => Splice l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Splice l -> Splice l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Splice l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Splice l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Splice l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Splice l -> c (Splice l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Splice l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Splice l -> u
    forall u. (forall d. Data d => d -> u) -> Splice l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Splice l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Splice l -> c (Splice l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Splice l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Splice l -> c (Splice l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Splice l -> c (Splice l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Splice l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Splice l)
    $ctoConstr :: forall l. Data l => Splice l -> Constr
    toConstr :: Splice l -> Constr
    $cdataTypeOf :: forall l. Data l => Splice l -> DataType
    dataTypeOf :: Splice l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Splice l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Splice l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Splice l -> Splice l
    gmapT :: (forall b. Data b => b -> b) -> Splice l -> Splice l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Splice l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Splice l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Splice l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Splice l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Splice l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Splice l -> m (Splice l)
    Data,(forall m. Monoid m => Splice m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Splice a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Splice a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Splice a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Splice a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Splice a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Splice a -> b)
    -> (forall a. (a -> a -> a) -> Splice a -> a)
    -> (forall a. (a -> a -> a) -> Splice a -> a)
    -> (forall a. Splice a -> [a])
    -> (forall a. Splice a -> Bool)
    -> (forall a. Splice a -> Int)
    -> (forall a. Eq a => a -> Splice a -> Bool)
    -> (forall a. Ord a => Splice a -> a)
    -> (forall a. Ord a => Splice a -> a)
    -> (forall a. Num a => Splice a -> a)
    -> (forall a. Num a => Splice a -> a)
    -> Foldable Splice
    forall a. Eq a => a -> Splice a -> Bool
    forall a. Num a => Splice a -> a
    forall a. Ord a => Splice a -> a
    forall m. Monoid m => Splice m -> m
    forall a. Splice a -> Bool
    forall a. Splice a -> Int
    forall a. Splice a -> [a]
    forall a. (a -> a -> a) -> Splice a -> a
    forall m a. Monoid m => (a -> m) -> Splice a -> m
    forall b a. (b -> a -> b) -> b -> Splice a -> b
    forall a b. (a -> b -> b) -> b -> Splice a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Splice m -> m
    fold :: forall m. Monoid m => Splice m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Splice a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Splice a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Splice a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Splice a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Splice a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Splice a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Splice a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Splice a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Splice a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Splice a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Splice a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Splice a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Splice a -> a
    foldr1 :: forall a. (a -> a -> a) -> Splice a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Splice a -> a
    foldl1 :: forall a. (a -> a -> a) -> Splice a -> a
    $ctoList :: forall a. Splice a -> [a]
    toList :: forall a. Splice a -> [a]
    $cnull :: forall a. Splice a -> Bool
    null :: forall a. Splice a -> Bool
    $clength :: forall a. Splice a -> Int
    length :: forall a. Splice a -> Int
    $celem :: forall a. Eq a => a -> Splice a -> Bool
    elem :: forall a. Eq a => a -> Splice a -> Bool
    $cmaximum :: forall a. Ord a => Splice a -> a
    maximum :: forall a. Ord a => Splice a -> a
    $cminimum :: forall a. Ord a => Splice a -> a
    minimum :: forall a. Ord a => Splice a -> a
    $csum :: forall a. Num a => Splice a -> a
    sum :: forall a. Num a => Splice a -> a
    $cproduct :: forall a. Num a => Splice a -> a
    product :: forall a. Num a => Splice a -> a
    Foldable,Functor Splice
    Foldable Splice
    (Functor Splice, Foldable Splice) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Splice a -> f (Splice b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Splice (f a) -> f (Splice a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Splice a -> m (Splice b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Splice (m a) -> m (Splice a))
    -> Traversable Splice
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Splice (m a) -> m (Splice a)
    forall (f :: * -> *) a.
    Applicative f =>
    Splice (f a) -> f (Splice a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Splice a -> m (Splice b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Splice a -> f (Splice b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Splice a -> f (Splice b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Splice a -> f (Splice b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Splice (f a) -> f (Splice a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Splice (f a) -> f (Splice a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Splice a -> m (Splice b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Splice a -> m (Splice b)
    $csequence :: forall (m :: * -> *) a. Monad m => Splice (m a) -> m (Splice a)
    sequence :: forall (m :: * -> *) a. Monad m => Splice (m a) -> m (Splice a)
    Traversable,(forall a b. (a -> b) -> Splice a -> Splice b)
    -> (forall a b. a -> Splice b -> Splice a) -> Functor Splice
    forall a b. a -> Splice b -> Splice a
    forall a b. (a -> b) -> Splice a -> Splice b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Splice a -> Splice b
    fmap :: forall a b. (a -> b) -> Splice a -> Splice b
    $c<$ :: forall a b. a -> Splice b -> Splice a
    <$ :: forall a b. a -> Splice b -> Splice a
    Functor,(forall x. Splice l -> Rep (Splice l) x)
    -> (forall x. Rep (Splice l) x -> Splice l) -> Generic (Splice l)
    forall x. Rep (Splice l) x -> Splice l
    forall x. Splice l -> Rep (Splice l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Splice l) x -> Splice l
    forall l x. Splice l -> Rep (Splice l) x
    $cfrom :: forall l x. Splice l -> Rep (Splice l) x
    from :: forall x. Splice l -> Rep (Splice l) x
    $cto :: forall l x. Rep (Splice l) x -> Splice l
    to :: forall x. Rep (Splice l) x -> Splice l
    Generic)

    -- | The safety of a foreign function call.
    data Safety l
        = PlayRisky l         -- ^ unsafe
        | PlaySafe l Bool     -- ^ safe ('False') or threadsafe ('True')
        | PlayInterruptible l -- ^ interruptible
      deriving (Safety l -> Safety l -> Bool
    (Safety l -> Safety l -> Bool)
    -> (Safety l -> Safety l -> Bool) -> Eq (Safety l)
    forall l. Eq l => Safety l -> Safety l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Safety l -> Safety l -> Bool
    == :: Safety l -> Safety l -> Bool
    $c/= :: forall l. Eq l => Safety l -> Safety l -> Bool
    /= :: Safety l -> Safety l -> Bool
    Eq,Eq (Safety l)
    Eq (Safety l) =>
    (Safety l -> Safety l -> Ordering)
    -> (Safety l -> Safety l -> Bool)
    -> (Safety l -> Safety l -> Bool)
    -> (Safety l -> Safety l -> Bool)
    -> (Safety l -> Safety l -> Bool)
    -> (Safety l -> Safety l -> Safety l)
    -> (Safety l -> Safety l -> Safety l)
    -> Ord (Safety l)
    Safety l -> Safety l -> Bool
    Safety l -> Safety l -> Ordering
    Safety l -> Safety l -> Safety l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Safety l)
    forall l. Ord l => Safety l -> Safety l -> Bool
    forall l. Ord l => Safety l -> Safety l -> Ordering
    forall l. Ord l => Safety l -> Safety l -> Safety l
    $ccompare :: forall l. Ord l => Safety l -> Safety l -> Ordering
    compare :: Safety l -> Safety l -> Ordering
    $c< :: forall l. Ord l => Safety l -> Safety l -> Bool
    < :: Safety l -> Safety l -> Bool
    $c<= :: forall l. Ord l => Safety l -> Safety l -> Bool
    <= :: Safety l -> Safety l -> Bool
    $c> :: forall l. Ord l => Safety l -> Safety l -> Bool
    > :: Safety l -> Safety l -> Bool
    $c>= :: forall l. Ord l => Safety l -> Safety l -> Bool
    >= :: Safety l -> Safety l -> Bool
    $cmax :: forall l. Ord l => Safety l -> Safety l -> Safety l
    max :: Safety l -> Safety l -> Safety l
    $cmin :: forall l. Ord l => Safety l -> Safety l -> Safety l
    min :: Safety l -> Safety l -> Safety l
    Ord,Int -> Safety l -> ShowS
    [Safety l] -> ShowS
    Safety l -> String
    (Int -> Safety l -> ShowS)
    -> (Safety l -> String) -> ([Safety l] -> ShowS) -> Show (Safety l)
    forall l. Show l => Int -> Safety l -> ShowS
    forall l. Show l => [Safety l] -> ShowS
    forall l. Show l => Safety l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Safety l -> ShowS
    showsPrec :: Int -> Safety l -> ShowS
    $cshow :: forall l. Show l => Safety l -> String
    show :: Safety l -> String
    $cshowList :: forall l. Show l => [Safety l] -> ShowS
    showList :: [Safety l] -> ShowS
    Show,Typeable,Typeable (Safety l)
    Typeable (Safety l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Safety l -> c (Safety l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Safety l))
    -> (Safety l -> Constr)
    -> (Safety l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Safety l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Safety l)))
    -> ((forall b. Data b => b -> b) -> Safety l -> Safety l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Safety l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Safety l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Safety l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Safety l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Safety l -> m (Safety l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Safety l -> m (Safety l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Safety l -> m (Safety l))
    -> Data (Safety l)
    Safety l -> Constr
    Safety l -> DataType
    (forall b. Data b => b -> b) -> Safety l -> Safety l
    forall l. Data l => Typeable (Safety l)
    forall l. Data l => Safety l -> Constr
    forall l. Data l => Safety l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Safety l -> Safety l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Safety l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Safety l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Safety l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Safety l -> c (Safety l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Safety l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Safety l -> u
    forall u. (forall d. Data d => d -> u) -> Safety l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Safety l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Safety l -> c (Safety l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Safety l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Safety l -> c (Safety l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Safety l -> c (Safety l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Safety l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Safety l)
    $ctoConstr :: forall l. Data l => Safety l -> Constr
    toConstr :: Safety l -> Constr
    $cdataTypeOf :: forall l. Data l => Safety l -> DataType
    dataTypeOf :: Safety l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Safety l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Safety l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Safety l -> Safety l
    gmapT :: (forall b. Data b => b -> b) -> Safety l -> Safety l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Safety l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Safety l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Safety l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Safety l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety l -> m (Safety l)
    Data,(forall m. Monoid m => Safety m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Safety a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Safety a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Safety a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Safety a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Safety a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Safety a -> b)
    -> (forall a. (a -> a -> a) -> Safety a -> a)
    -> (forall a. (a -> a -> a) -> Safety a -> a)
    -> (forall a. Safety a -> [a])
    -> (forall a. Safety a -> Bool)
    -> (forall a. Safety a -> Int)
    -> (forall a. Eq a => a -> Safety a -> Bool)
    -> (forall a. Ord a => Safety a -> a)
    -> (forall a. Ord a => Safety a -> a)
    -> (forall a. Num a => Safety a -> a)
    -> (forall a. Num a => Safety a -> a)
    -> Foldable Safety
    forall a. Eq a => a -> Safety a -> Bool
    forall a. Num a => Safety a -> a
    forall a. Ord a => Safety a -> a
    forall m. Monoid m => Safety m -> m
    forall a. Safety a -> Bool
    forall a. Safety a -> Int
    forall a. Safety a -> [a]
    forall a. (a -> a -> a) -> Safety a -> a
    forall m a. Monoid m => (a -> m) -> Safety a -> m
    forall b a. (b -> a -> b) -> b -> Safety a -> b
    forall a b. (a -> b -> b) -> b -> Safety a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Safety m -> m
    fold :: forall m. Monoid m => Safety m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Safety a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Safety a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Safety a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Safety a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Safety a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Safety a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Safety a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Safety a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Safety a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Safety a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Safety a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Safety a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Safety a -> a
    foldr1 :: forall a. (a -> a -> a) -> Safety a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Safety a -> a
    foldl1 :: forall a. (a -> a -> a) -> Safety a -> a
    $ctoList :: forall a. Safety a -> [a]
    toList :: forall a. Safety a -> [a]
    $cnull :: forall a. Safety a -> Bool
    null :: forall a. Safety a -> Bool
    $clength :: forall a. Safety a -> Int
    length :: forall a. Safety a -> Int
    $celem :: forall a. Eq a => a -> Safety a -> Bool
    elem :: forall a. Eq a => a -> Safety a -> Bool
    $cmaximum :: forall a. Ord a => Safety a -> a
    maximum :: forall a. Ord a => Safety a -> a
    $cminimum :: forall a. Ord a => Safety a -> a
    minimum :: forall a. Ord a => Safety a -> a
    $csum :: forall a. Num a => Safety a -> a
    sum :: forall a. Num a => Safety a -> a
    $cproduct :: forall a. Num a => Safety a -> a
    product :: forall a. Num a => Safety a -> a
    Foldable,Functor Safety
    Foldable Safety
    (Functor Safety, Foldable Safety) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Safety a -> f (Safety b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Safety (f a) -> f (Safety a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Safety a -> m (Safety b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Safety (m a) -> m (Safety a))
    -> Traversable Safety
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Safety (m a) -> m (Safety a)
    forall (f :: * -> *) a.
    Applicative f =>
    Safety (f a) -> f (Safety a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Safety a -> m (Safety b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Safety a -> f (Safety b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Safety a -> f (Safety b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Safety a -> f (Safety b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Safety (f a) -> f (Safety a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Safety (f a) -> f (Safety a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Safety a -> m (Safety b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Safety a -> m (Safety b)
    $csequence :: forall (m :: * -> *) a. Monad m => Safety (m a) -> m (Safety a)
    sequence :: forall (m :: * -> *) a. Monad m => Safety (m a) -> m (Safety a)
    Traversable,(forall a b. (a -> b) -> Safety a -> Safety b)
    -> (forall a b. a -> Safety b -> Safety a) -> Functor Safety
    forall a b. a -> Safety b -> Safety a
    forall a b. (a -> b) -> Safety a -> Safety b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Safety a -> Safety b
    fmap :: forall a b. (a -> b) -> Safety a -> Safety b
    $c<$ :: forall a b. a -> Safety b -> Safety a
    <$ :: forall a b. a -> Safety b -> Safety a
    Functor,(forall x. Safety l -> Rep (Safety l) x)
    -> (forall x. Rep (Safety l) x -> Safety l) -> Generic (Safety l)
    forall x. Rep (Safety l) x -> Safety l
    forall x. Safety l -> Rep (Safety l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Safety l) x -> Safety l
    forall l x. Safety l -> Rep (Safety l) x
    $cfrom :: forall l x. Safety l -> Rep (Safety l) x
    from :: forall x. Safety l -> Rep (Safety l) x
    $cto :: forall l x. Rep (Safety l) x -> Safety l
    to :: forall x. Rep (Safety l) x -> Safety l
    Generic)

    -- | The calling convention of a foreign function call.
    data CallConv l
        = StdCall l
        | CCall l
        | CPlusPlus l
        | DotNet l
        | Jvm l
        | Js l
        | JavaScript l
        | CApi l
      deriving (CallConv l -> CallConv l -> Bool
    (CallConv l -> CallConv l -> Bool)
    -> (CallConv l -> CallConv l -> Bool) -> Eq (CallConv l)
    forall l. Eq l => CallConv l -> CallConv l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => CallConv l -> CallConv l -> Bool
    == :: CallConv l -> CallConv l -> Bool
    $c/= :: forall l. Eq l => CallConv l -> CallConv l -> Bool
    /= :: CallConv l -> CallConv l -> Bool
    Eq,Eq (CallConv l)
    Eq (CallConv l) =>
    (CallConv l -> CallConv l -> Ordering)
    -> (CallConv l -> CallConv l -> Bool)
    -> (CallConv l -> CallConv l -> Bool)
    -> (CallConv l -> CallConv l -> Bool)
    -> (CallConv l -> CallConv l -> Bool)
    -> (CallConv l -> CallConv l -> CallConv l)
    -> (CallConv l -> CallConv l -> CallConv l)
    -> Ord (CallConv l)
    CallConv l -> CallConv l -> Bool
    CallConv l -> CallConv l -> Ordering
    CallConv l -> CallConv l -> CallConv l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (CallConv l)
    forall l. Ord l => CallConv l -> CallConv l -> Bool
    forall l. Ord l => CallConv l -> CallConv l -> Ordering
    forall l. Ord l => CallConv l -> CallConv l -> CallConv l
    $ccompare :: forall l. Ord l => CallConv l -> CallConv l -> Ordering
    compare :: CallConv l -> CallConv l -> Ordering
    $c< :: forall l. Ord l => CallConv l -> CallConv l -> Bool
    < :: CallConv l -> CallConv l -> Bool
    $c<= :: forall l. Ord l => CallConv l -> CallConv l -> Bool
    <= :: CallConv l -> CallConv l -> Bool
    $c> :: forall l. Ord l => CallConv l -> CallConv l -> Bool
    > :: CallConv l -> CallConv l -> Bool
    $c>= :: forall l. Ord l => CallConv l -> CallConv l -> Bool
    >= :: CallConv l -> CallConv l -> Bool
    $cmax :: forall l. Ord l => CallConv l -> CallConv l -> CallConv l
    max :: CallConv l -> CallConv l -> CallConv l
    $cmin :: forall l. Ord l => CallConv l -> CallConv l -> CallConv l
    min :: CallConv l -> CallConv l -> CallConv l
    Ord,Int -> CallConv l -> ShowS
    [CallConv l] -> ShowS
    CallConv l -> String
    (Int -> CallConv l -> ShowS)
    -> (CallConv l -> String)
    -> ([CallConv l] -> ShowS)
    -> Show (CallConv l)
    forall l. Show l => Int -> CallConv l -> ShowS
    forall l. Show l => [CallConv l] -> ShowS
    forall l. Show l => CallConv l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> CallConv l -> ShowS
    showsPrec :: Int -> CallConv l -> ShowS
    $cshow :: forall l. Show l => CallConv l -> String
    show :: CallConv l -> String
    $cshowList :: forall l. Show l => [CallConv l] -> ShowS
    showList :: [CallConv l] -> ShowS
    Show,Typeable,Typeable (CallConv l)
    Typeable (CallConv l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> CallConv l -> c (CallConv l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (CallConv l))
    -> (CallConv l -> Constr)
    -> (CallConv l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (CallConv l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (CallConv l)))
    -> ((forall b. Data b => b -> b) -> CallConv l -> CallConv l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CallConv l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CallConv l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CallConv l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CallConv l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l))
    -> Data (CallConv l)
    CallConv l -> Constr
    CallConv l -> DataType
    (forall b. Data b => b -> b) -> CallConv l -> CallConv l
    forall l. Data l => Typeable (CallConv l)
    forall l. Data l => CallConv l -> Constr
    forall l. Data l => CallConv l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> CallConv l -> CallConv l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> CallConv l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> CallConv l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CallConv l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CallConv l -> c (CallConv l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (CallConv l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CallConv l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> CallConv l -> u
    forall u. (forall d. Data d => d -> u) -> CallConv l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CallConv l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CallConv l -> c (CallConv l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CallConv l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CallConv l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CallConv l -> c (CallConv l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CallConv l -> c (CallConv l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CallConv l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CallConv l)
    $ctoConstr :: forall l. Data l => CallConv l -> Constr
    toConstr :: CallConv l -> Constr
    $cdataTypeOf :: forall l. Data l => CallConv l -> DataType
    dataTypeOf :: CallConv l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (CallConv l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CallConv l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CallConv l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CallConv l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> CallConv l -> CallConv l
    gmapT :: (forall b. Data b => b -> b) -> CallConv l -> CallConv l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CallConv l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> CallConv l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CallConv l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> CallConv l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CallConv l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l)
    Data,(forall m. Monoid m => CallConv m -> m)
    -> (forall m a. Monoid m => (a -> m) -> CallConv a -> m)
    -> (forall m a. Monoid m => (a -> m) -> CallConv a -> m)
    -> (forall a b. (a -> b -> b) -> b -> CallConv a -> b)
    -> (forall a b. (a -> b -> b) -> b -> CallConv a -> b)
    -> (forall b a. (b -> a -> b) -> b -> CallConv a -> b)
    -> (forall b a. (b -> a -> b) -> b -> CallConv a -> b)
    -> (forall a. (a -> a -> a) -> CallConv a -> a)
    -> (forall a. (a -> a -> a) -> CallConv a -> a)
    -> (forall a. CallConv a -> [a])
    -> (forall a. CallConv a -> Bool)
    -> (forall a. CallConv a -> Int)
    -> (forall a. Eq a => a -> CallConv a -> Bool)
    -> (forall a. Ord a => CallConv a -> a)
    -> (forall a. Ord a => CallConv a -> a)
    -> (forall a. Num a => CallConv a -> a)
    -> (forall a. Num a => CallConv a -> a)
    -> Foldable CallConv
    forall a. Eq a => a -> CallConv a -> Bool
    forall a. Num a => CallConv a -> a
    forall a. Ord a => CallConv a -> a
    forall m. Monoid m => CallConv m -> m
    forall a. CallConv a -> Bool
    forall a. CallConv a -> Int
    forall a. CallConv a -> [a]
    forall a. (a -> a -> a) -> CallConv a -> a
    forall m a. Monoid m => (a -> m) -> CallConv a -> m
    forall b a. (b -> a -> b) -> b -> CallConv a -> b
    forall a b. (a -> b -> b) -> b -> CallConv a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => CallConv m -> m
    fold :: forall m. Monoid m => CallConv m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> CallConv a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> CallConv a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> CallConv a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> CallConv a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> CallConv a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> CallConv a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> CallConv a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> CallConv a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> CallConv a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> CallConv a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> CallConv a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> CallConv a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> CallConv a -> a
    foldr1 :: forall a. (a -> a -> a) -> CallConv a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> CallConv a -> a
    foldl1 :: forall a. (a -> a -> a) -> CallConv a -> a
    $ctoList :: forall a. CallConv a -> [a]
    toList :: forall a. CallConv a -> [a]
    $cnull :: forall a. CallConv a -> Bool
    null :: forall a. CallConv a -> Bool
    $clength :: forall a. CallConv a -> Int
    length :: forall a. CallConv a -> Int
    $celem :: forall a. Eq a => a -> CallConv a -> Bool
    elem :: forall a. Eq a => a -> CallConv a -> Bool
    $cmaximum :: forall a. Ord a => CallConv a -> a
    maximum :: forall a. Ord a => CallConv a -> a
    $cminimum :: forall a. Ord a => CallConv a -> a
    minimum :: forall a. Ord a => CallConv a -> a
    $csum :: forall a. Num a => CallConv a -> a
    sum :: forall a. Num a => CallConv a -> a
    $cproduct :: forall a. Num a => CallConv a -> a
    product :: forall a. Num a => CallConv a -> a
    Foldable,Functor CallConv
    Foldable CallConv
    (Functor CallConv, Foldable CallConv) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> CallConv a -> f (CallConv b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        CallConv (f a) -> f (CallConv a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> CallConv a -> m (CallConv b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        CallConv (m a) -> m (CallConv a))
    -> Traversable CallConv
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => CallConv (m a) -> m (CallConv a)
    forall (f :: * -> *) a.
    Applicative f =>
    CallConv (f a) -> f (CallConv a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CallConv a -> m (CallConv b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CallConv a -> f (CallConv b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CallConv a -> f (CallConv b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CallConv a -> f (CallConv b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    CallConv (f a) -> f (CallConv a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    CallConv (f a) -> f (CallConv a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CallConv a -> m (CallConv b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CallConv a -> m (CallConv b)
    $csequence :: forall (m :: * -> *) a. Monad m => CallConv (m a) -> m (CallConv a)
    sequence :: forall (m :: * -> *) a. Monad m => CallConv (m a) -> m (CallConv a)
    Traversable,(forall a b. (a -> b) -> CallConv a -> CallConv b)
    -> (forall a b. a -> CallConv b -> CallConv a) -> Functor CallConv
    forall a b. a -> CallConv b -> CallConv a
    forall a b. (a -> b) -> CallConv a -> CallConv b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> CallConv a -> CallConv b
    fmap :: forall a b. (a -> b) -> CallConv a -> CallConv b
    $c<$ :: forall a b. a -> CallConv b -> CallConv a
    <$ :: forall a b. a -> CallConv b -> CallConv a
    Functor,(forall x. CallConv l -> Rep (CallConv l) x)
    -> (forall x. Rep (CallConv l) x -> CallConv l)
    -> Generic (CallConv l)
    forall x. Rep (CallConv l) x -> CallConv l
    forall x. CallConv l -> Rep (CallConv l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (CallConv l) x -> CallConv l
    forall l x. CallConv l -> Rep (CallConv l) x
    $cfrom :: forall l x. CallConv l -> Rep (CallConv l) x
    from :: forall x. CallConv l -> Rep (CallConv l) x
    $cto :: forall l x. Rep (CallConv l) x -> CallConv l
    to :: forall x. Rep (CallConv l) x -> CallConv l
    Generic)

    -- | A top level options pragma, preceding the module header.
    data ModulePragma l
        = LanguagePragma   l [Name l]  -- ^ LANGUAGE pragma
        | OptionsPragma    l (Maybe Tool) String
                            -- ^ OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC
        | AnnModulePragma  l (Annotation l)
                            -- ^ ANN pragma with module scope
      deriving (ModulePragma l -> ModulePragma l -> Bool
    (ModulePragma l -> ModulePragma l -> Bool)
    -> (ModulePragma l -> ModulePragma l -> Bool)
    -> Eq (ModulePragma l)
    forall l. Eq l => ModulePragma l -> ModulePragma l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => ModulePragma l -> ModulePragma l -> Bool
    == :: ModulePragma l -> ModulePragma l -> Bool
    $c/= :: forall l. Eq l => ModulePragma l -> ModulePragma l -> Bool
    /= :: ModulePragma l -> ModulePragma l -> Bool
    Eq,Eq (ModulePragma l)
    Eq (ModulePragma l) =>
    (ModulePragma l -> ModulePragma l -> Ordering)
    -> (ModulePragma l -> ModulePragma l -> Bool)
    -> (ModulePragma l -> ModulePragma l -> Bool)
    -> (ModulePragma l -> ModulePragma l -> Bool)
    -> (ModulePragma l -> ModulePragma l -> Bool)
    -> (ModulePragma l -> ModulePragma l -> ModulePragma l)
    -> (ModulePragma l -> ModulePragma l -> ModulePragma l)
    -> Ord (ModulePragma l)
    ModulePragma l -> ModulePragma l -> Bool
    ModulePragma l -> ModulePragma l -> Ordering
    ModulePragma l -> ModulePragma l -> ModulePragma l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (ModulePragma l)
    forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
    forall l. Ord l => ModulePragma l -> ModulePragma l -> Ordering
    forall l.
    Ord l =>
    ModulePragma l -> ModulePragma l -> ModulePragma l
    $ccompare :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Ordering
    compare :: ModulePragma l -> ModulePragma l -> Ordering
    $c< :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
    < :: ModulePragma l -> ModulePragma l -> Bool
    $c<= :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
    <= :: ModulePragma l -> ModulePragma l -> Bool
    $c> :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
    > :: ModulePragma l -> ModulePragma l -> Bool
    $c>= :: forall l. Ord l => ModulePragma l -> ModulePragma l -> Bool
    >= :: ModulePragma l -> ModulePragma l -> Bool
    $cmax :: forall l.
    Ord l =>
    ModulePragma l -> ModulePragma l -> ModulePragma l
    max :: ModulePragma l -> ModulePragma l -> ModulePragma l
    $cmin :: forall l.
    Ord l =>
    ModulePragma l -> ModulePragma l -> ModulePragma l
    min :: ModulePragma l -> ModulePragma l -> ModulePragma l
    Ord,Int -> ModulePragma l -> ShowS
    [ModulePragma l] -> ShowS
    ModulePragma l -> String
    (Int -> ModulePragma l -> ShowS)
    -> (ModulePragma l -> String)
    -> ([ModulePragma l] -> ShowS)
    -> Show (ModulePragma l)
    forall l. Show l => Int -> ModulePragma l -> ShowS
    forall l. Show l => [ModulePragma l] -> ShowS
    forall l. Show l => ModulePragma l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> ModulePragma l -> ShowS
    showsPrec :: Int -> ModulePragma l -> ShowS
    $cshow :: forall l. Show l => ModulePragma l -> String
    show :: ModulePragma l -> String
    $cshowList :: forall l. Show l => [ModulePragma l] -> ShowS
    showList :: [ModulePragma l] -> ShowS
    Show,Typeable,Typeable (ModulePragma l)
    Typeable (ModulePragma l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ModulePragma l))
    -> (ModulePragma l -> Constr)
    -> (ModulePragma l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ModulePragma l)))
    -> ((forall b. Data b => b -> b)
        -> ModulePragma l -> ModulePragma l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> ModulePragma l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> ModulePragma l -> m (ModulePragma l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ModulePragma l -> m (ModulePragma l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ModulePragma l -> m (ModulePragma l))
    -> Data (ModulePragma l)
    ModulePragma l -> Constr
    ModulePragma l -> DataType
    (forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l
    forall l. Data l => Typeable (ModulePragma l)
    forall l. Data l => ModulePragma l -> Constr
    forall l. Data l => ModulePragma l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ModulePragma l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModulePragma l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModulePragma l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u
    forall u. (forall d. Data d => d -> u) -> ModulePragma l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModulePragma l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModulePragma l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModulePragma l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModulePragma l)
    $ctoConstr :: forall l. Data l => ModulePragma l -> Constr
    toConstr :: ModulePragma l -> Constr
    $cdataTypeOf :: forall l. Data l => ModulePragma l -> DataType
    dataTypeOf :: ModulePragma l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModulePragma l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModulePragma l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l
    gmapT :: (forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> ModulePragma l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ModulePragma l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModulePragma l -> m (ModulePragma l)
    Data,(forall m. Monoid m => ModulePragma m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ModulePragma a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ModulePragma a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ModulePragma a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ModulePragma a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ModulePragma a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ModulePragma a -> b)
    -> (forall a. (a -> a -> a) -> ModulePragma a -> a)
    -> (forall a. (a -> a -> a) -> ModulePragma a -> a)
    -> (forall a. ModulePragma a -> [a])
    -> (forall a. ModulePragma a -> Bool)
    -> (forall a. ModulePragma a -> Int)
    -> (forall a. Eq a => a -> ModulePragma a -> Bool)
    -> (forall a. Ord a => ModulePragma a -> a)
    -> (forall a. Ord a => ModulePragma a -> a)
    -> (forall a. Num a => ModulePragma a -> a)
    -> (forall a. Num a => ModulePragma a -> a)
    -> Foldable ModulePragma
    forall a. Eq a => a -> ModulePragma a -> Bool
    forall a. Num a => ModulePragma a -> a
    forall a. Ord a => ModulePragma a -> a
    forall m. Monoid m => ModulePragma m -> m
    forall a. ModulePragma a -> Bool
    forall a. ModulePragma a -> Int
    forall a. ModulePragma a -> [a]
    forall a. (a -> a -> a) -> ModulePragma a -> a
    forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
    forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
    forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ModulePragma m -> m
    fold :: forall m. Monoid m => ModulePragma m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ModulePragma a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ModulePragma a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ModulePragma a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ModulePragma a -> a
    foldr1 :: forall a. (a -> a -> a) -> ModulePragma a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ModulePragma a -> a
    foldl1 :: forall a. (a -> a -> a) -> ModulePragma a -> a
    $ctoList :: forall a. ModulePragma a -> [a]
    toList :: forall a. ModulePragma a -> [a]
    $cnull :: forall a. ModulePragma a -> Bool
    null :: forall a. ModulePragma a -> Bool
    $clength :: forall a. ModulePragma a -> Int
    length :: forall a. ModulePragma a -> Int
    $celem :: forall a. Eq a => a -> ModulePragma a -> Bool
    elem :: forall a. Eq a => a -> ModulePragma a -> Bool
    $cmaximum :: forall a. Ord a => ModulePragma a -> a
    maximum :: forall a. Ord a => ModulePragma a -> a
    $cminimum :: forall a. Ord a => ModulePragma a -> a
    minimum :: forall a. Ord a => ModulePragma a -> a
    $csum :: forall a. Num a => ModulePragma a -> a
    sum :: forall a. Num a => ModulePragma a -> a
    $cproduct :: forall a. Num a => ModulePragma a -> a
    product :: forall a. Num a => ModulePragma a -> a
    Foldable,Functor ModulePragma
    Foldable ModulePragma
    (Functor ModulePragma, Foldable ModulePragma) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> ModulePragma a -> f (ModulePragma b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        ModulePragma (f a) -> f (ModulePragma a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> ModulePragma a -> m (ModulePragma b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        ModulePragma (m a) -> m (ModulePragma a))
    -> Traversable ModulePragma
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    ModulePragma (m a) -> m (ModulePragma a)
    forall (f :: * -> *) a.
    Applicative f =>
    ModulePragma (f a) -> f (ModulePragma a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModulePragma a -> m (ModulePragma b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModulePragma a -> f (ModulePragma b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModulePragma a -> f (ModulePragma b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ModulePragma a -> f (ModulePragma b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ModulePragma (f a) -> f (ModulePragma a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    ModulePragma (f a) -> f (ModulePragma a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModulePragma a -> m (ModulePragma b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ModulePragma a -> m (ModulePragma b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    ModulePragma (m a) -> m (ModulePragma a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    ModulePragma (m a) -> m (ModulePragma a)
    Traversable,(forall a b. (a -> b) -> ModulePragma a -> ModulePragma b)
    -> (forall a b. a -> ModulePragma b -> ModulePragma a)
    -> Functor ModulePragma
    forall a b. a -> ModulePragma b -> ModulePragma a
    forall a b. (a -> b) -> ModulePragma a -> ModulePragma b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ModulePragma a -> ModulePragma b
    fmap :: forall a b. (a -> b) -> ModulePragma a -> ModulePragma b
    $c<$ :: forall a b. a -> ModulePragma b -> ModulePragma a
    <$ :: forall a b. a -> ModulePragma b -> ModulePragma a
    Functor,(forall x. ModulePragma l -> Rep (ModulePragma l) x)
    -> (forall x. Rep (ModulePragma l) x -> ModulePragma l)
    -> Generic (ModulePragma l)
    forall x. Rep (ModulePragma l) x -> ModulePragma l
    forall x. ModulePragma l -> Rep (ModulePragma l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (ModulePragma l) x -> ModulePragma l
    forall l x. ModulePragma l -> Rep (ModulePragma l) x
    $cfrom :: forall l x. ModulePragma l -> Rep (ModulePragma l) x
    from :: forall x. ModulePragma l -> Rep (ModulePragma l) x
    $cto :: forall l x. Rep (ModulePragma l) x -> ModulePragma l
    to :: forall x. Rep (ModulePragma l) x -> ModulePragma l
    Generic)

    -- | Recognised tools for OPTIONS pragmas.
    data Tool = GHC | HUGS | NHC98 | YHC | HADDOCK | UnknownTool String
      deriving (Tool -> Tool -> Bool
    (Tool -> Tool -> Bool) -> (Tool -> Tool -> Bool) -> Eq Tool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Tool -> Tool -> Bool
    == :: Tool -> Tool -> Bool
    $c/= :: Tool -> Tool -> Bool
    /= :: Tool -> Tool -> Bool
    Eq,Eq Tool
    Eq Tool =>
    (Tool -> Tool -> Ordering)
    -> (Tool -> Tool -> Bool)
    -> (Tool -> Tool -> Bool)
    -> (Tool -> Tool -> Bool)
    -> (Tool -> Tool -> Bool)
    -> (Tool -> Tool -> Tool)
    -> (Tool -> Tool -> Tool)
    -> Ord Tool
    Tool -> Tool -> Bool
    Tool -> Tool -> Ordering
    Tool -> Tool -> Tool
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Tool -> Tool -> Ordering
    compare :: Tool -> Tool -> Ordering
    $c< :: Tool -> Tool -> Bool
    < :: Tool -> Tool -> Bool
    $c<= :: Tool -> Tool -> Bool
    <= :: Tool -> Tool -> Bool
    $c> :: Tool -> Tool -> Bool
    > :: Tool -> Tool -> Bool
    $c>= :: Tool -> Tool -> Bool
    >= :: Tool -> Tool -> Bool
    $cmax :: Tool -> Tool -> Tool
    max :: Tool -> Tool -> Tool
    $cmin :: Tool -> Tool -> Tool
    min :: Tool -> Tool -> Tool
    Ord,Int -> Tool -> ShowS
    [Tool] -> ShowS
    Tool -> String
    (Int -> Tool -> ShowS)
    -> (Tool -> String) -> ([Tool] -> ShowS) -> Show Tool
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Tool -> ShowS
    showsPrec :: Int -> Tool -> ShowS
    $cshow :: Tool -> String
    show :: Tool -> String
    $cshowList :: [Tool] -> ShowS
    showList :: [Tool] -> ShowS
    Show,Typeable,Typeable Tool
    Typeable Tool =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Tool -> c Tool)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Tool)
    -> (Tool -> Constr)
    -> (Tool -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Tool))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool))
    -> ((forall b. Data b => b -> b) -> Tool -> Tool)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Tool -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Tool -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Tool -> m Tool)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Tool -> m Tool)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Tool -> m Tool)
    -> Data Tool
    Tool -> Constr
    Tool -> DataType
    (forall b. Data b => b -> b) -> Tool -> Tool
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Tool -> u
    forall u. (forall d. Data d => d -> u) -> Tool -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Tool
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tool -> c Tool
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Tool)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tool -> c Tool
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tool -> c Tool
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Tool
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Tool
    $ctoConstr :: Tool -> Constr
    toConstr :: Tool -> Constr
    $cdataTypeOf :: Tool -> DataType
    dataTypeOf :: Tool -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Tool)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Tool)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool)
    $cgmapT :: (forall b. Data b => b -> b) -> Tool -> Tool
    gmapT :: (forall b. Data b => b -> b) -> Tool -> Tool
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Tool -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Tool -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tool -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tool -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tool -> m Tool
    Data,(forall x. Tool -> Rep Tool x)
    -> (forall x. Rep Tool x -> Tool) -> Generic Tool
    forall x. Rep Tool x -> Tool
    forall x. Tool -> Rep Tool x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Tool -> Rep Tool x
    from :: forall x. Tool -> Rep Tool x
    $cto :: forall x. Rep Tool x -> Tool
    to :: forall x. Rep Tool x -> Tool
    Generic)

    -- | Recognised overlaps for overlap pragmas.
    data Overlap l
        = NoOverlap l   -- ^ NO_OVERLAP pragma
        | Overlap l     -- ^ OVERLAP pragma
        | Overlapping l
        | Overlaps l
        | Overlappable l
        | Incoherent l  -- ^ INCOHERENT pragma
      deriving (Overlap l -> Overlap l -> Bool
    (Overlap l -> Overlap l -> Bool)
    -> (Overlap l -> Overlap l -> Bool) -> Eq (Overlap l)
    forall l. Eq l => Overlap l -> Overlap l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Overlap l -> Overlap l -> Bool
    == :: Overlap l -> Overlap l -> Bool
    $c/= :: forall l. Eq l => Overlap l -> Overlap l -> Bool
    /= :: Overlap l -> Overlap l -> Bool
    Eq,Eq (Overlap l)
    Eq (Overlap l) =>
    (Overlap l -> Overlap l -> Ordering)
    -> (Overlap l -> Overlap l -> Bool)
    -> (Overlap l -> Overlap l -> Bool)
    -> (Overlap l -> Overlap l -> Bool)
    -> (Overlap l -> Overlap l -> Bool)
    -> (Overlap l -> Overlap l -> Overlap l)
    -> (Overlap l -> Overlap l -> Overlap l)
    -> Ord (Overlap l)
    Overlap l -> Overlap l -> Bool
    Overlap l -> Overlap l -> Ordering
    Overlap l -> Overlap l -> Overlap l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Overlap l)
    forall l. Ord l => Overlap l -> Overlap l -> Bool
    forall l. Ord l => Overlap l -> Overlap l -> Ordering
    forall l. Ord l => Overlap l -> Overlap l -> Overlap l
    $ccompare :: forall l. Ord l => Overlap l -> Overlap l -> Ordering
    compare :: Overlap l -> Overlap l -> Ordering
    $c< :: forall l. Ord l => Overlap l -> Overlap l -> Bool
    < :: Overlap l -> Overlap l -> Bool
    $c<= :: forall l. Ord l => Overlap l -> Overlap l -> Bool
    <= :: Overlap l -> Overlap l -> Bool
    $c> :: forall l. Ord l => Overlap l -> Overlap l -> Bool
    > :: Overlap l -> Overlap l -> Bool
    $c>= :: forall l. Ord l => Overlap l -> Overlap l -> Bool
    >= :: Overlap l -> Overlap l -> Bool
    $cmax :: forall l. Ord l => Overlap l -> Overlap l -> Overlap l
    max :: Overlap l -> Overlap l -> Overlap l
    $cmin :: forall l. Ord l => Overlap l -> Overlap l -> Overlap l
    min :: Overlap l -> Overlap l -> Overlap l
    Ord,Int -> Overlap l -> ShowS
    [Overlap l] -> ShowS
    Overlap l -> String
    (Int -> Overlap l -> ShowS)
    -> (Overlap l -> String)
    -> ([Overlap l] -> ShowS)
    -> Show (Overlap l)
    forall l. Show l => Int -> Overlap l -> ShowS
    forall l. Show l => [Overlap l] -> ShowS
    forall l. Show l => Overlap l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Overlap l -> ShowS
    showsPrec :: Int -> Overlap l -> ShowS
    $cshow :: forall l. Show l => Overlap l -> String
    show :: Overlap l -> String
    $cshowList :: forall l. Show l => [Overlap l] -> ShowS
    showList :: [Overlap l] -> ShowS
    Show,Typeable,Typeable (Overlap l)
    Typeable (Overlap l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Overlap l -> c (Overlap l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Overlap l))
    -> (Overlap l -> Constr)
    -> (Overlap l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Overlap l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Overlap l)))
    -> ((forall b. Data b => b -> b) -> Overlap l -> Overlap l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Overlap l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Overlap l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Overlap l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Overlap l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l))
    -> Data (Overlap l)
    Overlap l -> Constr
    Overlap l -> DataType
    (forall b. Data b => b -> b) -> Overlap l -> Overlap l
    forall l. Data l => Typeable (Overlap l)
    forall l. Data l => Overlap l -> Constr
    forall l. Data l => Overlap l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Overlap l -> Overlap l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Overlap l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Overlap l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Overlap l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overlap l -> c (Overlap l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Overlap l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Overlap l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Overlap l -> u
    forall u. (forall d. Data d => d -> u) -> Overlap l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Overlap l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overlap l -> c (Overlap l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Overlap l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Overlap l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overlap l -> c (Overlap l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overlap l -> c (Overlap l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Overlap l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Overlap l)
    $ctoConstr :: forall l. Data l => Overlap l -> Constr
    toConstr :: Overlap l -> Constr
    $cdataTypeOf :: forall l. Data l => Overlap l -> DataType
    dataTypeOf :: Overlap l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Overlap l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Overlap l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Overlap l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Overlap l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Overlap l -> Overlap l
    gmapT :: (forall b. Data b => b -> b) -> Overlap l -> Overlap l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overlap l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Overlap l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Overlap l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Overlap l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Overlap l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l)
    Data,(forall m. Monoid m => Overlap m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Overlap a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Overlap a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Overlap a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Overlap a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Overlap a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Overlap a -> b)
    -> (forall a. (a -> a -> a) -> Overlap a -> a)
    -> (forall a. (a -> a -> a) -> Overlap a -> a)
    -> (forall a. Overlap a -> [a])
    -> (forall a. Overlap a -> Bool)
    -> (forall a. Overlap a -> Int)
    -> (forall a. Eq a => a -> Overlap a -> Bool)
    -> (forall a. Ord a => Overlap a -> a)
    -> (forall a. Ord a => Overlap a -> a)
    -> (forall a. Num a => Overlap a -> a)
    -> (forall a. Num a => Overlap a -> a)
    -> Foldable Overlap
    forall a. Eq a => a -> Overlap a -> Bool
    forall a. Num a => Overlap a -> a
    forall a. Ord a => Overlap a -> a
    forall m. Monoid m => Overlap m -> m
    forall a. Overlap a -> Bool
    forall a. Overlap a -> Int
    forall a. Overlap a -> [a]
    forall a. (a -> a -> a) -> Overlap a -> a
    forall m a. Monoid m => (a -> m) -> Overlap a -> m
    forall b a. (b -> a -> b) -> b -> Overlap a -> b
    forall a b. (a -> b -> b) -> b -> Overlap a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Overlap m -> m
    fold :: forall m. Monoid m => Overlap m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Overlap a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Overlap a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Overlap a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Overlap a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Overlap a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Overlap a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Overlap a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Overlap a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Overlap a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Overlap a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Overlap a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Overlap a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Overlap a -> a
    foldr1 :: forall a. (a -> a -> a) -> Overlap a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Overlap a -> a
    foldl1 :: forall a. (a -> a -> a) -> Overlap a -> a
    $ctoList :: forall a. Overlap a -> [a]
    toList :: forall a. Overlap a -> [a]
    $cnull :: forall a. Overlap a -> Bool
    null :: forall a. Overlap a -> Bool
    $clength :: forall a. Overlap a -> Int
    length :: forall a. Overlap a -> Int
    $celem :: forall a. Eq a => a -> Overlap a -> Bool
    elem :: forall a. Eq a => a -> Overlap a -> Bool
    $cmaximum :: forall a. Ord a => Overlap a -> a
    maximum :: forall a. Ord a => Overlap a -> a
    $cminimum :: forall a. Ord a => Overlap a -> a
    minimum :: forall a. Ord a => Overlap a -> a
    $csum :: forall a. Num a => Overlap a -> a
    sum :: forall a. Num a => Overlap a -> a
    $cproduct :: forall a. Num a => Overlap a -> a
    product :: forall a. Num a => Overlap a -> a
    Foldable,Functor Overlap
    Foldable Overlap
    (Functor Overlap, Foldable Overlap) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Overlap a -> f (Overlap b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Overlap (f a) -> f (Overlap a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Overlap a -> m (Overlap b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Overlap (m a) -> m (Overlap a))
    -> Traversable Overlap
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Overlap (m a) -> m (Overlap a)
    forall (f :: * -> *) a.
    Applicative f =>
    Overlap (f a) -> f (Overlap a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Overlap a -> m (Overlap b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Overlap a -> f (Overlap b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Overlap a -> f (Overlap b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Overlap a -> f (Overlap b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Overlap (f a) -> f (Overlap a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Overlap (f a) -> f (Overlap a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Overlap a -> m (Overlap b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Overlap a -> m (Overlap b)
    $csequence :: forall (m :: * -> *) a. Monad m => Overlap (m a) -> m (Overlap a)
    sequence :: forall (m :: * -> *) a. Monad m => Overlap (m a) -> m (Overlap a)
    Traversable,(forall a b. (a -> b) -> Overlap a -> Overlap b)
    -> (forall a b. a -> Overlap b -> Overlap a) -> Functor Overlap
    forall a b. a -> Overlap b -> Overlap a
    forall a b. (a -> b) -> Overlap a -> Overlap b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Overlap a -> Overlap b
    fmap :: forall a b. (a -> b) -> Overlap a -> Overlap b
    $c<$ :: forall a b. a -> Overlap b -> Overlap a
    <$ :: forall a b. a -> Overlap b -> Overlap a
    Functor,(forall x. Overlap l -> Rep (Overlap l) x)
    -> (forall x. Rep (Overlap l) x -> Overlap l)
    -> Generic (Overlap l)
    forall x. Rep (Overlap l) x -> Overlap l
    forall x. Overlap l -> Rep (Overlap l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Overlap l) x -> Overlap l
    forall l x. Overlap l -> Rep (Overlap l) x
    $cfrom :: forall l x. Overlap l -> Rep (Overlap l) x
    from :: forall x. Overlap l -> Rep (Overlap l) x
    $cto :: forall l x. Rep (Overlap l) x -> Overlap l
    to :: forall x. Rep (Overlap l) x -> Overlap l
    Generic)

    -- | Activation clause of a RULES pragma.
    data Activation l
        = ActiveFrom   l Int
        | ActiveUntil  l Int
      deriving (Activation l -> Activation l -> Bool
    (Activation l -> Activation l -> Bool)
    -> (Activation l -> Activation l -> Bool) -> Eq (Activation l)
    forall l. Eq l => Activation l -> Activation l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Activation l -> Activation l -> Bool
    == :: Activation l -> Activation l -> Bool
    $c/= :: forall l. Eq l => Activation l -> Activation l -> Bool
    /= :: Activation l -> Activation l -> Bool
    Eq,Eq (Activation l)
    Eq (Activation l) =>
    (Activation l -> Activation l -> Ordering)
    -> (Activation l -> Activation l -> Bool)
    -> (Activation l -> Activation l -> Bool)
    -> (Activation l -> Activation l -> Bool)
    -> (Activation l -> Activation l -> Bool)
    -> (Activation l -> Activation l -> Activation l)
    -> (Activation l -> Activation l -> Activation l)
    -> Ord (Activation l)
    Activation l -> Activation l -> Bool
    Activation l -> Activation l -> Ordering
    Activation l -> Activation l -> Activation l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Activation l)
    forall l. Ord l => Activation l -> Activation l -> Bool
    forall l. Ord l => Activation l -> Activation l -> Ordering
    forall l. Ord l => Activation l -> Activation l -> Activation l
    $ccompare :: forall l. Ord l => Activation l -> Activation l -> Ordering
    compare :: Activation l -> Activation l -> Ordering
    $c< :: forall l. Ord l => Activation l -> Activation l -> Bool
    < :: Activation l -> Activation l -> Bool
    $c<= :: forall l. Ord l => Activation l -> Activation l -> Bool
    <= :: Activation l -> Activation l -> Bool
    $c> :: forall l. Ord l => Activation l -> Activation l -> Bool
    > :: Activation l -> Activation l -> Bool
    $c>= :: forall l. Ord l => Activation l -> Activation l -> Bool
    >= :: Activation l -> Activation l -> Bool
    $cmax :: forall l. Ord l => Activation l -> Activation l -> Activation l
    max :: Activation l -> Activation l -> Activation l
    $cmin :: forall l. Ord l => Activation l -> Activation l -> Activation l
    min :: Activation l -> Activation l -> Activation l
    Ord,Int -> Activation l -> ShowS
    [Activation l] -> ShowS
    Activation l -> String
    (Int -> Activation l -> ShowS)
    -> (Activation l -> String)
    -> ([Activation l] -> ShowS)
    -> Show (Activation l)
    forall l. Show l => Int -> Activation l -> ShowS
    forall l. Show l => [Activation l] -> ShowS
    forall l. Show l => Activation l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Activation l -> ShowS
    showsPrec :: Int -> Activation l -> ShowS
    $cshow :: forall l. Show l => Activation l -> String
    show :: Activation l -> String
    $cshowList :: forall l. Show l => [Activation l] -> ShowS
    showList :: [Activation l] -> ShowS
    Show,Typeable,Typeable (Activation l)
    Typeable (Activation l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Activation l -> c (Activation l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Activation l))
    -> (Activation l -> Constr)
    -> (Activation l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Activation l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Activation l)))
    -> ((forall b. Data b => b -> b) -> Activation l -> Activation l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Activation l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Activation l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Activation l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Activation l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Activation l -> m (Activation l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Activation l -> m (Activation l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Activation l -> m (Activation l))
    -> Data (Activation l)
    Activation l -> Constr
    Activation l -> DataType
    (forall b. Data b => b -> b) -> Activation l -> Activation l
    forall l. Data l => Typeable (Activation l)
    forall l. Data l => Activation l -> Constr
    forall l. Data l => Activation l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Activation l -> Activation l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Activation l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Activation l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Activation l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Activation l -> c (Activation l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Activation l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Activation l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Activation l -> u
    forall u. (forall d. Data d => d -> u) -> Activation l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Activation l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Activation l -> c (Activation l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Activation l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Activation l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Activation l -> c (Activation l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Activation l -> c (Activation l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Activation l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Activation l)
    $ctoConstr :: forall l. Data l => Activation l -> Constr
    toConstr :: Activation l -> Constr
    $cdataTypeOf :: forall l. Data l => Activation l -> DataType
    dataTypeOf :: Activation l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Activation l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Activation l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Activation l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Activation l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Activation l -> Activation l
    gmapT :: (forall b. Data b => b -> b) -> Activation l -> Activation l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Activation l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> Activation l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Activation l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Activation l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Activation l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Activation l -> m (Activation l)
    Data,(forall m. Monoid m => Activation m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Activation a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Activation a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Activation a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Activation a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Activation a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Activation a -> b)
    -> (forall a. (a -> a -> a) -> Activation a -> a)
    -> (forall a. (a -> a -> a) -> Activation a -> a)
    -> (forall a. Activation a -> [a])
    -> (forall a. Activation a -> Bool)
    -> (forall a. Activation a -> Int)
    -> (forall a. Eq a => a -> Activation a -> Bool)
    -> (forall a. Ord a => Activation a -> a)
    -> (forall a. Ord a => Activation a -> a)
    -> (forall a. Num a => Activation a -> a)
    -> (forall a. Num a => Activation a -> a)
    -> Foldable Activation
    forall a. Eq a => a -> Activation a -> Bool
    forall a. Num a => Activation a -> a
    forall a. Ord a => Activation a -> a
    forall m. Monoid m => Activation m -> m
    forall a. Activation a -> Bool
    forall a. Activation a -> Int
    forall a. Activation a -> [a]
    forall a. (a -> a -> a) -> Activation a -> a
    forall m a. Monoid m => (a -> m) -> Activation a -> m
    forall b a. (b -> a -> b) -> b -> Activation a -> b
    forall a b. (a -> b -> b) -> b -> Activation a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Activation m -> m
    fold :: forall m. Monoid m => Activation m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Activation a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Activation a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Activation a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Activation a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Activation a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Activation a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Activation a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Activation a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Activation a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Activation a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Activation a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Activation a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Activation a -> a
    foldr1 :: forall a. (a -> a -> a) -> Activation a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Activation a -> a
    foldl1 :: forall a. (a -> a -> a) -> Activation a -> a
    $ctoList :: forall a. Activation a -> [a]
    toList :: forall a. Activation a -> [a]
    $cnull :: forall a. Activation a -> Bool
    null :: forall a. Activation a -> Bool
    $clength :: forall a. Activation a -> Int
    length :: forall a. Activation a -> Int
    $celem :: forall a. Eq a => a -> Activation a -> Bool
    elem :: forall a. Eq a => a -> Activation a -> Bool
    $cmaximum :: forall a. Ord a => Activation a -> a
    maximum :: forall a. Ord a => Activation a -> a
    $cminimum :: forall a. Ord a => Activation a -> a
    minimum :: forall a. Ord a => Activation a -> a
    $csum :: forall a. Num a => Activation a -> a
    sum :: forall a. Num a => Activation a -> a
    $cproduct :: forall a. Num a => Activation a -> a
    product :: forall a. Num a => Activation a -> a
    Foldable,Functor Activation
    Foldable Activation
    (Functor Activation, Foldable Activation) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Activation a -> f (Activation b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Activation (f a) -> f (Activation a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Activation a -> m (Activation b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Activation (m a) -> m (Activation a))
    -> Traversable Activation
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    Activation (m a) -> m (Activation a)
    forall (f :: * -> *) a.
    Applicative f =>
    Activation (f a) -> f (Activation a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Activation a -> m (Activation b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Activation a -> f (Activation b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Activation a -> f (Activation b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Activation a -> f (Activation b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Activation (f a) -> f (Activation a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Activation (f a) -> f (Activation a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Activation a -> m (Activation b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Activation a -> m (Activation b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    Activation (m a) -> m (Activation a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Activation (m a) -> m (Activation a)
    Traversable,(forall a b. (a -> b) -> Activation a -> Activation b)
    -> (forall a b. a -> Activation b -> Activation a)
    -> Functor Activation
    forall a b. a -> Activation b -> Activation a
    forall a b. (a -> b) -> Activation a -> Activation b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Activation a -> Activation b
    fmap :: forall a b. (a -> b) -> Activation a -> Activation b
    $c<$ :: forall a b. a -> Activation b -> Activation a
    <$ :: forall a b. a -> Activation b -> Activation a
    Functor,(forall x. Activation l -> Rep (Activation l) x)
    -> (forall x. Rep (Activation l) x -> Activation l)
    -> Generic (Activation l)
    forall x. Rep (Activation l) x -> Activation l
    forall x. Activation l -> Rep (Activation l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Activation l) x -> Activation l
    forall l x. Activation l -> Rep (Activation l) x
    $cfrom :: forall l x. Activation l -> Rep (Activation l) x
    from :: forall x. Activation l -> Rep (Activation l) x
    $cto :: forall l x. Rep (Activation l) x -> Activation l
    to :: forall x. Rep (Activation l) x -> Activation l
    Generic)

    -- | The body of a RULES pragma.
    data Rule l
        = Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l)
      deriving (Rule l -> Rule l -> Bool
    (Rule l -> Rule l -> Bool)
    -> (Rule l -> Rule l -> Bool) -> Eq (Rule l)
    forall l. Eq l => Rule l -> Rule l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Rule l -> Rule l -> Bool
    == :: Rule l -> Rule l -> Bool
    $c/= :: forall l. Eq l => Rule l -> Rule l -> Bool
    /= :: Rule l -> Rule l -> Bool
    Eq,Eq (Rule l)
    Eq (Rule l) =>
    (Rule l -> Rule l -> Ordering)
    -> (Rule l -> Rule l -> Bool)
    -> (Rule l -> Rule l -> Bool)
    -> (Rule l -> Rule l -> Bool)
    -> (Rule l -> Rule l -> Bool)
    -> (Rule l -> Rule l -> Rule l)
    -> (Rule l -> Rule l -> Rule l)
    -> Ord (Rule l)
    Rule l -> Rule l -> Bool
    Rule l -> Rule l -> Ordering
    Rule l -> Rule l -> Rule l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Rule l)
    forall l. Ord l => Rule l -> Rule l -> Bool
    forall l. Ord l => Rule l -> Rule l -> Ordering
    forall l. Ord l => Rule l -> Rule l -> Rule l
    $ccompare :: forall l. Ord l => Rule l -> Rule l -> Ordering
    compare :: Rule l -> Rule l -> Ordering
    $c< :: forall l. Ord l => Rule l -> Rule l -> Bool
    < :: Rule l -> Rule l -> Bool
    $c<= :: forall l. Ord l => Rule l -> Rule l -> Bool
    <= :: Rule l -> Rule l -> Bool
    $c> :: forall l. Ord l => Rule l -> Rule l -> Bool
    > :: Rule l -> Rule l -> Bool
    $c>= :: forall l. Ord l => Rule l -> Rule l -> Bool
    >= :: Rule l -> Rule l -> Bool
    $cmax :: forall l. Ord l => Rule l -> Rule l -> Rule l
    max :: Rule l -> Rule l -> Rule l
    $cmin :: forall l. Ord l => Rule l -> Rule l -> Rule l
    min :: Rule l -> Rule l -> Rule l
    Ord,Int -> Rule l -> ShowS
    [Rule l] -> ShowS
    Rule l -> String
    (Int -> Rule l -> ShowS)
    -> (Rule l -> String) -> ([Rule l] -> ShowS) -> Show (Rule l)
    forall l. Show l => Int -> Rule l -> ShowS
    forall l. Show l => [Rule l] -> ShowS
    forall l. Show l => Rule l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Rule l -> ShowS
    showsPrec :: Int -> Rule l -> ShowS
    $cshow :: forall l. Show l => Rule l -> String
    show :: Rule l -> String
    $cshowList :: forall l. Show l => [Rule l] -> ShowS
    showList :: [Rule l] -> ShowS
    Show,Typeable,Typeable (Rule l)
    Typeable (Rule l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Rule l -> c (Rule l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Rule l))
    -> (Rule l -> Constr)
    -> (Rule l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Rule l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l)))
    -> ((forall b. Data b => b -> b) -> Rule l -> Rule l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Rule l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Rule l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Rule l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Rule l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Rule l -> m (Rule l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Rule l -> m (Rule l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Rule l -> m (Rule l))
    -> Data (Rule l)
    Rule l -> Constr
    Rule l -> DataType
    (forall b. Data b => b -> b) -> Rule l -> Rule l
    forall l. Data l => Typeable (Rule l)
    forall l. Data l => Rule l -> Constr
    forall l. Data l => Rule l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Rule l -> Rule l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Rule l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Rule l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rule l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rule l -> c (Rule l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rule l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Rule l -> u
    forall u. (forall d. Data d => d -> u) -> Rule l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rule l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rule l -> c (Rule l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rule l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rule l -> c (Rule l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Rule l -> c (Rule l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rule l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Rule l)
    $ctoConstr :: forall l. Data l => Rule l -> Constr
    toConstr :: Rule l -> Constr
    $cdataTypeOf :: forall l. Data l => Rule l -> DataType
    dataTypeOf :: Rule l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rule l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Rule l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Rule l -> Rule l
    gmapT :: (forall b. Data b => b -> b) -> Rule l -> Rule l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Rule l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Rule l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Rule l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rule l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rule l -> m (Rule l)
    Data,(forall m. Monoid m => Rule m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Rule a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Rule a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Rule a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Rule a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Rule a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Rule a -> b)
    -> (forall a. (a -> a -> a) -> Rule a -> a)
    -> (forall a. (a -> a -> a) -> Rule a -> a)
    -> (forall a. Rule a -> [a])
    -> (forall a. Rule a -> Bool)
    -> (forall a. Rule a -> Int)
    -> (forall a. Eq a => a -> Rule a -> Bool)
    -> (forall a. Ord a => Rule a -> a)
    -> (forall a. Ord a => Rule a -> a)
    -> (forall a. Num a => Rule a -> a)
    -> (forall a. Num a => Rule a -> a)
    -> Foldable Rule
    forall a. Eq a => a -> Rule a -> Bool
    forall a. Num a => Rule a -> a
    forall a. Ord a => Rule a -> a
    forall m. Monoid m => Rule m -> m
    forall a. Rule a -> Bool
    forall a. Rule a -> Int
    forall a. Rule a -> [a]
    forall a. (a -> a -> a) -> Rule a -> a
    forall m a. Monoid m => (a -> m) -> Rule a -> m
    forall b a. (b -> a -> b) -> b -> Rule a -> b
    forall a b. (a -> b -> b) -> b -> Rule a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Rule m -> m
    fold :: forall m. Monoid m => Rule m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Rule a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Rule a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Rule a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Rule a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Rule a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Rule a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Rule a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Rule a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Rule a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Rule a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Rule a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Rule a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Rule a -> a
    foldr1 :: forall a. (a -> a -> a) -> Rule a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Rule a -> a
    foldl1 :: forall a. (a -> a -> a) -> Rule a -> a
    $ctoList :: forall a. Rule a -> [a]
    toList :: forall a. Rule a -> [a]
    $cnull :: forall a. Rule a -> Bool
    null :: forall a. Rule a -> Bool
    $clength :: forall a. Rule a -> Int
    length :: forall a. Rule a -> Int
    $celem :: forall a. Eq a => a -> Rule a -> Bool
    elem :: forall a. Eq a => a -> Rule a -> Bool
    $cmaximum :: forall a. Ord a => Rule a -> a
    maximum :: forall a. Ord a => Rule a -> a
    $cminimum :: forall a. Ord a => Rule a -> a
    minimum :: forall a. Ord a => Rule a -> a
    $csum :: forall a. Num a => Rule a -> a
    sum :: forall a. Num a => Rule a -> a
    $cproduct :: forall a. Num a => Rule a -> a
    product :: forall a. Num a => Rule a -> a
    Foldable,Functor Rule
    Foldable Rule
    (Functor Rule, Foldable Rule) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Rule a -> f (Rule b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Rule (f a) -> f (Rule a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Rule a -> m (Rule b))
    -> (forall (m :: * -> *) a. Monad m => Rule (m a) -> m (Rule a))
    -> Traversable Rule
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Rule (m a) -> m (Rule a)
    forall (f :: * -> *) a. Applicative f => Rule (f a) -> f (Rule a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Rule a -> m (Rule b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Rule a -> f (Rule b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Rule a -> f (Rule b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Rule a -> f (Rule b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Rule (f a) -> f (Rule a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Rule (f a) -> f (Rule a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Rule a -> m (Rule b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Rule a -> m (Rule b)
    $csequence :: forall (m :: * -> *) a. Monad m => Rule (m a) -> m (Rule a)
    sequence :: forall (m :: * -> *) a. Monad m => Rule (m a) -> m (Rule a)
    Traversable,(forall a b. (a -> b) -> Rule a -> Rule b)
    -> (forall a b. a -> Rule b -> Rule a) -> Functor Rule
    forall a b. a -> Rule b -> Rule a
    forall a b. (a -> b) -> Rule a -> Rule b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Rule a -> Rule b
    fmap :: forall a b. (a -> b) -> Rule a -> Rule b
    $c<$ :: forall a b. a -> Rule b -> Rule a
    <$ :: forall a b. a -> Rule b -> Rule a
    Functor,(forall x. Rule l -> Rep (Rule l) x)
    -> (forall x. Rep (Rule l) x -> Rule l) -> Generic (Rule l)
    forall x. Rep (Rule l) x -> Rule l
    forall x. Rule l -> Rep (Rule l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Rule l) x -> Rule l
    forall l x. Rule l -> Rep (Rule l) x
    $cfrom :: forall l x. Rule l -> Rep (Rule l) x
    from :: forall x. Rule l -> Rep (Rule l) x
    $cto :: forall l x. Rep (Rule l) x -> Rule l
    to :: forall x. Rep (Rule l) x -> Rule l
    Generic)

    -- | Variables used in a RULES pragma, optionally annotated with types
    data RuleVar l
        = RuleVar l (Name l)
        | TypedRuleVar l (Name l) (Type l)
      deriving (RuleVar l -> RuleVar l -> Bool
    (RuleVar l -> RuleVar l -> Bool)
    -> (RuleVar l -> RuleVar l -> Bool) -> Eq (RuleVar l)
    forall l. Eq l => RuleVar l -> RuleVar l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => RuleVar l -> RuleVar l -> Bool
    == :: RuleVar l -> RuleVar l -> Bool
    $c/= :: forall l. Eq l => RuleVar l -> RuleVar l -> Bool
    /= :: RuleVar l -> RuleVar l -> Bool
    Eq,Eq (RuleVar l)
    Eq (RuleVar l) =>
    (RuleVar l -> RuleVar l -> Ordering)
    -> (RuleVar l -> RuleVar l -> Bool)
    -> (RuleVar l -> RuleVar l -> Bool)
    -> (RuleVar l -> RuleVar l -> Bool)
    -> (RuleVar l -> RuleVar l -> Bool)
    -> (RuleVar l -> RuleVar l -> RuleVar l)
    -> (RuleVar l -> RuleVar l -> RuleVar l)
    -> Ord (RuleVar l)
    RuleVar l -> RuleVar l -> Bool
    RuleVar l -> RuleVar l -> Ordering
    RuleVar l -> RuleVar l -> RuleVar l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (RuleVar l)
    forall l. Ord l => RuleVar l -> RuleVar l -> Bool
    forall l. Ord l => RuleVar l -> RuleVar l -> Ordering
    forall l. Ord l => RuleVar l -> RuleVar l -> RuleVar l
    $ccompare :: forall l. Ord l => RuleVar l -> RuleVar l -> Ordering
    compare :: RuleVar l -> RuleVar l -> Ordering
    $c< :: forall l. Ord l => RuleVar l -> RuleVar l -> Bool
    < :: RuleVar l -> RuleVar l -> Bool
    $c<= :: forall l. Ord l => RuleVar l -> RuleVar l -> Bool
    <= :: RuleVar l -> RuleVar l -> Bool
    $c> :: forall l. Ord l => RuleVar l -> RuleVar l -> Bool
    > :: RuleVar l -> RuleVar l -> Bool
    $c>= :: forall l. Ord l => RuleVar l -> RuleVar l -> Bool
    >= :: RuleVar l -> RuleVar l -> Bool
    $cmax :: forall l. Ord l => RuleVar l -> RuleVar l -> RuleVar l
    max :: RuleVar l -> RuleVar l -> RuleVar l
    $cmin :: forall l. Ord l => RuleVar l -> RuleVar l -> RuleVar l
    min :: RuleVar l -> RuleVar l -> RuleVar l
    Ord,Int -> RuleVar l -> ShowS
    [RuleVar l] -> ShowS
    RuleVar l -> String
    (Int -> RuleVar l -> ShowS)
    -> (RuleVar l -> String)
    -> ([RuleVar l] -> ShowS)
    -> Show (RuleVar l)
    forall l. Show l => Int -> RuleVar l -> ShowS
    forall l. Show l => [RuleVar l] -> ShowS
    forall l. Show l => RuleVar l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> RuleVar l -> ShowS
    showsPrec :: Int -> RuleVar l -> ShowS
    $cshow :: forall l. Show l => RuleVar l -> String
    show :: RuleVar l -> String
    $cshowList :: forall l. Show l => [RuleVar l] -> ShowS
    showList :: [RuleVar l] -> ShowS
    Show,Typeable,Typeable (RuleVar l)
    Typeable (RuleVar l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (RuleVar l))
    -> (RuleVar l -> Constr)
    -> (RuleVar l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (RuleVar l)))
    -> ((forall b. Data b => b -> b) -> RuleVar l -> RuleVar l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> RuleVar l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> RuleVar l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l))
    -> Data (RuleVar l)
    RuleVar l -> Constr
    RuleVar l -> DataType
    (forall b. Data b => b -> b) -> RuleVar l -> RuleVar l
    forall l. Data l => Typeable (RuleVar l)
    forall l. Data l => RuleVar l -> Constr
    forall l. Data l => RuleVar l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> RuleVar l -> RuleVar l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> RuleVar l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> RuleVar l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RuleVar l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RuleVar l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> RuleVar l -> u
    forall u. (forall d. Data d => d -> u) -> RuleVar l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RuleVar l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RuleVar l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RuleVar l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RuleVar l)
    $ctoConstr :: forall l. Data l => RuleVar l -> Constr
    toConstr :: RuleVar l -> Constr
    $cdataTypeOf :: forall l. Data l => RuleVar l -> DataType
    dataTypeOf :: RuleVar l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RuleVar l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RuleVar l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> RuleVar l -> RuleVar l
    gmapT :: (forall b. Data b => b -> b) -> RuleVar l -> RuleVar l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> RuleVar l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RuleVar l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> RuleVar l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleVar l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l)
    Data,(forall m. Monoid m => RuleVar m -> m)
    -> (forall m a. Monoid m => (a -> m) -> RuleVar a -> m)
    -> (forall m a. Monoid m => (a -> m) -> RuleVar a -> m)
    -> (forall a b. (a -> b -> b) -> b -> RuleVar a -> b)
    -> (forall a b. (a -> b -> b) -> b -> RuleVar a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RuleVar a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RuleVar a -> b)
    -> (forall a. (a -> a -> a) -> RuleVar a -> a)
    -> (forall a. (a -> a -> a) -> RuleVar a -> a)
    -> (forall a. RuleVar a -> [a])
    -> (forall a. RuleVar a -> Bool)
    -> (forall a. RuleVar a -> Int)
    -> (forall a. Eq a => a -> RuleVar a -> Bool)
    -> (forall a. Ord a => RuleVar a -> a)
    -> (forall a. Ord a => RuleVar a -> a)
    -> (forall a. Num a => RuleVar a -> a)
    -> (forall a. Num a => RuleVar a -> a)
    -> Foldable RuleVar
    forall a. Eq a => a -> RuleVar a -> Bool
    forall a. Num a => RuleVar a -> a
    forall a. Ord a => RuleVar a -> a
    forall m. Monoid m => RuleVar m -> m
    forall a. RuleVar a -> Bool
    forall a. RuleVar a -> Int
    forall a. RuleVar a -> [a]
    forall a. (a -> a -> a) -> RuleVar a -> a
    forall m a. Monoid m => (a -> m) -> RuleVar a -> m
    forall b a. (b -> a -> b) -> b -> RuleVar a -> b
    forall a b. (a -> b -> b) -> b -> RuleVar a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => RuleVar m -> m
    fold :: forall m. Monoid m => RuleVar m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> RuleVar a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> RuleVar a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> RuleVar a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> RuleVar a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> RuleVar a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> RuleVar a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> RuleVar a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> RuleVar a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> RuleVar a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> RuleVar a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> RuleVar a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> RuleVar a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> RuleVar a -> a
    foldr1 :: forall a. (a -> a -> a) -> RuleVar a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> RuleVar a -> a
    foldl1 :: forall a. (a -> a -> a) -> RuleVar a -> a
    $ctoList :: forall a. RuleVar a -> [a]
    toList :: forall a. RuleVar a -> [a]
    $cnull :: forall a. RuleVar a -> Bool
    null :: forall a. RuleVar a -> Bool
    $clength :: forall a. RuleVar a -> Int
    length :: forall a. RuleVar a -> Int
    $celem :: forall a. Eq a => a -> RuleVar a -> Bool
    elem :: forall a. Eq a => a -> RuleVar a -> Bool
    $cmaximum :: forall a. Ord a => RuleVar a -> a
    maximum :: forall a. Ord a => RuleVar a -> a
    $cminimum :: forall a. Ord a => RuleVar a -> a
    minimum :: forall a. Ord a => RuleVar a -> a
    $csum :: forall a. Num a => RuleVar a -> a
    sum :: forall a. Num a => RuleVar a -> a
    $cproduct :: forall a. Num a => RuleVar a -> a
    product :: forall a. Num a => RuleVar a -> a
    Foldable,Functor RuleVar
    Foldable RuleVar
    (Functor RuleVar, Foldable RuleVar) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> RuleVar a -> f (RuleVar b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        RuleVar (f a) -> f (RuleVar a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> RuleVar a -> m (RuleVar b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        RuleVar (m a) -> m (RuleVar a))
    -> Traversable RuleVar
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => RuleVar (m a) -> m (RuleVar a)
    forall (f :: * -> *) a.
    Applicative f =>
    RuleVar (f a) -> f (RuleVar a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RuleVar a -> m (RuleVar b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RuleVar a -> f (RuleVar b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RuleVar a -> f (RuleVar b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RuleVar a -> f (RuleVar b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RuleVar (f a) -> f (RuleVar a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RuleVar (f a) -> f (RuleVar a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RuleVar a -> m (RuleVar b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RuleVar a -> m (RuleVar b)
    $csequence :: forall (m :: * -> *) a. Monad m => RuleVar (m a) -> m (RuleVar a)
    sequence :: forall (m :: * -> *) a. Monad m => RuleVar (m a) -> m (RuleVar a)
    Traversable,(forall a b. (a -> b) -> RuleVar a -> RuleVar b)
    -> (forall a b. a -> RuleVar b -> RuleVar a) -> Functor RuleVar
    forall a b. a -> RuleVar b -> RuleVar a
    forall a b. (a -> b) -> RuleVar a -> RuleVar b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> RuleVar a -> RuleVar b
    fmap :: forall a b. (a -> b) -> RuleVar a -> RuleVar b
    $c<$ :: forall a b. a -> RuleVar b -> RuleVar a
    <$ :: forall a b. a -> RuleVar b -> RuleVar a
    Functor,(forall x. RuleVar l -> Rep (RuleVar l) x)
    -> (forall x. Rep (RuleVar l) x -> RuleVar l)
    -> Generic (RuleVar l)
    forall x. Rep (RuleVar l) x -> RuleVar l
    forall x. RuleVar l -> Rep (RuleVar l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (RuleVar l) x -> RuleVar l
    forall l x. RuleVar l -> Rep (RuleVar l) x
    $cfrom :: forall l x. RuleVar l -> Rep (RuleVar l) x
    from :: forall x. RuleVar l -> Rep (RuleVar l) x
    $cto :: forall l x. Rep (RuleVar l) x -> RuleVar l
    to :: forall x. Rep (RuleVar l) x -> RuleVar l
    Generic)

    -- | Warning text to optionally use in the module header of e.g.
    --   a deprecated module.
    data WarningText l
        = DeprText l String
        | WarnText l String
      deriving (WarningText l -> WarningText l -> Bool
    (WarningText l -> WarningText l -> Bool)
    -> (WarningText l -> WarningText l -> Bool) -> Eq (WarningText l)
    forall l. Eq l => WarningText l -> WarningText l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => WarningText l -> WarningText l -> Bool
    == :: WarningText l -> WarningText l -> Bool
    $c/= :: forall l. Eq l => WarningText l -> WarningText l -> Bool
    /= :: WarningText l -> WarningText l -> Bool
    Eq,Eq (WarningText l)
    Eq (WarningText l) =>
    (WarningText l -> WarningText l -> Ordering)
    -> (WarningText l -> WarningText l -> Bool)
    -> (WarningText l -> WarningText l -> Bool)
    -> (WarningText l -> WarningText l -> Bool)
    -> (WarningText l -> WarningText l -> Bool)
    -> (WarningText l -> WarningText l -> WarningText l)
    -> (WarningText l -> WarningText l -> WarningText l)
    -> Ord (WarningText l)
    WarningText l -> WarningText l -> Bool
    WarningText l -> WarningText l -> Ordering
    WarningText l -> WarningText l -> WarningText l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (WarningText l)
    forall l. Ord l => WarningText l -> WarningText l -> Bool
    forall l. Ord l => WarningText l -> WarningText l -> Ordering
    forall l. Ord l => WarningText l -> WarningText l -> WarningText l
    $ccompare :: forall l. Ord l => WarningText l -> WarningText l -> Ordering
    compare :: WarningText l -> WarningText l -> Ordering
    $c< :: forall l. Ord l => WarningText l -> WarningText l -> Bool
    < :: WarningText l -> WarningText l -> Bool
    $c<= :: forall l. Ord l => WarningText l -> WarningText l -> Bool
    <= :: WarningText l -> WarningText l -> Bool
    $c> :: forall l. Ord l => WarningText l -> WarningText l -> Bool
    > :: WarningText l -> WarningText l -> Bool
    $c>= :: forall l. Ord l => WarningText l -> WarningText l -> Bool
    >= :: WarningText l -> WarningText l -> Bool
    $cmax :: forall l. Ord l => WarningText l -> WarningText l -> WarningText l
    max :: WarningText l -> WarningText l -> WarningText l
    $cmin :: forall l. Ord l => WarningText l -> WarningText l -> WarningText l
    min :: WarningText l -> WarningText l -> WarningText l
    Ord,Int -> WarningText l -> ShowS
    [WarningText l] -> ShowS
    WarningText l -> String
    (Int -> WarningText l -> ShowS)
    -> (WarningText l -> String)
    -> ([WarningText l] -> ShowS)
    -> Show (WarningText l)
    forall l. Show l => Int -> WarningText l -> ShowS
    forall l. Show l => [WarningText l] -> ShowS
    forall l. Show l => WarningText l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> WarningText l -> ShowS
    showsPrec :: Int -> WarningText l -> ShowS
    $cshow :: forall l. Show l => WarningText l -> String
    show :: WarningText l -> String
    $cshowList :: forall l. Show l => [WarningText l] -> ShowS
    showList :: [WarningText l] -> ShowS
    Show,Typeable,Typeable (WarningText l)
    Typeable (WarningText l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> WarningText l -> c (WarningText l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (WarningText l))
    -> (WarningText l -> Constr)
    -> (WarningText l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (WarningText l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (WarningText l)))
    -> ((forall b. Data b => b -> b) -> WarningText l -> WarningText l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> WarningText l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> WarningText l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> WarningText l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> WarningText l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> WarningText l -> m (WarningText l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> WarningText l -> m (WarningText l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> WarningText l -> m (WarningText l))
    -> Data (WarningText l)
    WarningText l -> Constr
    WarningText l -> DataType
    (forall b. Data b => b -> b) -> WarningText l -> WarningText l
    forall l. Data l => Typeable (WarningText l)
    forall l. Data l => WarningText l -> Constr
    forall l. Data l => WarningText l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> WarningText l -> WarningText l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> WarningText l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> WarningText l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WarningText l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WarningText l -> c (WarningText l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (WarningText l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WarningText l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> WarningText l -> u
    forall u. (forall d. Data d => d -> u) -> WarningText l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WarningText l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WarningText l -> c (WarningText l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (WarningText l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WarningText l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WarningText l -> c (WarningText l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WarningText l -> c (WarningText l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WarningText l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WarningText l)
    $ctoConstr :: forall l. Data l => WarningText l -> Constr
    toConstr :: WarningText l -> Constr
    $cdataTypeOf :: forall l. Data l => WarningText l -> DataType
    dataTypeOf :: WarningText l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (WarningText l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (WarningText l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WarningText l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WarningText l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> WarningText l -> WarningText l
    gmapT :: (forall b. Data b => b -> b) -> WarningText l -> WarningText l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WarningText l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> WarningText l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> WarningText l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> WarningText l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WarningText l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WarningText l -> m (WarningText l)
    Data,(forall m. Monoid m => WarningText m -> m)
    -> (forall m a. Monoid m => (a -> m) -> WarningText a -> m)
    -> (forall m a. Monoid m => (a -> m) -> WarningText a -> m)
    -> (forall a b. (a -> b -> b) -> b -> WarningText a -> b)
    -> (forall a b. (a -> b -> b) -> b -> WarningText a -> b)
    -> (forall b a. (b -> a -> b) -> b -> WarningText a -> b)
    -> (forall b a. (b -> a -> b) -> b -> WarningText a -> b)
    -> (forall a. (a -> a -> a) -> WarningText a -> a)
    -> (forall a. (a -> a -> a) -> WarningText a -> a)
    -> (forall a. WarningText a -> [a])
    -> (forall a. WarningText a -> Bool)
    -> (forall a. WarningText a -> Int)
    -> (forall a. Eq a => a -> WarningText a -> Bool)
    -> (forall a. Ord a => WarningText a -> a)
    -> (forall a. Ord a => WarningText a -> a)
    -> (forall a. Num a => WarningText a -> a)
    -> (forall a. Num a => WarningText a -> a)
    -> Foldable WarningText
    forall a. Eq a => a -> WarningText a -> Bool
    forall a. Num a => WarningText a -> a
    forall a. Ord a => WarningText a -> a
    forall m. Monoid m => WarningText m -> m
    forall a. WarningText a -> Bool
    forall a. WarningText a -> Int
    forall a. WarningText a -> [a]
    forall a. (a -> a -> a) -> WarningText a -> a
    forall m a. Monoid m => (a -> m) -> WarningText a -> m
    forall b a. (b -> a -> b) -> b -> WarningText a -> b
    forall a b. (a -> b -> b) -> b -> WarningText a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => WarningText m -> m
    fold :: forall m. Monoid m => WarningText m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> WarningText a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> WarningText a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> WarningText a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> WarningText a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> WarningText a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> WarningText a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> WarningText a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> WarningText a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> WarningText a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> WarningText a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> WarningText a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> WarningText a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> WarningText a -> a
    foldr1 :: forall a. (a -> a -> a) -> WarningText a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> WarningText a -> a
    foldl1 :: forall a. (a -> a -> a) -> WarningText a -> a
    $ctoList :: forall a. WarningText a -> [a]
    toList :: forall a. WarningText a -> [a]
    $cnull :: forall a. WarningText a -> Bool
    null :: forall a. WarningText a -> Bool
    $clength :: forall a. WarningText a -> Int
    length :: forall a. WarningText a -> Int
    $celem :: forall a. Eq a => a -> WarningText a -> Bool
    elem :: forall a. Eq a => a -> WarningText a -> Bool
    $cmaximum :: forall a. Ord a => WarningText a -> a
    maximum :: forall a. Ord a => WarningText a -> a
    $cminimum :: forall a. Ord a => WarningText a -> a
    minimum :: forall a. Ord a => WarningText a -> a
    $csum :: forall a. Num a => WarningText a -> a
    sum :: forall a. Num a => WarningText a -> a
    $cproduct :: forall a. Num a => WarningText a -> a
    product :: forall a. Num a => WarningText a -> a
    Foldable,Functor WarningText
    Foldable WarningText
    (Functor WarningText, Foldable WarningText) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> WarningText a -> f (WarningText b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        WarningText (f a) -> f (WarningText a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> WarningText a -> m (WarningText b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        WarningText (m a) -> m (WarningText a))
    -> Traversable WarningText
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    WarningText (m a) -> m (WarningText a)
    forall (f :: * -> *) a.
    Applicative f =>
    WarningText (f a) -> f (WarningText a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WarningText a -> m (WarningText b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WarningText a -> f (WarningText b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WarningText a -> f (WarningText b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> WarningText a -> f (WarningText b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    WarningText (f a) -> f (WarningText a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    WarningText (f a) -> f (WarningText a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WarningText a -> m (WarningText b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> WarningText a -> m (WarningText b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    WarningText (m a) -> m (WarningText a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    WarningText (m a) -> m (WarningText a)
    Traversable,(forall a b. (a -> b) -> WarningText a -> WarningText b)
    -> (forall a b. a -> WarningText b -> WarningText a)
    -> Functor WarningText
    forall a b. a -> WarningText b -> WarningText a
    forall a b. (a -> b) -> WarningText a -> WarningText b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> WarningText a -> WarningText b
    fmap :: forall a b. (a -> b) -> WarningText a -> WarningText b
    $c<$ :: forall a b. a -> WarningText b -> WarningText a
    <$ :: forall a b. a -> WarningText b -> WarningText a
    Functor,(forall x. WarningText l -> Rep (WarningText l) x)
    -> (forall x. Rep (WarningText l) x -> WarningText l)
    -> Generic (WarningText l)
    forall x. Rep (WarningText l) x -> WarningText l
    forall x. WarningText l -> Rep (WarningText l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (WarningText l) x -> WarningText l
    forall l x. WarningText l -> Rep (WarningText l) x
    $cfrom :: forall l x. WarningText l -> Rep (WarningText l) x
    from :: forall x. WarningText l -> Rep (WarningText l) x
    $cto :: forall l x. Rep (WarningText l) x -> WarningText l
    to :: forall x. Rep (WarningText l) x -> WarningText l
    Generic)

    -- | A pattern, to be matched against a value.
    data Pat l
        = PVar l (Name l)                       -- ^ variable
        | PLit l (Sign l) (Literal l)           -- ^ literal constant
        | PNPlusK l (Name l) Integer            -- ^ n+k pattern
        | PInfixApp l (Pat l) (QName l) (Pat l) -- ^ pattern with an infix data constructor
        | PApp l (QName l) [Pat l]              -- ^ data constructor and argument patterns
        | PTuple l Boxed [Pat l]                -- ^ tuple pattern
        | PUnboxedSum l Int Int (Pat l)         -- ^ unboxed sum
        | PList l [Pat l]                       -- ^ list pattern
        | PParen l (Pat l)                      -- ^ parenthesized pattern
        | PRec l (QName l) [PatField l]         -- ^ labelled pattern, record style
        | PAsPat l (Name l) (Pat l)             -- ^ @\@@-pattern
        | PWildCard l                           -- ^ wildcard pattern: @_@
        | PIrrPat l (Pat l)                     -- ^ irrefutable pattern: @~/pat/@
        | PatTypeSig l (Pat l) (Type l)         -- ^ pattern with type signature
        | PViewPat l (Exp l) (Pat l)            -- ^ view patterns of the form @(/exp/ -> /pat/)@
        | PRPat l [RPat l]                      -- ^ regular list pattern
        | PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]
                                                -- ^ XML element pattern
        | PXETag l (XName l) [PXAttr l] (Maybe (Pat l))
                                                -- ^ XML singleton element pattern
        | PXPcdata l String                     -- ^ XML PCDATA pattern
        | PXPatTag l (Pat l)                    -- ^ XML embedded pattern
        | PXRPats  l [RPat l]                   -- ^ XML regular list pattern
        | PSplice l (Splice l)                  -- ^ template haskell splice pattern
        | PQuasiQuote l String String           -- ^ quasi quote pattern: @[$/name/| /string/ |]@
        | PBangPat l (Pat l)                    -- ^ strict (bang) pattern: @f !x = ...@
      deriving (Pat l -> Pat l -> Bool
    (Pat l -> Pat l -> Bool) -> (Pat l -> Pat l -> Bool) -> Eq (Pat l)
    forall l. Eq l => Pat l -> Pat l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Pat l -> Pat l -> Bool
    == :: Pat l -> Pat l -> Bool
    $c/= :: forall l. Eq l => Pat l -> Pat l -> Bool
    /= :: Pat l -> Pat l -> Bool
    Eq,Eq (Pat l)
    Eq (Pat l) =>
    (Pat l -> Pat l -> Ordering)
    -> (Pat l -> Pat l -> Bool)
    -> (Pat l -> Pat l -> Bool)
    -> (Pat l -> Pat l -> Bool)
    -> (Pat l -> Pat l -> Bool)
    -> (Pat l -> Pat l -> Pat l)
    -> (Pat l -> Pat l -> Pat l)
    -> Ord (Pat l)
    Pat l -> Pat l -> Bool
    Pat l -> Pat l -> Ordering
    Pat l -> Pat l -> Pat l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Pat l)
    forall l. Ord l => Pat l -> Pat l -> Bool
    forall l. Ord l => Pat l -> Pat l -> Ordering
    forall l. Ord l => Pat l -> Pat l -> Pat l
    $ccompare :: forall l. Ord l => Pat l -> Pat l -> Ordering
    compare :: Pat l -> Pat l -> Ordering
    $c< :: forall l. Ord l => Pat l -> Pat l -> Bool
    < :: Pat l -> Pat l -> Bool
    $c<= :: forall l. Ord l => Pat l -> Pat l -> Bool
    <= :: Pat l -> Pat l -> Bool
    $c> :: forall l. Ord l => Pat l -> Pat l -> Bool
    > :: Pat l -> Pat l -> Bool
    $c>= :: forall l. Ord l => Pat l -> Pat l -> Bool
    >= :: Pat l -> Pat l -> Bool
    $cmax :: forall l. Ord l => Pat l -> Pat l -> Pat l
    max :: Pat l -> Pat l -> Pat l
    $cmin :: forall l. Ord l => Pat l -> Pat l -> Pat l
    min :: Pat l -> Pat l -> Pat l
    Ord,Int -> Pat l -> ShowS
    [Pat l] -> ShowS
    Pat l -> String
    (Int -> Pat l -> ShowS)
    -> (Pat l -> String) -> ([Pat l] -> ShowS) -> Show (Pat l)
    forall l. Show l => Int -> Pat l -> ShowS
    forall l. Show l => [Pat l] -> ShowS
    forall l. Show l => Pat l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Pat l -> ShowS
    showsPrec :: Int -> Pat l -> ShowS
    $cshow :: forall l. Show l => Pat l -> String
    show :: Pat l -> String
    $cshowList :: forall l. Show l => [Pat l] -> ShowS
    showList :: [Pat l] -> ShowS
    Show,Typeable,Typeable (Pat l)
    Typeable (Pat l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Pat l -> c (Pat l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Pat l))
    -> (Pat l -> Constr)
    -> (Pat l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Pat l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l)))
    -> ((forall b. Data b => b -> b) -> Pat l -> Pat l)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Pat l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Pat l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Pat l -> m (Pat l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Pat l -> m (Pat l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Pat l -> m (Pat l))
    -> Data (Pat l)
    Pat l -> Constr
    Pat l -> DataType
    (forall b. Data b => b -> b) -> Pat l -> Pat l
    forall l. Data l => Typeable (Pat l)
    forall l. Data l => Pat l -> Constr
    forall l. Data l => Pat l -> DataType
    forall l. Data l => (forall b. Data b => b -> b) -> Pat l -> Pat l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Pat l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Pat l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Pat l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat l -> c (Pat l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Pat l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Pat l -> u
    forall u. (forall d. Data d => d -> u) -> Pat l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Pat l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat l -> c (Pat l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Pat l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat l -> c (Pat l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat l -> c (Pat l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Pat l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Pat l)
    $ctoConstr :: forall l. Data l => Pat l -> Constr
    toConstr :: Pat l -> Constr
    $cdataTypeOf :: forall l. Data l => Pat l -> DataType
    dataTypeOf :: Pat l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Pat l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Pat l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l))
    $cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Pat l -> Pat l
    gmapT :: (forall b. Data b => b -> b) -> Pat l -> Pat l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Pat l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Pat l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Pat l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
    Data,(forall m. Monoid m => Pat m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Pat a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Pat a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Pat a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Pat a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Pat a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Pat a -> b)
    -> (forall a. (a -> a -> a) -> Pat a -> a)
    -> (forall a. (a -> a -> a) -> Pat a -> a)
    -> (forall a. Pat a -> [a])
    -> (forall a. Pat a -> Bool)
    -> (forall a. Pat a -> Int)
    -> (forall a. Eq a => a -> Pat a -> Bool)
    -> (forall a. Ord a => Pat a -> a)
    -> (forall a. Ord a => Pat a -> a)
    -> (forall a. Num a => Pat a -> a)
    -> (forall a. Num a => Pat a -> a)
    -> Foldable Pat
    forall a. Eq a => a -> Pat a -> Bool
    forall a. Num a => Pat a -> a
    forall a. Ord a => Pat a -> a
    forall m. Monoid m => Pat m -> m
    forall a. Pat a -> Bool
    forall a. Pat a -> Int
    forall a. Pat a -> [a]
    forall a. (a -> a -> a) -> Pat a -> a
    forall m a. Monoid m => (a -> m) -> Pat a -> m
    forall b a. (b -> a -> b) -> b -> Pat a -> b
    forall a b. (a -> b -> b) -> b -> Pat a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Pat m -> m
    fold :: forall m. Monoid m => Pat m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Pat a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Pat a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Pat a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Pat a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Pat a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Pat a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Pat a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Pat a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Pat a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Pat a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Pat a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Pat a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Pat a -> a
    foldr1 :: forall a. (a -> a -> a) -> Pat a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Pat a -> a
    foldl1 :: forall a. (a -> a -> a) -> Pat a -> a
    $ctoList :: forall a. Pat a -> [a]
    toList :: forall a. Pat a -> [a]
    $cnull :: forall a. Pat a -> Bool
    null :: forall a. Pat a -> Bool
    $clength :: forall a. Pat a -> Int
    length :: forall a. Pat a -> Int
    $celem :: forall a. Eq a => a -> Pat a -> Bool
    elem :: forall a. Eq a => a -> Pat a -> Bool
    $cmaximum :: forall a. Ord a => Pat a -> a
    maximum :: forall a. Ord a => Pat a -> a
    $cminimum :: forall a. Ord a => Pat a -> a
    minimum :: forall a. Ord a => Pat a -> a
    $csum :: forall a. Num a => Pat a -> a
    sum :: forall a. Num a => Pat a -> a
    $cproduct :: forall a. Num a => Pat a -> a
    product :: forall a. Num a => Pat a -> a
    Foldable,Functor Pat
    Foldable Pat
    (Functor Pat, Foldable Pat) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Pat a -> f (Pat b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Pat (f a) -> f (Pat a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Pat a -> m (Pat b))
    -> (forall (m :: * -> *) a. Monad m => Pat (m a) -> m (Pat a))
    -> Traversable Pat
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Pat (m a) -> m (Pat a)
    forall (f :: * -> *) a. Applicative f => Pat (f a) -> f (Pat a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Pat a -> m (Pat b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Pat a -> f (Pat b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Pat a -> f (Pat b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Pat a -> f (Pat b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Pat (f a) -> f (Pat a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Pat (f a) -> f (Pat a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Pat a -> m (Pat b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Pat a -> m (Pat b)
    $csequence :: forall (m :: * -> *) a. Monad m => Pat (m a) -> m (Pat a)
    sequence :: forall (m :: * -> *) a. Monad m => Pat (m a) -> m (Pat a)
    Traversable,(forall a b. (a -> b) -> Pat a -> Pat b)
    -> (forall a b. a -> Pat b -> Pat a) -> Functor Pat
    forall a b. a -> Pat b -> Pat a
    forall a b. (a -> b) -> Pat a -> Pat b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Pat a -> Pat b
    fmap :: forall a b. (a -> b) -> Pat a -> Pat b
    $c<$ :: forall a b. a -> Pat b -> Pat a
    <$ :: forall a b. a -> Pat b -> Pat a
    Functor,(forall x. Pat l -> Rep (Pat l) x)
    -> (forall x. Rep (Pat l) x -> Pat l) -> Generic (Pat l)
    forall x. Rep (Pat l) x -> Pat l
    forall x. Pat l -> Rep (Pat l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Pat l) x -> Pat l
    forall l x. Pat l -> Rep (Pat l) x
    $cfrom :: forall l x. Pat l -> Rep (Pat l) x
    from :: forall x. Pat l -> Rep (Pat l) x
    $cto :: forall l x. Rep (Pat l) x -> Pat l
    to :: forall x. Rep (Pat l) x -> Pat l
    Generic)

    -- | An XML attribute in a pattern.
    data PXAttr l = PXAttr l (XName l) (Pat l)
      deriving (PXAttr l -> PXAttr l -> Bool
    (PXAttr l -> PXAttr l -> Bool)
    -> (PXAttr l -> PXAttr l -> Bool) -> Eq (PXAttr l)
    forall l. Eq l => PXAttr l -> PXAttr l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => PXAttr l -> PXAttr l -> Bool
    == :: PXAttr l -> PXAttr l -> Bool
    $c/= :: forall l. Eq l => PXAttr l -> PXAttr l -> Bool
    /= :: PXAttr l -> PXAttr l -> Bool
    Eq,Eq (PXAttr l)
    Eq (PXAttr l) =>
    (PXAttr l -> PXAttr l -> Ordering)
    -> (PXAttr l -> PXAttr l -> Bool)
    -> (PXAttr l -> PXAttr l -> Bool)
    -> (PXAttr l -> PXAttr l -> Bool)
    -> (PXAttr l -> PXAttr l -> Bool)
    -> (PXAttr l -> PXAttr l -> PXAttr l)
    -> (PXAttr l -> PXAttr l -> PXAttr l)
    -> Ord (PXAttr l)
    PXAttr l -> PXAttr l -> Bool
    PXAttr l -> PXAttr l -> Ordering
    PXAttr l -> PXAttr l -> PXAttr l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (PXAttr l)
    forall l. Ord l => PXAttr l -> PXAttr l -> Bool
    forall l. Ord l => PXAttr l -> PXAttr l -> Ordering
    forall l. Ord l => PXAttr l -> PXAttr l -> PXAttr l
    $ccompare :: forall l. Ord l => PXAttr l -> PXAttr l -> Ordering
    compare :: PXAttr l -> PXAttr l -> Ordering
    $c< :: forall l. Ord l => PXAttr l -> PXAttr l -> Bool
    < :: PXAttr l -> PXAttr l -> Bool
    $c<= :: forall l. Ord l => PXAttr l -> PXAttr l -> Bool
    <= :: PXAttr l -> PXAttr l -> Bool
    $c> :: forall l. Ord l => PXAttr l -> PXAttr l -> Bool
    > :: PXAttr l -> PXAttr l -> Bool
    $c>= :: forall l. Ord l => PXAttr l -> PXAttr l -> Bool
    >= :: PXAttr l -> PXAttr l -> Bool
    $cmax :: forall l. Ord l => PXAttr l -> PXAttr l -> PXAttr l
    max :: PXAttr l -> PXAttr l -> PXAttr l
    $cmin :: forall l. Ord l => PXAttr l -> PXAttr l -> PXAttr l
    min :: PXAttr l -> PXAttr l -> PXAttr l
    Ord,Int -> PXAttr l -> ShowS
    [PXAttr l] -> ShowS
    PXAttr l -> String
    (Int -> PXAttr l -> ShowS)
    -> (PXAttr l -> String) -> ([PXAttr l] -> ShowS) -> Show (PXAttr l)
    forall l. Show l => Int -> PXAttr l -> ShowS
    forall l. Show l => [PXAttr l] -> ShowS
    forall l. Show l => PXAttr l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> PXAttr l -> ShowS
    showsPrec :: Int -> PXAttr l -> ShowS
    $cshow :: forall l. Show l => PXAttr l -> String
    show :: PXAttr l -> String
    $cshowList :: forall l. Show l => [PXAttr l] -> ShowS
    showList :: [PXAttr l] -> ShowS
    Show,Typeable,Typeable (PXAttr l)
    Typeable (PXAttr l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (PXAttr l))
    -> (PXAttr l -> Constr)
    -> (PXAttr l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (PXAttr l)))
    -> ((forall b. Data b => b -> b) -> PXAttr l -> PXAttr l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PXAttr l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> PXAttr l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l))
    -> Data (PXAttr l)
    PXAttr l -> Constr
    PXAttr l -> DataType
    (forall b. Data b => b -> b) -> PXAttr l -> PXAttr l
    forall l. Data l => Typeable (PXAttr l)
    forall l. Data l => PXAttr l -> Constr
    forall l. Data l => PXAttr l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> PXAttr l -> PXAttr l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> PXAttr l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> PXAttr l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PXAttr l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> PXAttr l -> u
    forall u. (forall d. Data d => d -> u) -> PXAttr l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PXAttr l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PXAttr l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PXAttr l)
    $ctoConstr :: forall l. Data l => PXAttr l -> Constr
    toConstr :: PXAttr l -> Constr
    $cdataTypeOf :: forall l. Data l => PXAttr l -> DataType
    dataTypeOf :: PXAttr l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> PXAttr l -> PXAttr l
    gmapT :: (forall b. Data b => b -> b) -> PXAttr l -> PXAttr l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> PXAttr l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PXAttr l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> PXAttr l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PXAttr l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l)
    Data,(forall m. Monoid m => PXAttr m -> m)
    -> (forall m a. Monoid m => (a -> m) -> PXAttr a -> m)
    -> (forall m a. Monoid m => (a -> m) -> PXAttr a -> m)
    -> (forall a b. (a -> b -> b) -> b -> PXAttr a -> b)
    -> (forall a b. (a -> b -> b) -> b -> PXAttr a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PXAttr a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PXAttr a -> b)
    -> (forall a. (a -> a -> a) -> PXAttr a -> a)
    -> (forall a. (a -> a -> a) -> PXAttr a -> a)
    -> (forall a. PXAttr a -> [a])
    -> (forall a. PXAttr a -> Bool)
    -> (forall a. PXAttr a -> Int)
    -> (forall a. Eq a => a -> PXAttr a -> Bool)
    -> (forall a. Ord a => PXAttr a -> a)
    -> (forall a. Ord a => PXAttr a -> a)
    -> (forall a. Num a => PXAttr a -> a)
    -> (forall a. Num a => PXAttr a -> a)
    -> Foldable PXAttr
    forall a. Eq a => a -> PXAttr a -> Bool
    forall a. Num a => PXAttr a -> a
    forall a. Ord a => PXAttr a -> a
    forall m. Monoid m => PXAttr m -> m
    forall a. PXAttr a -> Bool
    forall a. PXAttr a -> Int
    forall a. PXAttr a -> [a]
    forall a. (a -> a -> a) -> PXAttr a -> a
    forall m a. Monoid m => (a -> m) -> PXAttr a -> m
    forall b a. (b -> a -> b) -> b -> PXAttr a -> b
    forall a b. (a -> b -> b) -> b -> PXAttr a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => PXAttr m -> m
    fold :: forall m. Monoid m => PXAttr m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> PXAttr a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> PXAttr a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> PXAttr a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> PXAttr a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> PXAttr a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> PXAttr a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> PXAttr a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> PXAttr a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> PXAttr a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> PXAttr a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> PXAttr a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> PXAttr a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> PXAttr a -> a
    foldr1 :: forall a. (a -> a -> a) -> PXAttr a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> PXAttr a -> a
    foldl1 :: forall a. (a -> a -> a) -> PXAttr a -> a
    $ctoList :: forall a. PXAttr a -> [a]
    toList :: forall a. PXAttr a -> [a]
    $cnull :: forall a. PXAttr a -> Bool
    null :: forall a. PXAttr a -> Bool
    $clength :: forall a. PXAttr a -> Int
    length :: forall a. PXAttr a -> Int
    $celem :: forall a. Eq a => a -> PXAttr a -> Bool
    elem :: forall a. Eq a => a -> PXAttr a -> Bool
    $cmaximum :: forall a. Ord a => PXAttr a -> a
    maximum :: forall a. Ord a => PXAttr a -> a
    $cminimum :: forall a. Ord a => PXAttr a -> a
    minimum :: forall a. Ord a => PXAttr a -> a
    $csum :: forall a. Num a => PXAttr a -> a
    sum :: forall a. Num a => PXAttr a -> a
    $cproduct :: forall a. Num a => PXAttr a -> a
    product :: forall a. Num a => PXAttr a -> a
    Foldable,Functor PXAttr
    Foldable PXAttr
    (Functor PXAttr, Foldable PXAttr) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> PXAttr a -> f (PXAttr b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        PXAttr (f a) -> f (PXAttr a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> PXAttr a -> m (PXAttr b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        PXAttr (m a) -> m (PXAttr a))
    -> Traversable PXAttr
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => PXAttr (m a) -> m (PXAttr a)
    forall (f :: * -> *) a.
    Applicative f =>
    PXAttr (f a) -> f (PXAttr a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PXAttr a -> m (PXAttr b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PXAttr a -> f (PXAttr b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PXAttr a -> f (PXAttr b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PXAttr a -> f (PXAttr b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PXAttr (f a) -> f (PXAttr a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PXAttr (f a) -> f (PXAttr a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PXAttr a -> m (PXAttr b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PXAttr a -> m (PXAttr b)
    $csequence :: forall (m :: * -> *) a. Monad m => PXAttr (m a) -> m (PXAttr a)
    sequence :: forall (m :: * -> *) a. Monad m => PXAttr (m a) -> m (PXAttr a)
    Traversable,(forall a b. (a -> b) -> PXAttr a -> PXAttr b)
    -> (forall a b. a -> PXAttr b -> PXAttr a) -> Functor PXAttr
    forall a b. a -> PXAttr b -> PXAttr a
    forall a b. (a -> b) -> PXAttr a -> PXAttr b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> PXAttr a -> PXAttr b
    fmap :: forall a b. (a -> b) -> PXAttr a -> PXAttr b
    $c<$ :: forall a b. a -> PXAttr b -> PXAttr a
    <$ :: forall a b. a -> PXAttr b -> PXAttr a
    Functor,(forall x. PXAttr l -> Rep (PXAttr l) x)
    -> (forall x. Rep (PXAttr l) x -> PXAttr l) -> Generic (PXAttr l)
    forall x. Rep (PXAttr l) x -> PXAttr l
    forall x. PXAttr l -> Rep (PXAttr l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (PXAttr l) x -> PXAttr l
    forall l x. PXAttr l -> Rep (PXAttr l) x
    $cfrom :: forall l x. PXAttr l -> Rep (PXAttr l) x
    from :: forall x. PXAttr l -> Rep (PXAttr l) x
    $cto :: forall l x. Rep (PXAttr l) x -> PXAttr l
    to :: forall x. Rep (PXAttr l) x -> PXAttr l
    Generic)

    -- | A regular pattern operator.
    data RPatOp l
        = RPStar  l  -- ^ @*@ = 0 or more
        | RPStarG l  -- ^ @*!@ = 0 or more, greedy
        | RPPlus  l  -- ^ @+@ = 1 or more
        | RPPlusG l  -- ^ @+!@ = 1 or more, greedy
        | RPOpt   l  -- ^ @?@ = 0 or 1
        | RPOptG  l  -- ^ @?!@ = 0 or 1, greedy
      deriving (RPatOp l -> RPatOp l -> Bool
    (RPatOp l -> RPatOp l -> Bool)
    -> (RPatOp l -> RPatOp l -> Bool) -> Eq (RPatOp l)
    forall l. Eq l => RPatOp l -> RPatOp l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => RPatOp l -> RPatOp l -> Bool
    == :: RPatOp l -> RPatOp l -> Bool
    $c/= :: forall l. Eq l => RPatOp l -> RPatOp l -> Bool
    /= :: RPatOp l -> RPatOp l -> Bool
    Eq,Eq (RPatOp l)
    Eq (RPatOp l) =>
    (RPatOp l -> RPatOp l -> Ordering)
    -> (RPatOp l -> RPatOp l -> Bool)
    -> (RPatOp l -> RPatOp l -> Bool)
    -> (RPatOp l -> RPatOp l -> Bool)
    -> (RPatOp l -> RPatOp l -> Bool)
    -> (RPatOp l -> RPatOp l -> RPatOp l)
    -> (RPatOp l -> RPatOp l -> RPatOp l)
    -> Ord (RPatOp l)
    RPatOp l -> RPatOp l -> Bool
    RPatOp l -> RPatOp l -> Ordering
    RPatOp l -> RPatOp l -> RPatOp l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (RPatOp l)
    forall l. Ord l => RPatOp l -> RPatOp l -> Bool
    forall l. Ord l => RPatOp l -> RPatOp l -> Ordering
    forall l. Ord l => RPatOp l -> RPatOp l -> RPatOp l
    $ccompare :: forall l. Ord l => RPatOp l -> RPatOp l -> Ordering
    compare :: RPatOp l -> RPatOp l -> Ordering
    $c< :: forall l. Ord l => RPatOp l -> RPatOp l -> Bool
    < :: RPatOp l -> RPatOp l -> Bool
    $c<= :: forall l. Ord l => RPatOp l -> RPatOp l -> Bool
    <= :: RPatOp l -> RPatOp l -> Bool
    $c> :: forall l. Ord l => RPatOp l -> RPatOp l -> Bool
    > :: RPatOp l -> RPatOp l -> Bool
    $c>= :: forall l. Ord l => RPatOp l -> RPatOp l -> Bool
    >= :: RPatOp l -> RPatOp l -> Bool
    $cmax :: forall l. Ord l => RPatOp l -> RPatOp l -> RPatOp l
    max :: RPatOp l -> RPatOp l -> RPatOp l
    $cmin :: forall l. Ord l => RPatOp l -> RPatOp l -> RPatOp l
    min :: RPatOp l -> RPatOp l -> RPatOp l
    Ord,Int -> RPatOp l -> ShowS
    [RPatOp l] -> ShowS
    RPatOp l -> String
    (Int -> RPatOp l -> ShowS)
    -> (RPatOp l -> String) -> ([RPatOp l] -> ShowS) -> Show (RPatOp l)
    forall l. Show l => Int -> RPatOp l -> ShowS
    forall l. Show l => [RPatOp l] -> ShowS
    forall l. Show l => RPatOp l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> RPatOp l -> ShowS
    showsPrec :: Int -> RPatOp l -> ShowS
    $cshow :: forall l. Show l => RPatOp l -> String
    show :: RPatOp l -> String
    $cshowList :: forall l. Show l => [RPatOp l] -> ShowS
    showList :: [RPatOp l] -> ShowS
    Show,Typeable,Typeable (RPatOp l)
    Typeable (RPatOp l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (RPatOp l))
    -> (RPatOp l -> Constr)
    -> (RPatOp l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (RPatOp l)))
    -> ((forall b. Data b => b -> b) -> RPatOp l -> RPatOp l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> RPatOp l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> RPatOp l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l))
    -> Data (RPatOp l)
    RPatOp l -> Constr
    RPatOp l -> DataType
    (forall b. Data b => b -> b) -> RPatOp l -> RPatOp l
    forall l. Data l => Typeable (RPatOp l)
    forall l. Data l => RPatOp l -> Constr
    forall l. Data l => RPatOp l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> RPatOp l -> RPatOp l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> RPatOp l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> RPatOp l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPatOp l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> RPatOp l -> u
    forall u. (forall d. Data d => d -> u) -> RPatOp l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPatOp l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPatOp l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPatOp l)
    $ctoConstr :: forall l. Data l => RPatOp l -> Constr
    toConstr :: RPatOp l -> Constr
    $cdataTypeOf :: forall l. Data l => RPatOp l -> DataType
    dataTypeOf :: RPatOp l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> RPatOp l -> RPatOp l
    gmapT :: (forall b. Data b => b -> b) -> RPatOp l -> RPatOp l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> RPatOp l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RPatOp l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> RPatOp l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RPatOp l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l)
    Data,(forall m. Monoid m => RPatOp m -> m)
    -> (forall m a. Monoid m => (a -> m) -> RPatOp a -> m)
    -> (forall m a. Monoid m => (a -> m) -> RPatOp a -> m)
    -> (forall a b. (a -> b -> b) -> b -> RPatOp a -> b)
    -> (forall a b. (a -> b -> b) -> b -> RPatOp a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RPatOp a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RPatOp a -> b)
    -> (forall a. (a -> a -> a) -> RPatOp a -> a)
    -> (forall a. (a -> a -> a) -> RPatOp a -> a)
    -> (forall a. RPatOp a -> [a])
    -> (forall a. RPatOp a -> Bool)
    -> (forall a. RPatOp a -> Int)
    -> (forall a. Eq a => a -> RPatOp a -> Bool)
    -> (forall a. Ord a => RPatOp a -> a)
    -> (forall a. Ord a => RPatOp a -> a)
    -> (forall a. Num a => RPatOp a -> a)
    -> (forall a. Num a => RPatOp a -> a)
    -> Foldable RPatOp
    forall a. Eq a => a -> RPatOp a -> Bool
    forall a. Num a => RPatOp a -> a
    forall a. Ord a => RPatOp a -> a
    forall m. Monoid m => RPatOp m -> m
    forall a. RPatOp a -> Bool
    forall a. RPatOp a -> Int
    forall a. RPatOp a -> [a]
    forall a. (a -> a -> a) -> RPatOp a -> a
    forall m a. Monoid m => (a -> m) -> RPatOp a -> m
    forall b a. (b -> a -> b) -> b -> RPatOp a -> b
    forall a b. (a -> b -> b) -> b -> RPatOp a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => RPatOp m -> m
    fold :: forall m. Monoid m => RPatOp m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> RPatOp a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> RPatOp a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> RPatOp a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> RPatOp a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> RPatOp a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> RPatOp a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> RPatOp a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> RPatOp a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> RPatOp a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> RPatOp a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> RPatOp a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> RPatOp a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> RPatOp a -> a
    foldr1 :: forall a. (a -> a -> a) -> RPatOp a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> RPatOp a -> a
    foldl1 :: forall a. (a -> a -> a) -> RPatOp a -> a
    $ctoList :: forall a. RPatOp a -> [a]
    toList :: forall a. RPatOp a -> [a]
    $cnull :: forall a. RPatOp a -> Bool
    null :: forall a. RPatOp a -> Bool
    $clength :: forall a. RPatOp a -> Int
    length :: forall a. RPatOp a -> Int
    $celem :: forall a. Eq a => a -> RPatOp a -> Bool
    elem :: forall a. Eq a => a -> RPatOp a -> Bool
    $cmaximum :: forall a. Ord a => RPatOp a -> a
    maximum :: forall a. Ord a => RPatOp a -> a
    $cminimum :: forall a. Ord a => RPatOp a -> a
    minimum :: forall a. Ord a => RPatOp a -> a
    $csum :: forall a. Num a => RPatOp a -> a
    sum :: forall a. Num a => RPatOp a -> a
    $cproduct :: forall a. Num a => RPatOp a -> a
    product :: forall a. Num a => RPatOp a -> a
    Foldable,Functor RPatOp
    Foldable RPatOp
    (Functor RPatOp, Foldable RPatOp) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> RPatOp a -> f (RPatOp b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        RPatOp (f a) -> f (RPatOp a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> RPatOp a -> m (RPatOp b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        RPatOp (m a) -> m (RPatOp a))
    -> Traversable RPatOp
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => RPatOp (m a) -> m (RPatOp a)
    forall (f :: * -> *) a.
    Applicative f =>
    RPatOp (f a) -> f (RPatOp a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RPatOp a -> m (RPatOp b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RPatOp a -> f (RPatOp b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RPatOp a -> f (RPatOp b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RPatOp a -> f (RPatOp b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RPatOp (f a) -> f (RPatOp a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RPatOp (f a) -> f (RPatOp a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RPatOp a -> m (RPatOp b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RPatOp a -> m (RPatOp b)
    $csequence :: forall (m :: * -> *) a. Monad m => RPatOp (m a) -> m (RPatOp a)
    sequence :: forall (m :: * -> *) a. Monad m => RPatOp (m a) -> m (RPatOp a)
    Traversable,(forall a b. (a -> b) -> RPatOp a -> RPatOp b)
    -> (forall a b. a -> RPatOp b -> RPatOp a) -> Functor RPatOp
    forall a b. a -> RPatOp b -> RPatOp a
    forall a b. (a -> b) -> RPatOp a -> RPatOp b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> RPatOp a -> RPatOp b
    fmap :: forall a b. (a -> b) -> RPatOp a -> RPatOp b
    $c<$ :: forall a b. a -> RPatOp b -> RPatOp a
    <$ :: forall a b. a -> RPatOp b -> RPatOp a
    Functor,(forall x. RPatOp l -> Rep (RPatOp l) x)
    -> (forall x. Rep (RPatOp l) x -> RPatOp l) -> Generic (RPatOp l)
    forall x. Rep (RPatOp l) x -> RPatOp l
    forall x. RPatOp l -> Rep (RPatOp l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (RPatOp l) x -> RPatOp l
    forall l x. RPatOp l -> Rep (RPatOp l) x
    $cfrom :: forall l x. RPatOp l -> Rep (RPatOp l) x
    from :: forall x. RPatOp l -> Rep (RPatOp l) x
    $cto :: forall l x. Rep (RPatOp l) x -> RPatOp l
    to :: forall x. Rep (RPatOp l) x -> RPatOp l
    Generic)

    -- | An entity in a regular pattern.
    data RPat l
        = RPOp l (RPat l) (RPatOp l)   -- ^ operator pattern, e.g. pat*
        | RPEither l (RPat l) (RPat l) -- ^ choice pattern, e.g. (1 | 2)
        | RPSeq l [RPat l]             -- ^ sequence pattern, e.g. (| 1, 2, 3 |)
        | RPGuard l (Pat l) [Stmt l]   -- ^ guarded pattern, e.g. (| p | p < 3 |)
        | RPCAs l (Name l) (RPat l)    -- ^ non-linear variable binding, e.g. (foo\@:(1 | 2))*
        | RPAs l (Name l) (RPat l)     -- ^ linear variable binding, e.g. foo\@(1 | 2)
        | RPParen l (RPat l)           -- ^ parenthesised pattern, e.g. (2*)
        | RPPat l (Pat l)              -- ^ an ordinary pattern
      deriving (RPat l -> RPat l -> Bool
    (RPat l -> RPat l -> Bool)
    -> (RPat l -> RPat l -> Bool) -> Eq (RPat l)
    forall l. Eq l => RPat l -> RPat l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => RPat l -> RPat l -> Bool
    == :: RPat l -> RPat l -> Bool
    $c/= :: forall l. Eq l => RPat l -> RPat l -> Bool
    /= :: RPat l -> RPat l -> Bool
    Eq,Eq (RPat l)
    Eq (RPat l) =>
    (RPat l -> RPat l -> Ordering)
    -> (RPat l -> RPat l -> Bool)
    -> (RPat l -> RPat l -> Bool)
    -> (RPat l -> RPat l -> Bool)
    -> (RPat l -> RPat l -> Bool)
    -> (RPat l -> RPat l -> RPat l)
    -> (RPat l -> RPat l -> RPat l)
    -> Ord (RPat l)
    RPat l -> RPat l -> Bool
    RPat l -> RPat l -> Ordering
    RPat l -> RPat l -> RPat l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (RPat l)
    forall l. Ord l => RPat l -> RPat l -> Bool
    forall l. Ord l => RPat l -> RPat l -> Ordering
    forall l. Ord l => RPat l -> RPat l -> RPat l
    $ccompare :: forall l. Ord l => RPat l -> RPat l -> Ordering
    compare :: RPat l -> RPat l -> Ordering
    $c< :: forall l. Ord l => RPat l -> RPat l -> Bool
    < :: RPat l -> RPat l -> Bool
    $c<= :: forall l. Ord l => RPat l -> RPat l -> Bool
    <= :: RPat l -> RPat l -> Bool
    $c> :: forall l. Ord l => RPat l -> RPat l -> Bool
    > :: RPat l -> RPat l -> Bool
    $c>= :: forall l. Ord l => RPat l -> RPat l -> Bool
    >= :: RPat l -> RPat l -> Bool
    $cmax :: forall l. Ord l => RPat l -> RPat l -> RPat l
    max :: RPat l -> RPat l -> RPat l
    $cmin :: forall l. Ord l => RPat l -> RPat l -> RPat l
    min :: RPat l -> RPat l -> RPat l
    Ord,Int -> RPat l -> ShowS
    [RPat l] -> ShowS
    RPat l -> String
    (Int -> RPat l -> ShowS)
    -> (RPat l -> String) -> ([RPat l] -> ShowS) -> Show (RPat l)
    forall l. Show l => Int -> RPat l -> ShowS
    forall l. Show l => [RPat l] -> ShowS
    forall l. Show l => RPat l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> RPat l -> ShowS
    showsPrec :: Int -> RPat l -> ShowS
    $cshow :: forall l. Show l => RPat l -> String
    show :: RPat l -> String
    $cshowList :: forall l. Show l => [RPat l] -> ShowS
    showList :: [RPat l] -> ShowS
    Show,Typeable,Typeable (RPat l)
    Typeable (RPat l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> RPat l -> c (RPat l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (RPat l))
    -> (RPat l -> Constr)
    -> (RPat l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (RPat l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l)))
    -> ((forall b. Data b => b -> b) -> RPat l -> RPat l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RPat l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RPat l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> RPat l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> RPat l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> RPat l -> m (RPat l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RPat l -> m (RPat l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RPat l -> m (RPat l))
    -> Data (RPat l)
    RPat l -> Constr
    RPat l -> DataType
    (forall b. Data b => b -> b) -> RPat l -> RPat l
    forall l. Data l => Typeable (RPat l)
    forall l. Data l => RPat l -> Constr
    forall l. Data l => RPat l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> RPat l -> RPat l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> RPat l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> RPat l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPat l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RPat l -> c (RPat l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPat l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> RPat l -> u
    forall u. (forall d. Data d => d -> u) -> RPat l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPat l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RPat l -> c (RPat l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPat l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RPat l -> c (RPat l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RPat l -> c (RPat l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPat l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RPat l)
    $ctoConstr :: forall l. Data l => RPat l -> Constr
    toConstr :: RPat l -> Constr
    $cdataTypeOf :: forall l. Data l => RPat l -> DataType
    dataTypeOf :: RPat l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPat l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RPat l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> RPat l -> RPat l
    gmapT :: (forall b. Data b => b -> b) -> RPat l -> RPat l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> RPat l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RPat l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> RPat l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RPat l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RPat l -> m (RPat l)
    Data,(forall m. Monoid m => RPat m -> m)
    -> (forall m a. Monoid m => (a -> m) -> RPat a -> m)
    -> (forall m a. Monoid m => (a -> m) -> RPat a -> m)
    -> (forall a b. (a -> b -> b) -> b -> RPat a -> b)
    -> (forall a b. (a -> b -> b) -> b -> RPat a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RPat a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RPat a -> b)
    -> (forall a. (a -> a -> a) -> RPat a -> a)
    -> (forall a. (a -> a -> a) -> RPat a -> a)
    -> (forall a. RPat a -> [a])
    -> (forall a. RPat a -> Bool)
    -> (forall a. RPat a -> Int)
    -> (forall a. Eq a => a -> RPat a -> Bool)
    -> (forall a. Ord a => RPat a -> a)
    -> (forall a. Ord a => RPat a -> a)
    -> (forall a. Num a => RPat a -> a)
    -> (forall a. Num a => RPat a -> a)
    -> Foldable RPat
    forall a. Eq a => a -> RPat a -> Bool
    forall a. Num a => RPat a -> a
    forall a. Ord a => RPat a -> a
    forall m. Monoid m => RPat m -> m
    forall a. RPat a -> Bool
    forall a. RPat a -> Int
    forall a. RPat a -> [a]
    forall a. (a -> a -> a) -> RPat a -> a
    forall m a. Monoid m => (a -> m) -> RPat a -> m
    forall b a. (b -> a -> b) -> b -> RPat a -> b
    forall a b. (a -> b -> b) -> b -> RPat a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => RPat m -> m
    fold :: forall m. Monoid m => RPat m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> RPat a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> RPat a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> RPat a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> RPat a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> RPat a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> RPat a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> RPat a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> RPat a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> RPat a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> RPat a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> RPat a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> RPat a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> RPat a -> a
    foldr1 :: forall a. (a -> a -> a) -> RPat a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> RPat a -> a
    foldl1 :: forall a. (a -> a -> a) -> RPat a -> a
    $ctoList :: forall a. RPat a -> [a]
    toList :: forall a. RPat a -> [a]
    $cnull :: forall a. RPat a -> Bool
    null :: forall a. RPat a -> Bool
    $clength :: forall a. RPat a -> Int
    length :: forall a. RPat a -> Int
    $celem :: forall a. Eq a => a -> RPat a -> Bool
    elem :: forall a. Eq a => a -> RPat a -> Bool
    $cmaximum :: forall a. Ord a => RPat a -> a
    maximum :: forall a. Ord a => RPat a -> a
    $cminimum :: forall a. Ord a => RPat a -> a
    minimum :: forall a. Ord a => RPat a -> a
    $csum :: forall a. Num a => RPat a -> a
    sum :: forall a. Num a => RPat a -> a
    $cproduct :: forall a. Num a => RPat a -> a
    product :: forall a. Num a => RPat a -> a
    Foldable,Functor RPat
    Foldable RPat
    (Functor RPat, Foldable RPat) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> RPat a -> f (RPat b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        RPat (f a) -> f (RPat a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> RPat a -> m (RPat b))
    -> (forall (m :: * -> *) a. Monad m => RPat (m a) -> m (RPat a))
    -> Traversable RPat
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => RPat (m a) -> m (RPat a)
    forall (f :: * -> *) a. Applicative f => RPat (f a) -> f (RPat a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RPat a -> m (RPat b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RPat a -> f (RPat b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RPat a -> f (RPat b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RPat a -> f (RPat b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => RPat (f a) -> f (RPat a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => RPat (f a) -> f (RPat a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RPat a -> m (RPat b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RPat a -> m (RPat b)
    $csequence :: forall (m :: * -> *) a. Monad m => RPat (m a) -> m (RPat a)
    sequence :: forall (m :: * -> *) a. Monad m => RPat (m a) -> m (RPat a)
    Traversable,(forall a b. (a -> b) -> RPat a -> RPat b)
    -> (forall a b. a -> RPat b -> RPat a) -> Functor RPat
    forall a b. a -> RPat b -> RPat a
    forall a b. (a -> b) -> RPat a -> RPat b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> RPat a -> RPat b
    fmap :: forall a b. (a -> b) -> RPat a -> RPat b
    $c<$ :: forall a b. a -> RPat b -> RPat a
    <$ :: forall a b. a -> RPat b -> RPat a
    Functor,(forall x. RPat l -> Rep (RPat l) x)
    -> (forall x. Rep (RPat l) x -> RPat l) -> Generic (RPat l)
    forall x. Rep (RPat l) x -> RPat l
    forall x. RPat l -> Rep (RPat l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (RPat l) x -> RPat l
    forall l x. RPat l -> Rep (RPat l) x
    $cfrom :: forall l x. RPat l -> Rep (RPat l) x
    from :: forall x. RPat l -> Rep (RPat l) x
    $cto :: forall l x. Rep (RPat l) x -> RPat l
    to :: forall x. Rep (RPat l) x -> RPat l
    Generic)

    -- | An /fpat/ in a labeled record pattern.
    data PatField l
        = PFieldPat l (QName l) (Pat l)     -- ^ ordinary label-pattern pair
        | PFieldPun l (QName l)             -- ^ record field pun
        | PFieldWildcard l                  -- ^ record field wildcard
      deriving (PatField l -> PatField l -> Bool
    (PatField l -> PatField l -> Bool)
    -> (PatField l -> PatField l -> Bool) -> Eq (PatField l)
    forall l. Eq l => PatField l -> PatField l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => PatField l -> PatField l -> Bool
    == :: PatField l -> PatField l -> Bool
    $c/= :: forall l. Eq l => PatField l -> PatField l -> Bool
    /= :: PatField l -> PatField l -> Bool
    Eq,Eq (PatField l)
    Eq (PatField l) =>
    (PatField l -> PatField l -> Ordering)
    -> (PatField l -> PatField l -> Bool)
    -> (PatField l -> PatField l -> Bool)
    -> (PatField l -> PatField l -> Bool)
    -> (PatField l -> PatField l -> Bool)
    -> (PatField l -> PatField l -> PatField l)
    -> (PatField l -> PatField l -> PatField l)
    -> Ord (PatField l)
    PatField l -> PatField l -> Bool
    PatField l -> PatField l -> Ordering
    PatField l -> PatField l -> PatField l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (PatField l)
    forall l. Ord l => PatField l -> PatField l -> Bool
    forall l. Ord l => PatField l -> PatField l -> Ordering
    forall l. Ord l => PatField l -> PatField l -> PatField l
    $ccompare :: forall l. Ord l => PatField l -> PatField l -> Ordering
    compare :: PatField l -> PatField l -> Ordering
    $c< :: forall l. Ord l => PatField l -> PatField l -> Bool
    < :: PatField l -> PatField l -> Bool
    $c<= :: forall l. Ord l => PatField l -> PatField l -> Bool
    <= :: PatField l -> PatField l -> Bool
    $c> :: forall l. Ord l => PatField l -> PatField l -> Bool
    > :: PatField l -> PatField l -> Bool
    $c>= :: forall l. Ord l => PatField l -> PatField l -> Bool
    >= :: PatField l -> PatField l -> Bool
    $cmax :: forall l. Ord l => PatField l -> PatField l -> PatField l
    max :: PatField l -> PatField l -> PatField l
    $cmin :: forall l. Ord l => PatField l -> PatField l -> PatField l
    min :: PatField l -> PatField l -> PatField l
    Ord,Int -> PatField l -> ShowS
    [PatField l] -> ShowS
    PatField l -> String
    (Int -> PatField l -> ShowS)
    -> (PatField l -> String)
    -> ([PatField l] -> ShowS)
    -> Show (PatField l)
    forall l. Show l => Int -> PatField l -> ShowS
    forall l. Show l => [PatField l] -> ShowS
    forall l. Show l => PatField l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> PatField l -> ShowS
    showsPrec :: Int -> PatField l -> ShowS
    $cshow :: forall l. Show l => PatField l -> String
    show :: PatField l -> String
    $cshowList :: forall l. Show l => [PatField l] -> ShowS
    showList :: [PatField l] -> ShowS
    Show,Typeable,Typeable (PatField l)
    Typeable (PatField l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> PatField l -> c (PatField l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (PatField l))
    -> (PatField l -> Constr)
    -> (PatField l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (PatField l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (PatField l)))
    -> ((forall b. Data b => b -> b) -> PatField l -> PatField l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PatField l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PatField l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PatField l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> PatField l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PatField l -> m (PatField l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PatField l -> m (PatField l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PatField l -> m (PatField l))
    -> Data (PatField l)
    PatField l -> Constr
    PatField l -> DataType
    (forall b. Data b => b -> b) -> PatField l -> PatField l
    forall l. Data l => Typeable (PatField l)
    forall l. Data l => PatField l -> Constr
    forall l. Data l => PatField l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> PatField l -> PatField l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> PatField l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> PatField l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatField l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatField l -> c (PatField l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatField l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatField l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> PatField l -> u
    forall u. (forall d. Data d => d -> u) -> PatField l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatField l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatField l -> c (PatField l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatField l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatField l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatField l -> c (PatField l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatField l -> c (PatField l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatField l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PatField l)
    $ctoConstr :: forall l. Data l => PatField l -> Constr
    toConstr :: PatField l -> Constr
    $cdataTypeOf :: forall l. Data l => PatField l -> DataType
    dataTypeOf :: PatField l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatField l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PatField l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatField l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PatField l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> PatField l -> PatField l
    gmapT :: (forall b. Data b => b -> b) -> PatField l -> PatField l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatField l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> PatField l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PatField l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> PatField l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatField l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatField l -> m (PatField l)
    Data,(forall m. Monoid m => PatField m -> m)
    -> (forall m a. Monoid m => (a -> m) -> PatField a -> m)
    -> (forall m a. Monoid m => (a -> m) -> PatField a -> m)
    -> (forall a b. (a -> b -> b) -> b -> PatField a -> b)
    -> (forall a b. (a -> b -> b) -> b -> PatField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PatField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PatField a -> b)
    -> (forall a. (a -> a -> a) -> PatField a -> a)
    -> (forall a. (a -> a -> a) -> PatField a -> a)
    -> (forall a. PatField a -> [a])
    -> (forall a. PatField a -> Bool)
    -> (forall a. PatField a -> Int)
    -> (forall a. Eq a => a -> PatField a -> Bool)
    -> (forall a. Ord a => PatField a -> a)
    -> (forall a. Ord a => PatField a -> a)
    -> (forall a. Num a => PatField a -> a)
    -> (forall a. Num a => PatField a -> a)
    -> Foldable PatField
    forall a. Eq a => a -> PatField a -> Bool
    forall a. Num a => PatField a -> a
    forall a. Ord a => PatField a -> a
    forall m. Monoid m => PatField m -> m
    forall a. PatField a -> Bool
    forall a. PatField a -> Int
    forall a. PatField a -> [a]
    forall a. (a -> a -> a) -> PatField a -> a
    forall m a. Monoid m => (a -> m) -> PatField a -> m
    forall b a. (b -> a -> b) -> b -> PatField a -> b
    forall a b. (a -> b -> b) -> b -> PatField a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => PatField m -> m
    fold :: forall m. Monoid m => PatField m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> PatField a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> PatField a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> PatField a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> PatField a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> PatField a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> PatField a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> PatField a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> PatField a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> PatField a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> PatField a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> PatField a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> PatField a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> PatField a -> a
    foldr1 :: forall a. (a -> a -> a) -> PatField a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> PatField a -> a
    foldl1 :: forall a. (a -> a -> a) -> PatField a -> a
    $ctoList :: forall a. PatField a -> [a]
    toList :: forall a. PatField a -> [a]
    $cnull :: forall a. PatField a -> Bool
    null :: forall a. PatField a -> Bool
    $clength :: forall a. PatField a -> Int
    length :: forall a. PatField a -> Int
    $celem :: forall a. Eq a => a -> PatField a -> Bool
    elem :: forall a. Eq a => a -> PatField a -> Bool
    $cmaximum :: forall a. Ord a => PatField a -> a
    maximum :: forall a. Ord a => PatField a -> a
    $cminimum :: forall a. Ord a => PatField a -> a
    minimum :: forall a. Ord a => PatField a -> a
    $csum :: forall a. Num a => PatField a -> a
    sum :: forall a. Num a => PatField a -> a
    $cproduct :: forall a. Num a => PatField a -> a
    product :: forall a. Num a => PatField a -> a
    Foldable,Functor PatField
    Foldable PatField
    (Functor PatField, Foldable PatField) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> PatField a -> f (PatField b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        PatField (f a) -> f (PatField a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> PatField a -> m (PatField b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        PatField (m a) -> m (PatField a))
    -> Traversable PatField
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => PatField (m a) -> m (PatField a)
    forall (f :: * -> *) a.
    Applicative f =>
    PatField (f a) -> f (PatField a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PatField a -> m (PatField b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PatField a -> f (PatField b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PatField a -> f (PatField b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PatField a -> f (PatField b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PatField (f a) -> f (PatField a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PatField (f a) -> f (PatField a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PatField a -> m (PatField b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PatField a -> m (PatField b)
    $csequence :: forall (m :: * -> *) a. Monad m => PatField (m a) -> m (PatField a)
    sequence :: forall (m :: * -> *) a. Monad m => PatField (m a) -> m (PatField a)
    Traversable,(forall a b. (a -> b) -> PatField a -> PatField b)
    -> (forall a b. a -> PatField b -> PatField a) -> Functor PatField
    forall a b. a -> PatField b -> PatField a
    forall a b. (a -> b) -> PatField a -> PatField b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> PatField a -> PatField b
    fmap :: forall a b. (a -> b) -> PatField a -> PatField b
    $c<$ :: forall a b. a -> PatField b -> PatField a
    <$ :: forall a b. a -> PatField b -> PatField a
    Functor,(forall x. PatField l -> Rep (PatField l) x)
    -> (forall x. Rep (PatField l) x -> PatField l)
    -> Generic (PatField l)
    forall x. Rep (PatField l) x -> PatField l
    forall x. PatField l -> Rep (PatField l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (PatField l) x -> PatField l
    forall l x. PatField l -> Rep (PatField l) x
    $cfrom :: forall l x. PatField l -> Rep (PatField l) x
    from :: forall x. PatField l -> Rep (PatField l) x
    $cto :: forall l x. Rep (PatField l) x -> PatField l
    to :: forall x. Rep (PatField l) x -> PatField l
    Generic)

    -- | A statement, representing both a /stmt/ in a @do@-expression,
    --   an ordinary /qual/ in a list comprehension, as well as a /stmt/
    --   in a pattern guard.
    data Stmt l
        = Generator l (Pat l) (Exp l)
                                -- ^ a generator: /pat/ @<-@ /exp/
        | Qualifier l (Exp l)   -- ^ an /exp/ by itself: in a @do@-expression,
                                --   an action whose result is discarded;
                                --   in a list comprehension and pattern guard,
                                --   a guard expression
        | LetStmt l (Binds l)   -- ^ local bindings
        | RecStmt l [Stmt l]    -- ^ a recursive binding group for arrows
      deriving (Stmt l -> Stmt l -> Bool
    (Stmt l -> Stmt l -> Bool)
    -> (Stmt l -> Stmt l -> Bool) -> Eq (Stmt l)
    forall l. Eq l => Stmt l -> Stmt l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Stmt l -> Stmt l -> Bool
    == :: Stmt l -> Stmt l -> Bool
    $c/= :: forall l. Eq l => Stmt l -> Stmt l -> Bool
    /= :: Stmt l -> Stmt l -> Bool
    Eq,Eq (Stmt l)
    Eq (Stmt l) =>
    (Stmt l -> Stmt l -> Ordering)
    -> (Stmt l -> Stmt l -> Bool)
    -> (Stmt l -> Stmt l -> Bool)
    -> (Stmt l -> Stmt l -> Bool)
    -> (Stmt l -> Stmt l -> Bool)
    -> (Stmt l -> Stmt l -> Stmt l)
    -> (Stmt l -> Stmt l -> Stmt l)
    -> Ord (Stmt l)
    Stmt l -> Stmt l -> Bool
    Stmt l -> Stmt l -> Ordering
    Stmt l -> Stmt l -> Stmt l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Stmt l)
    forall l. Ord l => Stmt l -> Stmt l -> Bool
    forall l. Ord l => Stmt l -> Stmt l -> Ordering
    forall l. Ord l => Stmt l -> Stmt l -> Stmt l
    $ccompare :: forall l. Ord l => Stmt l -> Stmt l -> Ordering
    compare :: Stmt l -> Stmt l -> Ordering
    $c< :: forall l. Ord l => Stmt l -> Stmt l -> Bool
    < :: Stmt l -> Stmt l -> Bool
    $c<= :: forall l. Ord l => Stmt l -> Stmt l -> Bool
    <= :: Stmt l -> Stmt l -> Bool
    $c> :: forall l. Ord l => Stmt l -> Stmt l -> Bool
    > :: Stmt l -> Stmt l -> Bool
    $c>= :: forall l. Ord l => Stmt l -> Stmt l -> Bool
    >= :: Stmt l -> Stmt l -> Bool
    $cmax :: forall l. Ord l => Stmt l -> Stmt l -> Stmt l
    max :: Stmt l -> Stmt l -> Stmt l
    $cmin :: forall l. Ord l => Stmt l -> Stmt l -> Stmt l
    min :: Stmt l -> Stmt l -> Stmt l
    Ord,Int -> Stmt l -> ShowS
    [Stmt l] -> ShowS
    Stmt l -> String
    (Int -> Stmt l -> ShowS)
    -> (Stmt l -> String) -> ([Stmt l] -> ShowS) -> Show (Stmt l)
    forall l. Show l => Int -> Stmt l -> ShowS
    forall l. Show l => [Stmt l] -> ShowS
    forall l. Show l => Stmt l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Stmt l -> ShowS
    showsPrec :: Int -> Stmt l -> ShowS
    $cshow :: forall l. Show l => Stmt l -> String
    show :: Stmt l -> String
    $cshowList :: forall l. Show l => [Stmt l] -> ShowS
    showList :: [Stmt l] -> ShowS
    Show,Typeable,Typeable (Stmt l)
    Typeable (Stmt l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Stmt l -> c (Stmt l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Stmt l))
    -> (Stmt l -> Constr)
    -> (Stmt l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Stmt l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l)))
    -> ((forall b. Data b => b -> b) -> Stmt l -> Stmt l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Stmt l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Stmt l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Stmt l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Stmt l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l))
    -> Data (Stmt l)
    Stmt l -> Constr
    Stmt l -> DataType
    (forall b. Data b => b -> b) -> Stmt l -> Stmt l
    forall l. Data l => Typeable (Stmt l)
    forall l. Data l => Stmt l -> Constr
    forall l. Data l => Stmt l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Stmt l -> Stmt l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Stmt l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Stmt l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Stmt l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stmt l -> c (Stmt l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Stmt l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Stmt l -> u
    forall u. (forall d. Data d => d -> u) -> Stmt l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Stmt l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stmt l -> c (Stmt l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Stmt l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stmt l -> c (Stmt l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stmt l -> c (Stmt l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Stmt l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Stmt l)
    $ctoConstr :: forall l. Data l => Stmt l -> Constr
    toConstr :: Stmt l -> Constr
    $cdataTypeOf :: forall l. Data l => Stmt l -> DataType
    dataTypeOf :: Stmt l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Stmt l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Stmt l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> Stmt l -> Stmt l
    gmapT :: (forall b. Data b => b -> b) -> Stmt l -> Stmt l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Stmt l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Stmt l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Stmt l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stmt l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l)
    Data,(forall m. Monoid m => Stmt m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Stmt a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Stmt a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Stmt a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Stmt a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Stmt a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Stmt a -> b)
    -> (forall a. (a -> a -> a) -> Stmt a -> a)
    -> (forall a. (a -> a -> a) -> Stmt a -> a)
    -> (forall a. Stmt a -> [a])
    -> (forall a. Stmt a -> Bool)
    -> (forall a. Stmt a -> Int)
    -> (forall a. Eq a => a -> Stmt a -> Bool)
    -> (forall a. Ord a => Stmt a -> a)
    -> (forall a. Ord a => Stmt a -> a)
    -> (forall a. Num a => Stmt a -> a)
    -> (forall a. Num a => Stmt a -> a)
    -> Foldable Stmt
    forall a. Eq a => a -> Stmt a -> Bool
    forall a. Num a => Stmt a -> a
    forall a. Ord a => Stmt a -> a
    forall m. Monoid m => Stmt m -> m
    forall a. Stmt a -> Bool
    forall a. Stmt a -> Int
    forall a. Stmt a -> [a]
    forall a. (a -> a -> a) -> Stmt a -> a
    forall m a. Monoid m => (a -> m) -> Stmt a -> m
    forall b a. (b -> a -> b) -> b -> Stmt a -> b
    forall a b. (a -> b -> b) -> b -> Stmt a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Stmt m -> m
    fold :: forall m. Monoid m => Stmt m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Stmt a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Stmt a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Stmt a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Stmt a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Stmt a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Stmt a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Stmt a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Stmt a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Stmt a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Stmt a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Stmt a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Stmt a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Stmt a -> a
    foldr1 :: forall a. (a -> a -> a) -> Stmt a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Stmt a -> a
    foldl1 :: forall a. (a -> a -> a) -> Stmt a -> a
    $ctoList :: forall a. Stmt a -> [a]
    toList :: forall a. Stmt a -> [a]
    $cnull :: forall a. Stmt a -> Bool
    null :: forall a. Stmt a -> Bool
    $clength :: forall a. Stmt a -> Int
    length :: forall a. Stmt a -> Int
    $celem :: forall a. Eq a => a -> Stmt a -> Bool
    elem :: forall a. Eq a => a -> Stmt a -> Bool
    $cmaximum :: forall a. Ord a => Stmt a -> a
    maximum :: forall a. Ord a => Stmt a -> a
    $cminimum :: forall a. Ord a => Stmt a -> a
    minimum :: forall a. Ord a => Stmt a -> a
    $csum :: forall a. Num a => Stmt a -> a
    sum :: forall a. Num a => Stmt a -> a
    $cproduct :: forall a. Num a => Stmt a -> a
    product :: forall a. Num a => Stmt a -> a
    Foldable,Functor Stmt
    Foldable Stmt
    (Functor Stmt, Foldable Stmt) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Stmt a -> f (Stmt b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Stmt (f a) -> f (Stmt a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Stmt a -> m (Stmt b))
    -> (forall (m :: * -> *) a. Monad m => Stmt (m a) -> m (Stmt a))
    -> Traversable Stmt
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Stmt (m a) -> m (Stmt a)
    forall (f :: * -> *) a. Applicative f => Stmt (f a) -> f (Stmt a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Stmt a -> m (Stmt b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Stmt a -> f (Stmt b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Stmt a -> f (Stmt b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Stmt a -> f (Stmt b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Stmt (f a) -> f (Stmt a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Stmt (f a) -> f (Stmt a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Stmt a -> m (Stmt b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Stmt a -> m (Stmt b)
    $csequence :: forall (m :: * -> *) a. Monad m => Stmt (m a) -> m (Stmt a)
    sequence :: forall (m :: * -> *) a. Monad m => Stmt (m a) -> m (Stmt a)
    Traversable,(forall a b. (a -> b) -> Stmt a -> Stmt b)
    -> (forall a b. a -> Stmt b -> Stmt a) -> Functor Stmt
    forall a b. a -> Stmt b -> Stmt a
    forall a b. (a -> b) -> Stmt a -> Stmt b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Stmt a -> Stmt b
    fmap :: forall a b. (a -> b) -> Stmt a -> Stmt b
    $c<$ :: forall a b. a -> Stmt b -> Stmt a
    <$ :: forall a b. a -> Stmt b -> Stmt a
    Functor,(forall x. Stmt l -> Rep (Stmt l) x)
    -> (forall x. Rep (Stmt l) x -> Stmt l) -> Generic (Stmt l)
    forall x. Rep (Stmt l) x -> Stmt l
    forall x. Stmt l -> Rep (Stmt l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Stmt l) x -> Stmt l
    forall l x. Stmt l -> Rep (Stmt l) x
    $cfrom :: forall l x. Stmt l -> Rep (Stmt l) x
    from :: forall x. Stmt l -> Rep (Stmt l) x
    $cto :: forall l x. Rep (Stmt l) x -> Stmt l
    to :: forall x. Rep (Stmt l) x -> Stmt l
    Generic)

    -- | A general /transqual/ in a list comprehension,
    --   which could potentially be a transform of the kind
    --   enabled by TransformListComp.
    data QualStmt l
        = QualStmt     l (Stmt l)         -- ^ an ordinary statement
        | ThenTrans    l (Exp l)          -- ^ @then@ /exp/
        | ThenBy       l (Exp l) (Exp l)  -- ^ @then@ /exp/ @by@ /exp/
        | GroupBy      l (Exp l)          -- ^ @then@ @group@ @by@ /exp/
        | GroupUsing   l (Exp l)          -- ^ @then@ @group@ @using@ /exp/
        | GroupByUsing l (Exp l) (Exp l)  -- ^ @then@ @group@ @by@ /exp/ @using@ /exp/
      deriving (QualStmt l -> QualStmt l -> Bool
    (QualStmt l -> QualStmt l -> Bool)
    -> (QualStmt l -> QualStmt l -> Bool) -> Eq (QualStmt l)
    forall l. Eq l => QualStmt l -> QualStmt l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => QualStmt l -> QualStmt l -> Bool
    == :: QualStmt l -> QualStmt l -> Bool
    $c/= :: forall l. Eq l => QualStmt l -> QualStmt l -> Bool
    /= :: QualStmt l -> QualStmt l -> Bool
    Eq,Eq (QualStmt l)
    Eq (QualStmt l) =>
    (QualStmt l -> QualStmt l -> Ordering)
    -> (QualStmt l -> QualStmt l -> Bool)
    -> (QualStmt l -> QualStmt l -> Bool)
    -> (QualStmt l -> QualStmt l -> Bool)
    -> (QualStmt l -> QualStmt l -> Bool)
    -> (QualStmt l -> QualStmt l -> QualStmt l)
    -> (QualStmt l -> QualStmt l -> QualStmt l)
    -> Ord (QualStmt l)
    QualStmt l -> QualStmt l -> Bool
    QualStmt l -> QualStmt l -> Ordering
    QualStmt l -> QualStmt l -> QualStmt l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (QualStmt l)
    forall l. Ord l => QualStmt l -> QualStmt l -> Bool
    forall l. Ord l => QualStmt l -> QualStmt l -> Ordering
    forall l. Ord l => QualStmt l -> QualStmt l -> QualStmt l
    $ccompare :: forall l. Ord l => QualStmt l -> QualStmt l -> Ordering
    compare :: QualStmt l -> QualStmt l -> Ordering
    $c< :: forall l. Ord l => QualStmt l -> QualStmt l -> Bool
    < :: QualStmt l -> QualStmt l -> Bool
    $c<= :: forall l. Ord l => QualStmt l -> QualStmt l -> Bool
    <= :: QualStmt l -> QualStmt l -> Bool
    $c> :: forall l. Ord l => QualStmt l -> QualStmt l -> Bool
    > :: QualStmt l -> QualStmt l -> Bool
    $c>= :: forall l. Ord l => QualStmt l -> QualStmt l -> Bool
    >= :: QualStmt l -> QualStmt l -> Bool
    $cmax :: forall l. Ord l => QualStmt l -> QualStmt l -> QualStmt l
    max :: QualStmt l -> QualStmt l -> QualStmt l
    $cmin :: forall l. Ord l => QualStmt l -> QualStmt l -> QualStmt l
    min :: QualStmt l -> QualStmt l -> QualStmt l
    Ord,Int -> QualStmt l -> ShowS
    [QualStmt l] -> ShowS
    QualStmt l -> String
    (Int -> QualStmt l -> ShowS)
    -> (QualStmt l -> String)
    -> ([QualStmt l] -> ShowS)
    -> Show (QualStmt l)
    forall l. Show l => Int -> QualStmt l -> ShowS
    forall l. Show l => [QualStmt l] -> ShowS
    forall l. Show l => QualStmt l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> QualStmt l -> ShowS
    showsPrec :: Int -> QualStmt l -> ShowS
    $cshow :: forall l. Show l => QualStmt l -> String
    show :: QualStmt l -> String
    $cshowList :: forall l. Show l => [QualStmt l] -> ShowS
    showList :: [QualStmt l] -> ShowS
    Show,Typeable,Typeable (QualStmt l)
    Typeable (QualStmt l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (QualStmt l))
    -> (QualStmt l -> Constr)
    -> (QualStmt l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (QualStmt l)))
    -> ((forall b. Data b => b -> b) -> QualStmt l -> QualStmt l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> QualStmt l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> QualStmt l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l))
    -> Data (QualStmt l)
    QualStmt l -> Constr
    QualStmt l -> DataType
    (forall b. Data b => b -> b) -> QualStmt l -> QualStmt l
    forall l. Data l => Typeable (QualStmt l)
    forall l. Data l => QualStmt l -> Constr
    forall l. Data l => QualStmt l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> QualStmt l -> QualStmt l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> QualStmt l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> QualStmt l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualStmt l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualStmt l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> QualStmt l -> u
    forall u. (forall d. Data d => d -> u) -> QualStmt l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualStmt l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualStmt l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualStmt l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (QualStmt l)
    $ctoConstr :: forall l. Data l => QualStmt l -> Constr
    toConstr :: QualStmt l -> Constr
    $cdataTypeOf :: forall l. Data l => QualStmt l -> DataType
    dataTypeOf :: QualStmt l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualStmt l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (QualStmt l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> QualStmt l -> QualStmt l
    gmapT :: (forall b. Data b => b -> b) -> QualStmt l -> QualStmt l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> QualStmt l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> QualStmt l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> QualStmt l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QualStmt l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l)
    Data,(forall m. Monoid m => QualStmt m -> m)
    -> (forall m a. Monoid m => (a -> m) -> QualStmt a -> m)
    -> (forall m a. Monoid m => (a -> m) -> QualStmt a -> m)
    -> (forall a b. (a -> b -> b) -> b -> QualStmt a -> b)
    -> (forall a b. (a -> b -> b) -> b -> QualStmt a -> b)
    -> (forall b a. (b -> a -> b) -> b -> QualStmt a -> b)
    -> (forall b a. (b -> a -> b) -> b -> QualStmt a -> b)
    -> (forall a. (a -> a -> a) -> QualStmt a -> a)
    -> (forall a. (a -> a -> a) -> QualStmt a -> a)
    -> (forall a. QualStmt a -> [a])
    -> (forall a. QualStmt a -> Bool)
    -> (forall a. QualStmt a -> Int)
    -> (forall a. Eq a => a -> QualStmt a -> Bool)
    -> (forall a. Ord a => QualStmt a -> a)
    -> (forall a. Ord a => QualStmt a -> a)
    -> (forall a. Num a => QualStmt a -> a)
    -> (forall a. Num a => QualStmt a -> a)
    -> Foldable QualStmt
    forall a. Eq a => a -> QualStmt a -> Bool
    forall a. Num a => QualStmt a -> a
    forall a. Ord a => QualStmt a -> a
    forall m. Monoid m => QualStmt m -> m
    forall a. QualStmt a -> Bool
    forall a. QualStmt a -> Int
    forall a. QualStmt a -> [a]
    forall a. (a -> a -> a) -> QualStmt a -> a
    forall m a. Monoid m => (a -> m) -> QualStmt a -> m
    forall b a. (b -> a -> b) -> b -> QualStmt a -> b
    forall a b. (a -> b -> b) -> b -> QualStmt a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => QualStmt m -> m
    fold :: forall m. Monoid m => QualStmt m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> QualStmt a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> QualStmt a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> QualStmt a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> QualStmt a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> QualStmt a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> QualStmt a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> QualStmt a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> QualStmt a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> QualStmt a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> QualStmt a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> QualStmt a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> QualStmt a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> QualStmt a -> a
    foldr1 :: forall a. (a -> a -> a) -> QualStmt a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> QualStmt a -> a
    foldl1 :: forall a. (a -> a -> a) -> QualStmt a -> a
    $ctoList :: forall a. QualStmt a -> [a]
    toList :: forall a. QualStmt a -> [a]
    $cnull :: forall a. QualStmt a -> Bool
    null :: forall a. QualStmt a -> Bool
    $clength :: forall a. QualStmt a -> Int
    length :: forall a. QualStmt a -> Int
    $celem :: forall a. Eq a => a -> QualStmt a -> Bool
    elem :: forall a. Eq a => a -> QualStmt a -> Bool
    $cmaximum :: forall a. Ord a => QualStmt a -> a
    maximum :: forall a. Ord a => QualStmt a -> a
    $cminimum :: forall a. Ord a => QualStmt a -> a
    minimum :: forall a. Ord a => QualStmt a -> a
    $csum :: forall a. Num a => QualStmt a -> a
    sum :: forall a. Num a => QualStmt a -> a
    $cproduct :: forall a. Num a => QualStmt a -> a
    product :: forall a. Num a => QualStmt a -> a
    Foldable,Functor QualStmt
    Foldable QualStmt
    (Functor QualStmt, Foldable QualStmt) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> QualStmt a -> f (QualStmt b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        QualStmt (f a) -> f (QualStmt a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> QualStmt a -> m (QualStmt b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        QualStmt (m a) -> m (QualStmt a))
    -> Traversable QualStmt
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => QualStmt (m a) -> m (QualStmt a)
    forall (f :: * -> *) a.
    Applicative f =>
    QualStmt (f a) -> f (QualStmt a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QualStmt a -> m (QualStmt b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QualStmt a -> f (QualStmt b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QualStmt a -> f (QualStmt b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> QualStmt a -> f (QualStmt b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    QualStmt (f a) -> f (QualStmt a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    QualStmt (f a) -> f (QualStmt a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QualStmt a -> m (QualStmt b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QualStmt a -> m (QualStmt b)
    $csequence :: forall (m :: * -> *) a. Monad m => QualStmt (m a) -> m (QualStmt a)
    sequence :: forall (m :: * -> *) a. Monad m => QualStmt (m a) -> m (QualStmt a)
    Traversable,(forall a b. (a -> b) -> QualStmt a -> QualStmt b)
    -> (forall a b. a -> QualStmt b -> QualStmt a) -> Functor QualStmt
    forall a b. a -> QualStmt b -> QualStmt a
    forall a b. (a -> b) -> QualStmt a -> QualStmt b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> QualStmt a -> QualStmt b
    fmap :: forall a b. (a -> b) -> QualStmt a -> QualStmt b
    $c<$ :: forall a b. a -> QualStmt b -> QualStmt a
    <$ :: forall a b. a -> QualStmt b -> QualStmt a
    Functor,(forall x. QualStmt l -> Rep (QualStmt l) x)
    -> (forall x. Rep (QualStmt l) x -> QualStmt l)
    -> Generic (QualStmt l)
    forall x. Rep (QualStmt l) x -> QualStmt l
    forall x. QualStmt l -> Rep (QualStmt l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (QualStmt l) x -> QualStmt l
    forall l x. QualStmt l -> Rep (QualStmt l) x
    $cfrom :: forall l x. QualStmt l -> Rep (QualStmt l) x
    from :: forall x. QualStmt l -> Rep (QualStmt l) x
    $cto :: forall l x. Rep (QualStmt l) x -> QualStmt l
    to :: forall x. Rep (QualStmt l) x -> QualStmt l
    Generic)

    -- | An /fbind/ in a labeled construction or update expression.
    data FieldUpdate l
        = FieldUpdate l (QName l) (Exp l)    -- ^ ordinary label-expresion pair
        | FieldPun l (QName l)               -- ^ record field pun
        | FieldWildcard l                    -- ^ record field wildcard
      deriving (FieldUpdate l -> FieldUpdate l -> Bool
    (FieldUpdate l -> FieldUpdate l -> Bool)
    -> (FieldUpdate l -> FieldUpdate l -> Bool) -> Eq (FieldUpdate l)
    forall l. Eq l => FieldUpdate l -> FieldUpdate l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => FieldUpdate l -> FieldUpdate l -> Bool
    == :: FieldUpdate l -> FieldUpdate l -> Bool
    $c/= :: forall l. Eq l => FieldUpdate l -> FieldUpdate l -> Bool
    /= :: FieldUpdate l -> FieldUpdate l -> Bool
    Eq,Eq (FieldUpdate l)
    Eq (FieldUpdate l) =>
    (FieldUpdate l -> FieldUpdate l -> Ordering)
    -> (FieldUpdate l -> FieldUpdate l -> Bool)
    -> (FieldUpdate l -> FieldUpdate l -> Bool)
    -> (FieldUpdate l -> FieldUpdate l -> Bool)
    -> (FieldUpdate l -> FieldUpdate l -> Bool)
    -> (FieldUpdate l -> FieldUpdate l -> FieldUpdate l)
    -> (FieldUpdate l -> FieldUpdate l -> FieldUpdate l)
    -> Ord (FieldUpdate l)
    FieldUpdate l -> FieldUpdate l -> Bool
    FieldUpdate l -> FieldUpdate l -> Ordering
    FieldUpdate l -> FieldUpdate l -> FieldUpdate l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (FieldUpdate l)
    forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
    forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Ordering
    forall l. Ord l => FieldUpdate l -> FieldUpdate l -> FieldUpdate l
    $ccompare :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Ordering
    compare :: FieldUpdate l -> FieldUpdate l -> Ordering
    $c< :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
    < :: FieldUpdate l -> FieldUpdate l -> Bool
    $c<= :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
    <= :: FieldUpdate l -> FieldUpdate l -> Bool
    $c> :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
    > :: FieldUpdate l -> FieldUpdate l -> Bool
    $c>= :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> Bool
    >= :: FieldUpdate l -> FieldUpdate l -> Bool
    $cmax :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> FieldUpdate l
    max :: FieldUpdate l -> FieldUpdate l -> FieldUpdate l
    $cmin :: forall l. Ord l => FieldUpdate l -> FieldUpdate l -> FieldUpdate l
    min :: FieldUpdate l -> FieldUpdate l -> FieldUpdate l
    Ord,Int -> FieldUpdate l -> ShowS
    [FieldUpdate l] -> ShowS
    FieldUpdate l -> String
    (Int -> FieldUpdate l -> ShowS)
    -> (FieldUpdate l -> String)
    -> ([FieldUpdate l] -> ShowS)
    -> Show (FieldUpdate l)
    forall l. Show l => Int -> FieldUpdate l -> ShowS
    forall l. Show l => [FieldUpdate l] -> ShowS
    forall l. Show l => FieldUpdate l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> FieldUpdate l -> ShowS
    showsPrec :: Int -> FieldUpdate l -> ShowS
    $cshow :: forall l. Show l => FieldUpdate l -> String
    show :: FieldUpdate l -> String
    $cshowList :: forall l. Show l => [FieldUpdate l] -> ShowS
    showList :: [FieldUpdate l] -> ShowS
    Show,Typeable,Typeable (FieldUpdate l)
    Typeable (FieldUpdate l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l))
    -> (FieldUpdate l -> Constr)
    -> (FieldUpdate l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (FieldUpdate l)))
    -> ((forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> FieldUpdate l -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> FieldUpdate l -> m (FieldUpdate l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FieldUpdate l -> m (FieldUpdate l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> FieldUpdate l -> m (FieldUpdate l))
    -> Data (FieldUpdate l)
    FieldUpdate l -> Constr
    FieldUpdate l -> DataType
    (forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l
    forall l. Data l => Typeable (FieldUpdate l)
    forall l. Data l => FieldUpdate l -> Constr
    forall l. Data l => FieldUpdate l -> DataType
    forall l.
    Data l =>
    (forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u
    forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> FieldUpdate l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldUpdate l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u
    forall u. (forall d. Data d => d -> u) -> FieldUpdate l -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldUpdate l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l)
    $ctoConstr :: forall l. Data l => FieldUpdate l -> Constr
    toConstr :: FieldUpdate l -> Constr
    $cdataTypeOf :: forall l. Data l => FieldUpdate l -> DataType
    dataTypeOf :: FieldUpdate l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldUpdate l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FieldUpdate l))
    $cgmapT :: forall l.
    Data l =>
    (forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l
    gmapT :: (forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r
    $cgmapQ :: forall l u.
    Data l =>
    (forall d. Data d => d -> u) -> FieldUpdate l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FieldUpdate l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FieldUpdate l -> m (FieldUpdate l)
    Data,(forall m. Monoid m => FieldUpdate m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b)
    -> (forall a. (a -> a -> a) -> FieldUpdate a -> a)
    -> (forall a. (a -> a -> a) -> FieldUpdate a -> a)
    -> (forall a. FieldUpdate a -> [a])
    -> (forall a. FieldUpdate a -> Bool)
    -> (forall a. FieldUpdate a -> Int)
    -> (forall a. Eq a => a -> FieldUpdate a -> Bool)
    -> (forall a. Ord a => FieldUpdate a -> a)
    -> (forall a. Ord a => FieldUpdate a -> a)
    -> (forall a. Num a => FieldUpdate a -> a)
    -> (forall a. Num a => FieldUpdate a -> a)
    -> Foldable FieldUpdate
    forall a. Eq a => a -> FieldUpdate a -> Bool
    forall a. Num a => FieldUpdate a -> a
    forall a. Ord a => FieldUpdate a -> a
    forall m. Monoid m => FieldUpdate m -> m
    forall a. FieldUpdate a -> Bool
    forall a. FieldUpdate a -> Int
    forall a. FieldUpdate a -> [a]
    forall a. (a -> a -> a) -> FieldUpdate a -> a
    forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
    forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
    forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => FieldUpdate m -> m
    fold :: forall m. Monoid m => FieldUpdate m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> FieldUpdate a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> FieldUpdate a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> FieldUpdate a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> FieldUpdate a -> a
    foldr1 :: forall a. (a -> a -> a) -> FieldUpdate a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> FieldUpdate a -> a
    foldl1 :: forall a. (a -> a -> a) -> FieldUpdate a -> a
    $ctoList :: forall a. FieldUpdate a -> [a]
    toList :: forall a. FieldUpdate a -> [a]
    $cnull :: forall a. FieldUpdate a -> Bool
    null :: forall a. FieldUpdate a -> Bool
    $clength :: forall a. FieldUpdate a -> Int
    length :: forall a. FieldUpdate a -> Int
    $celem :: forall a. Eq a => a -> FieldUpdate a -> Bool
    elem :: forall a. Eq a => a -> FieldUpdate a -> Bool
    $cmaximum :: forall a. Ord a => FieldUpdate a -> a
    maximum :: forall a. Ord a => FieldUpdate a -> a
    $cminimum :: forall a. Ord a => FieldUpdate a -> a
    minimum :: forall a. Ord a => FieldUpdate a -> a
    $csum :: forall a. Num a => FieldUpdate a -> a
    sum :: forall a. Num a => FieldUpdate a -> a
    $cproduct :: forall a. Num a => FieldUpdate a -> a
    product :: forall a. Num a => FieldUpdate a -> a
    Foldable,Functor FieldUpdate
    Foldable FieldUpdate
    (Functor FieldUpdate, Foldable FieldUpdate) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> FieldUpdate a -> f (FieldUpdate b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        FieldUpdate (f a) -> f (FieldUpdate a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> FieldUpdate a -> m (FieldUpdate b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        FieldUpdate (m a) -> m (FieldUpdate a))
    -> Traversable FieldUpdate
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    FieldUpdate (m a) -> m (FieldUpdate a)
    forall (f :: * -> *) a.
    Applicative f =>
    FieldUpdate (f a) -> f (FieldUpdate a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FieldUpdate a -> m (FieldUpdate b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FieldUpdate a -> f (FieldUpdate b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FieldUpdate a -> f (FieldUpdate b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> FieldUpdate a -> f (FieldUpdate b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FieldUpdate (f a) -> f (FieldUpdate a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    FieldUpdate (f a) -> f (FieldUpdate a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FieldUpdate a -> m (FieldUpdate b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FieldUpdate a -> m (FieldUpdate b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    FieldUpdate (m a) -> m (FieldUpdate a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    FieldUpdate (m a) -> m (FieldUpdate a)
    Traversable,(forall a b. (a -> b) -> FieldUpdate a -> FieldUpdate b)
    -> (forall a b. a -> FieldUpdate b -> FieldUpdate a)
    -> Functor FieldUpdate
    forall a b. a -> FieldUpdate b -> FieldUpdate a
    forall a b. (a -> b) -> FieldUpdate a -> FieldUpdate b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> FieldUpdate a -> FieldUpdate b
    fmap :: forall a b. (a -> b) -> FieldUpdate a -> FieldUpdate b
    $c<$ :: forall a b. a -> FieldUpdate b -> FieldUpdate a
    <$ :: forall a b. a -> FieldUpdate b -> FieldUpdate a
    Functor,(forall x. FieldUpdate l -> Rep (FieldUpdate l) x)
    -> (forall x. Rep (FieldUpdate l) x -> FieldUpdate l)
    -> Generic (FieldUpdate l)
    forall x. Rep (FieldUpdate l) x -> FieldUpdate l
    forall x. FieldUpdate l -> Rep (FieldUpdate l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (FieldUpdate l) x -> FieldUpdate l
    forall l x. FieldUpdate l -> Rep (FieldUpdate l) x
    $cfrom :: forall l x. FieldUpdate l -> Rep (FieldUpdate l) x
    from :: forall x. FieldUpdate l -> Rep (FieldUpdate l) x
    $cto :: forall l x. Rep (FieldUpdate l) x -> FieldUpdate l
    to :: forall x. Rep (FieldUpdate l) x -> FieldUpdate l
    Generic)

    -- | An /alt/ alternative in a @case@ expression.
    data Alt l
        = Alt l (Pat l) (Rhs l) (Maybe (Binds l))
      deriving (Alt l -> Alt l -> Bool
    (Alt l -> Alt l -> Bool) -> (Alt l -> Alt l -> Bool) -> Eq (Alt l)
    forall l. Eq l => Alt l -> Alt l -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall l. Eq l => Alt l -> Alt l -> Bool
    == :: Alt l -> Alt l -> Bool
    $c/= :: forall l. Eq l => Alt l -> Alt l -> Bool
    /= :: Alt l -> Alt l -> Bool
    Eq,Eq (Alt l)
    Eq (Alt l) =>
    (Alt l -> Alt l -> Ordering)
    -> (Alt l -> Alt l -> Bool)
    -> (Alt l -> Alt l -> Bool)
    -> (Alt l -> Alt l -> Bool)
    -> (Alt l -> Alt l -> Bool)
    -> (Alt l -> Alt l -> Alt l)
    -> (Alt l -> Alt l -> Alt l)
    -> Ord (Alt l)
    Alt l -> Alt l -> Bool
    Alt l -> Alt l -> Ordering
    Alt l -> Alt l -> Alt l
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l. Ord l => Eq (Alt l)
    forall l. Ord l => Alt l -> Alt l -> Bool
    forall l. Ord l => Alt l -> Alt l -> Ordering
    forall l. Ord l => Alt l -> Alt l -> Alt l
    $ccompare :: forall l. Ord l => Alt l -> Alt l -> Ordering
    compare :: Alt l -> Alt l -> Ordering
    $c< :: forall l. Ord l => Alt l -> Alt l -> Bool
    < :: Alt l -> Alt l -> Bool
    $c<= :: forall l. Ord l => Alt l -> Alt l -> Bool
    <= :: Alt l -> Alt l -> Bool
    $c> :: forall l. Ord l => Alt l -> Alt l -> Bool
    > :: Alt l -> Alt l -> Bool
    $c>= :: forall l. Ord l => Alt l -> Alt l -> Bool
    >= :: Alt l -> Alt l -> Bool
    $cmax :: forall l. Ord l => Alt l -> Alt l -> Alt l
    max :: Alt l -> Alt l -> Alt l
    $cmin :: forall l. Ord l => Alt l -> Alt l -> Alt l
    min :: Alt l -> Alt l -> Alt l
    Ord,Int -> Alt l -> ShowS
    [Alt l] -> ShowS
    Alt l -> String
    (Int -> Alt l -> ShowS)
    -> (Alt l -> String) -> ([Alt l] -> ShowS) -> Show (Alt l)
    forall l. Show l => Int -> Alt l -> ShowS
    forall l. Show l => [Alt l] -> ShowS
    forall l. Show l => Alt l -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall l. Show l => Int -> Alt l -> ShowS
    showsPrec :: Int -> Alt l -> ShowS
    $cshow :: forall l. Show l => Alt l -> String
    show :: Alt l -> String
    $cshowList :: forall l. Show l => [Alt l] -> ShowS
    showList :: [Alt l] -> ShowS
    Show,Typeable,Typeable (Alt l)
    Typeable (Alt l) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Alt l -> c (Alt l))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Alt l))
    -> (Alt l -> Constr)
    -> (Alt l -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Alt l)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l)))
    -> ((forall b. Data b => b -> b) -> Alt l -> Alt l)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Alt l -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Alt l -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Alt l -> m (Alt l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Alt l -> m (Alt l))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Alt l -> m (Alt l))
    -> Data (Alt l)
    Alt l -> Constr
    Alt l -> DataType
    (forall b. Data b => b -> b) -> Alt l -> Alt l
    forall l. Data l => Typeable (Alt l)
    forall l. Data l => Alt l -> Constr
    forall l. Data l => Alt l -> DataType
    forall l. Data l => (forall b. Data b => b -> b) -> Alt l -> Alt l
    forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Alt l -> u
    forall l u. Data l => (forall d. Data d => d -> u) -> Alt l -> [u]
    forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
    forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
    forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Alt l)
    forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Alt l -> c (Alt l)
    forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Alt l))
    forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Alt l -> u
    forall u. (forall d. Data d => d -> u) -> Alt l -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Alt l)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Alt l -> c (Alt l)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Alt l))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l))
    $cgfoldl :: forall l (c :: * -> *).
    Data l =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Alt l -> c (Alt l)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Alt l -> c (Alt l)
    $cgunfold :: forall l (c :: * -> *).
    Data l =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Alt l)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Alt l)
    $ctoConstr :: forall l. Data l => Alt l -> Constr
    toConstr :: Alt l -> Constr
    $cdataTypeOf :: forall l. Data l => Alt l -> DataType
    dataTypeOf :: Alt l -> DataType
    $cdataCast1 :: forall l (t :: * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Alt l))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Alt l))
    $cdataCast2 :: forall l (t :: * -> * -> *) (c :: * -> *).
    (Data l, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l))
    $cgmapT :: forall l. Data l => (forall b. Data b => b -> b) -> Alt l -> Alt l
    gmapT :: (forall b. Data b => b -> b) -> Alt l -> Alt l
    $cgmapQl :: forall l r r'.
    Data l =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
    $cgmapQr :: forall l r r'.
    Data l =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r
    $cgmapQ :: forall l u. Data l => (forall d. Data d => d -> u) -> Alt l -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Alt l -> [u]
    $cgmapQi :: forall l u.
    Data l =>
    Int -> (forall d. Data d => d -> u) -> Alt l -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Alt l -> u
    $cgmapM :: forall l (m :: * -> *).
    (Data l, Monad m) =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    $cgmapMp :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    $cgmapMo :: forall l (m :: * -> *).
    (Data l, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alt l -> m (Alt l)
    Data,(forall m. Monoid m => Alt m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Alt a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Alt a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Alt a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Alt a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Alt a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Alt a -> b)
    -> (forall a. (a -> a -> a) -> Alt a -> a)
    -> (forall a. (a -> a -> a) -> Alt a -> a)
    -> (forall a. Alt a -> [a])
    -> (forall a. Alt a -> Bool)
    -> (forall a. Alt a -> Int)
    -> (forall a. Eq a => a -> Alt a -> Bool)
    -> (forall a. Ord a => Alt a -> a)
    -> (forall a. Ord a => Alt a -> a)
    -> (forall a. Num a => Alt a -> a)
    -> (forall a. Num a => Alt a -> a)
    -> Foldable Alt
    forall a. Eq a => a -> Alt a -> Bool
    forall a. Num a => Alt a -> a
    forall a. Ord a => Alt a -> a
    forall m. Monoid m => Alt m -> m
    forall a. Alt a -> Bool
    forall a. Alt a -> Int
    forall a. Alt a -> [a]
    forall a. (a -> a -> a) -> Alt a -> a
    forall m a. Monoid m => (a -> m) -> Alt a -> m
    forall b a. (b -> a -> b) -> b -> Alt a -> b
    forall a b. (a -> b -> b) -> b -> Alt a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Alt m -> m
    fold :: forall m. Monoid m => Alt m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Alt a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Alt a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Alt a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Alt a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Alt a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Alt a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Alt a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Alt a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Alt a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Alt a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Alt a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Alt a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Alt a -> a
    foldr1 :: forall a. (a -> a -> a) -> Alt a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Alt a -> a
    foldl1 :: forall a. (a -> a -> a) -> Alt a -> a
    $ctoList :: forall a. Alt a -> [a]
    toList :: forall a. Alt a -> [a]
    $cnull :: forall a. Alt a -> Bool
    null :: forall a. Alt a -> Bool
    $clength :: forall a. Alt a -> Int
    length :: forall a. Alt a -> Int
    $celem :: forall a. Eq a => a -> Alt a -> Bool
    elem :: forall a. Eq a => a -> Alt a -> Bool
    $cmaximum :: forall a. Ord a => Alt a -> a
    maximum :: forall a. Ord a => Alt a -> a
    $cminimum :: forall a. Ord a => Alt a -> a
    minimum :: forall a. Ord a => Alt a -> a
    $csum :: forall a. Num a => Alt a -> a
    sum :: forall a. Num a => Alt a -> a
    $cproduct :: forall a. Num a => Alt a -> a
    product :: forall a. Num a => Alt a -> a
    Foldable,Functor Alt
    Foldable Alt
    (Functor Alt, Foldable Alt) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Alt a -> f (Alt b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Alt (f a) -> f (Alt a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Alt a -> m (Alt b))
    -> (forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a))
    -> Traversable Alt
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a)
    forall (f :: * -> *) a. Applicative f => Alt (f a) -> f (Alt a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Alt a -> m (Alt b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Alt a -> f (Alt b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Alt a -> f (Alt b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Alt a -> f (Alt b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Alt (f a) -> f (Alt a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Alt (f a) -> f (Alt a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Alt a -> m (Alt b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Alt a -> m (Alt b)
    $csequence :: forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a)
    sequence :: forall (m :: * -> *) a. Monad m => Alt (m a) -> m (Alt a)
    Traversable,(forall a b. (a -> b) -> Alt a -> Alt b)
    -> (forall a b. a -> Alt b -> Alt a) -> Functor Alt
    forall a b. a -> Alt b -> Alt a
    forall a b. (a -> b) -> Alt a -> Alt b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Alt a -> Alt b
    fmap :: forall a b. (a -> b) -> Alt a -> Alt b
    $c<$ :: forall a b. a -> Alt b -> Alt a
    <$ :: forall a b. a -> Alt b -> Alt a
    Functor,(forall x. Alt l -> Rep (Alt l) x)
    -> (forall x. Rep (Alt l) x -> Alt l) -> Generic (Alt l)
    forall x. Rep (Alt l) x -> Alt l
    forall x. Alt l -> Rep (Alt l) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall l x. Rep (Alt l) x -> Alt l
    forall l x. Alt l -> Rep (Alt l) x
    $cfrom :: forall l x. Alt l -> Rep (Alt l) x
    from :: forall x. Alt l -> Rep (Alt l) x
    $cto :: forall l x. Rep (Alt l) x -> Alt l
    to :: forall x. Rep (Alt l) x -> Alt l
    Generic)

    -----------------------------------------------------------------------------
    -- Builtin names.

    prelude_mod, main_mod :: l -> ModuleName l
    prelude_mod :: forall l. l -> ModuleName l
    prelude_mod l
    l = l -> String -> ModuleName l
    forall l. l -> String -> ModuleName l
    ModuleName l
    l String
    "Prelude"
    main_mod :: forall l. l -> ModuleName l
    main_mod    l
    l = l -> String -> ModuleName l
    forall l. l -> String -> ModuleName l
    ModuleName l
    l String
    "Main"

    main_name :: l -> Name l
    main_name :: forall l. l -> Name l
    main_name l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "main"

    unit_con_name :: l -> QName l
    unit_con_name :: forall l. l -> QName l
    unit_con_name l
    l = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> SpecialCon l
    forall l. l -> SpecialCon l
    UnitCon l
    l)

    tuple_con_name :: l -> Boxed -> Int -> QName l
    tuple_con_name :: forall l. l -> Boxed -> Int -> QName l
    tuple_con_name l
    l Boxed
    b Int
    i = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> Boxed -> Int -> SpecialCon l
    forall l. l -> Boxed -> Int -> SpecialCon l
    TupleCon l
    l Boxed
    b (Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1))

    list_con_name :: l -> QName l
    list_con_name :: forall l. l -> QName l
    list_con_name l
    l = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> SpecialCon l
    forall l. l -> SpecialCon l
    ListCon l
    l)

    list_cons_name :: l -> QName l
    list_cons_name :: forall l. l -> QName l
    list_cons_name l
    l = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> SpecialCon l
    forall l. l -> SpecialCon l
    Cons l
    l)

    unboxed_singleton_con_name :: l -> QName l
    unboxed_singleton_con_name :: forall l. l -> QName l
    unboxed_singleton_con_name l
    l = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> SpecialCon l
    forall l. l -> SpecialCon l
    UnboxedSingleCon l
    l)

    unit_con :: l -> Exp l
    unit_con :: forall l. l -> Exp l
    unit_con l
    l = l -> QName l -> Exp l
    forall l. l -> QName l -> Exp l
    Con l
    l (QName l -> Exp l) -> QName l -> Exp l
    forall a b. (a -> b) -> a -> b
    $ l -> QName l
    forall l. l -> QName l
    unit_con_name l
    l

    tuple_con :: l -> Boxed -> Int -> Exp l
    tuple_con :: forall l. l -> Boxed -> Int -> Exp l
    tuple_con l
    l Boxed
    b Int
    i = l -> QName l -> Exp l
    forall l. l -> QName l -> Exp l
    Con l
    l (l -> Boxed -> Int -> QName l
    forall l. l -> Boxed -> Int -> QName l
    tuple_con_name l
    l Boxed
    b Int
    i)

    unboxed_singleton_con :: l -> Exp l
    unboxed_singleton_con :: forall l. l -> Exp l
    unboxed_singleton_con l
    l = l -> QName l -> Exp l
    forall l. l -> QName l -> Exp l
    Con l
    l (l -> QName l
    forall l. l -> QName l
    unboxed_singleton_con_name l
    l)

    as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name :: l -> Name l
    as_name :: forall l. l -> Name l
    as_name        l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident  l
    l String
    "as"
    qualified_name :: forall l. l -> Name l
    qualified_name l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident  l
    l String
    "qualified"
    hiding_name :: forall l. l -> Name l
    hiding_name    l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident  l
    l String
    "hiding"
    minus_name :: forall l. l -> Name l
    minus_name     l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Symbol l
    l String
    "-"
    bang_name :: forall l. l -> Name l
    bang_name      l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Symbol l
    l String
    "!"
    dot_name :: forall l. l -> Name l
    dot_name       l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Symbol l
    l String
    "."
    star_name :: forall l. l -> Name l
    star_name      l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Symbol l
    l String
    "*"

    hole_name :: l -> QName l
    hole_name :: forall l. l -> QName l
    hole_name      l
    l = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> SpecialCon l
    forall l. l -> SpecialCon l
    ExprHole l
    l)

    export_name, safe_name, unsafe_name, interruptible_name, threadsafe_name,
      stdcall_name, ccall_name, cplusplus_name, dotnet_name,
      jvm_name, js_name, javascript_name, capi_name, forall_name,
      family_name, role_name, stock_name, anyclass_name, via_name :: l -> Name l
    export_name :: forall l. l -> Name l
    export_name     l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "export"
    safe_name :: forall l. l -> Name l
    safe_name       l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "safe"
    unsafe_name :: forall l. l -> Name l
    unsafe_name     l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "unsafe"
    interruptible_name :: forall l. l -> Name l
    interruptible_name l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "interruptible"
    threadsafe_name :: forall l. l -> Name l
    threadsafe_name l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "threadsafe"
    stdcall_name :: forall l. l -> Name l
    stdcall_name    l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "stdcall"
    ccall_name :: forall l. l -> Name l
    ccall_name      l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "ccall"
    cplusplus_name :: forall l. l -> Name l
    cplusplus_name  l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "cplusplus"
    dotnet_name :: forall l. l -> Name l
    dotnet_name     l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "dotnet"
    jvm_name :: forall l. l -> Name l
    jvm_name        l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "jvm"
    js_name :: forall l. l -> Name l
    js_name         l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "js"
    javascript_name :: forall l. l -> Name l
    javascript_name l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "javascript"
    capi_name :: forall l. l -> Name l
    capi_name       l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "capi"
    forall_name :: forall l. l -> Name l
    forall_name     l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "forall"
    family_name :: forall l. l -> Name l
    family_name     l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "family"
    role_name :: forall l. l -> Name l
    role_name       l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "role"
    stock_name :: forall l. l -> Name l
    stock_name      l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "stock"
    anyclass_name :: forall l. l -> Name l
    anyclass_name   l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "anyclass"
    via_name :: forall l. l -> Name l
    via_name        l
    l = l -> String -> Name l
    forall l. l -> String -> Name l
    Ident l
    l String
    "via"

    unit_tycon_name, fun_tycon_name, list_tycon_name, unboxed_singleton_tycon_name :: l -> QName l
    unit_tycon_name :: forall l. l -> QName l
    unit_tycon_name l
    l = l -> QName l
    forall l. l -> QName l
    unit_con_name l
    l
    fun_tycon_name :: forall l. l -> QName l
    fun_tycon_name  l
    l = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> SpecialCon l
    forall l. l -> SpecialCon l
    FunCon l
    l)
    list_tycon_name :: forall l. l -> QName l
    list_tycon_name l
    l = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> SpecialCon l
    forall l. l -> SpecialCon l
    ListCon l
    l)
    unboxed_singleton_tycon_name :: forall l. l -> QName l
    unboxed_singleton_tycon_name l
    l = l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special l
    l (l -> SpecialCon l
    forall l. l -> SpecialCon l
    UnboxedSingleCon l
    l)

    tuple_tycon_name :: l -> Boxed -> Int -> QName l
    tuple_tycon_name :: forall l. l -> Boxed -> Int -> QName l
    tuple_tycon_name l
    l Boxed
    b Int
    i = l -> Boxed -> Int -> QName l
    forall l. l -> Boxed -> Int -> QName l
    tuple_con_name l
    l Boxed
    b Int
    i

    unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: l -> Type l
    unit_tycon :: forall l. l -> Type l
    unit_tycon l
    l = l -> QName l -> Type l
    forall l. l -> QName l -> Type l
    TyCon l
    l (QName l -> Type l) -> QName l -> Type l
    forall a b. (a -> b) -> a -> b
    $ l -> QName l
    forall l. l -> QName l
    unit_tycon_name l
    l
    fun_tycon :: forall l. l -> Type l
    fun_tycon  l
    l = l -> QName l -> Type l
    forall l. l -> QName l -> Type l
    TyCon l
    l (QName l -> Type l) -> QName l -> Type l
    forall a b. (a -> b) -> a -> b
    $ l -> QName l
    forall l. l -> QName l
    fun_tycon_name  l
    l
    list_tycon :: forall l. l -> Type l
    list_tycon l
    l = l -> QName l -> Type l
    forall l. l -> QName l -> Type l
    TyCon l
    l (QName l -> Type l) -> QName l -> Type l
    forall a b. (a -> b) -> a -> b
    $ l -> QName l
    forall l. l -> QName l
    list_tycon_name l
    l
    unboxed_singleton_tycon :: forall l. l -> Type l
    unboxed_singleton_tycon l
    l = l -> QName l -> Type l
    forall l. l -> QName l -> Type l
    TyCon l
    l (QName l -> Type l) -> QName l -> Type l
    forall a b. (a -> b) -> a -> b
    $ l -> QName l
    forall l. l -> QName l
    unboxed_singleton_tycon_name l
    l

    tuple_tycon :: l -> Boxed -> Int -> Type l
    tuple_tycon :: forall l. l -> Boxed -> Int -> Type l
    tuple_tycon l
    l Boxed
    b Int
    i = l -> QName l -> Type l
    forall l. l -> QName l -> Type l
    TyCon l
    l (l -> Boxed -> Int -> QName l
    forall l. l -> Boxed -> Int -> QName l
    tuple_tycon_name l
    l Boxed
    b Int
    i)

    -----------------------------------------------------------------------------
    -- AST traversal, boiler-plate style

    -- | Test if two AST elements are equal modulo annotations.
    (=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool
    a l1
    a =~= :: forall (a :: * -> *) l1 l2.
    (Annotated a, Eq (a ())) =>
    a l1 -> a l2 -> Bool
    =~= a l2
    b = (l1 -> ()) -> a l1 -> a ()
    forall a b. (a -> b) -> a a -> a b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (() -> l1 -> ()
    forall a b. a -> b -> a
    const ()) a l1
    a a () -> a () -> Bool
    forall a. Eq a => a -> a -> Bool
    == (l2 -> ()) -> a l2 -> a ()
    forall a b. (a -> b) -> a a -> a b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (() -> l2 -> ()
    forall a b. a -> b -> a
    const ()) a l2
    b

    -----------------------------------------------------------------------------
    -- Reading annotations

    -- | AST nodes are annotated, and this class allows manipulation of the annotations.
    class Functor ast => Annotated ast where
        -- | Retrieve the annotation of an AST node.
        ann :: ast l -> l
        -- | Change the annotation of an AST node. Note that only the annotation of
        --   the node itself is affected, and not the annotations of any child nodes.
        --   if all nodes in the AST tree are to be affected, use 'fmap'.
        amap :: (l -> l) -> ast l -> ast l

    instance Annotated ModuleName where
        ann :: forall l. ModuleName l -> l
    ann (ModuleName l
    l String
    _) = l
    l
        amap :: forall l. (l -> l) -> ModuleName l -> ModuleName l
    amap l -> l
    f (ModuleName l
    l String
    n) = l -> String -> ModuleName l
    forall l. l -> String -> ModuleName l
    ModuleName (l -> l
    f l
    l) String
    n

    instance Annotated SpecialCon where
        ann :: forall l. SpecialCon l -> l
    ann SpecialCon l
    sc = case SpecialCon l
    sc of
            UnitCon l
    l   -> l
    l
            ListCon l
    l   -> l
    l
            FunCon  l
    l   -> l
    l
            TupleCon l
    l Boxed
    _ Int
    _  -> l
    l
            Cons l
    l      -> l
    l
            UnboxedSingleCon l
    l  -> l
    l
            ExprHole l
    l  -> l
    l
        amap :: forall l. (l -> l) -> SpecialCon l -> SpecialCon l
    amap = (l -> l) -> SpecialCon l -> SpecialCon l
    forall a b. (a -> b) -> SpecialCon a -> SpecialCon b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated QName where
        ann :: forall l. QName l -> l
    ann QName l
    qn = case QName l
    qn of
            Qual    l
    l ModuleName l
    _ Name l
    _  -> l
    l
            UnQual  l
    l   Name l
    _  -> l
    l
            Special l
    l SpecialCon l
    _    -> l
    l
        amap :: forall l. (l -> l) -> QName l -> QName l
    amap l -> l
    f QName l
    qn = case QName l
    qn of
            Qual    l
    l ModuleName l
    mn Name l
    n  -> l -> ModuleName l -> Name l -> QName l
    forall l. l -> ModuleName l -> Name l -> QName l
    Qual    (l -> l
    f l
    l) ModuleName l
    mn Name l
    n
            UnQual  l
    l    Name l
    n  -> l -> Name l -> QName l
    forall l. l -> Name l -> QName l
    UnQual  (l -> l
    f l
    l)    Name l
    n
            Special l
    l SpecialCon l
    sc    -> l -> SpecialCon l -> QName l
    forall l. l -> SpecialCon l -> QName l
    Special (l -> l
    f l
    l) SpecialCon l
    sc

    instance Annotated Name where
        ann :: forall l. Name l -> l
    ann (Ident  l
    l String
    _) = l
    l
        ann (Symbol l
    l String
    _) = l
    l
        amap :: forall l. (l -> l) -> Name l -> Name l
    amap = (l -> l) -> Name l -> Name l
    forall a b. (a -> b) -> Name a -> Name b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated IPName where
        ann :: forall l. IPName l -> l
    ann (IPDup l
    l String
    _) = l
    l
        ann (IPLin l
    l String
    _) = l
    l
        amap :: forall l. (l -> l) -> IPName l -> IPName l
    amap = (l -> l) -> IPName l -> IPName l
    forall a b. (a -> b) -> IPName a -> IPName b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated QOp where
        ann :: forall l. QOp l -> l
    ann (QVarOp l
    l QName l
    _) = l
    l
        ann (QConOp l
    l QName l
    _) = l
    l
        amap :: forall l. (l -> l) -> QOp l -> QOp l
    amap l -> l
    f (QVarOp l
    l QName l
    qn) = l -> QName l -> QOp l
    forall l. l -> QName l -> QOp l
    QVarOp (l -> l
    f l
    l) QName l
    qn
        amap l -> l
    f (QConOp l
    l QName l
    qn) = l -> QName l -> QOp l
    forall l. l -> QName l -> QOp l
    QConOp (l -> l
    f l
    l) QName l
    qn

    instance Annotated Op where
        ann :: forall l. Op l -> l
    ann (VarOp l
    l Name l
    _) = l
    l
        ann (ConOp l
    l Name l
    _) = l
    l
        amap :: forall l. (l -> l) -> Op l -> Op l
    amap l -> l
    f (VarOp l
    l Name l
    n) = l -> Name l -> Op l
    forall l. l -> Name l -> Op l
    VarOp (l -> l
    f l
    l) Name l
    n
        amap l -> l
    f (ConOp l
    l Name l
    n) = l -> Name l -> Op l
    forall l. l -> Name l -> Op l
    ConOp (l -> l
    f l
    l) Name l
    n

    instance Annotated CName where
        ann :: forall l. CName l -> l
    ann (VarName l
    l Name l
    _) = l
    l
        ann (ConName l
    l Name l
    _) = l
    l
        amap :: forall l. (l -> l) -> CName l -> CName l
    amap l -> l
    f (VarName l
    l Name l
    n) = l -> Name l -> CName l
    forall l. l -> Name l -> CName l
    VarName (l -> l
    f l
    l) Name l
    n
        amap l -> l
    f (ConName l
    l Name l
    n) = l -> Name l -> CName l
    forall l. l -> Name l -> CName l
    ConName (l -> l
    f l
    l) Name l
    n

    instance Annotated Module where
        ann :: forall l. Module l -> l
    ann (Module l
    l Maybe (ModuleHead l)
    _ [ModulePragma l]
    _ [ImportDecl l]
    _ [Decl l]
    _)            = l
    l
        ann (XmlPage l
    l ModuleName l
    _ [ModulePragma l]
    _ XName l
    _ [XAttr l]
    _ Maybe (Exp l)
    _ [Exp l]
    _)       = l
    l
        ann (XmlHybrid l
    l Maybe (ModuleHead l)
    _ [ModulePragma l]
    _ [ImportDecl l]
    _ [Decl l]
    _ XName l
    _ [XAttr l]
    _ Maybe (Exp l)
    _ [Exp l]
    _) = l
    l

        amap :: forall l. (l -> l) -> Module l -> Module l
    amap l -> l
    f (Module l
    l Maybe (ModuleHead l)
    mmh [ModulePragma l]
    ops [ImportDecl l]
    iss [Decl l]
    dcls) =
            l
    -> Maybe (ModuleHead l)
    -> [ModulePragma l]
    -> [ImportDecl l]
    -> [Decl l]
    -> Module l
    forall l.
    l
    -> Maybe (ModuleHead l)
    -> [ModulePragma l]
    -> [ImportDecl l]
    -> [Decl l]
    -> Module l
    Module (l -> l
    f l
    l) Maybe (ModuleHead l)
    mmh [ModulePragma l]
    ops [ImportDecl l]
    iss [Decl l]
    dcls
        amap l -> l
    f (XmlPage l
    l ModuleName l
    mn [ModulePragma l]
    os XName l
    xn [XAttr l]
    xas Maybe (Exp l)
    me [Exp l]
    es) =
            l
    -> ModuleName l
    -> [ModulePragma l]
    -> XName l
    -> [XAttr l]
    -> Maybe (Exp l)
    -> [Exp l]
    -> Module l
    forall l.
    l
    -> ModuleName l
    -> [ModulePragma l]
    -> XName l
    -> [XAttr l]
    -> Maybe (Exp l)
    -> [Exp l]
    -> Module l
    XmlPage (l -> l
    f l
    l) ModuleName l
    mn [ModulePragma l]
    os XName l
    xn [XAttr l]
    xas Maybe (Exp l)
    me [Exp l]
    es
        amap l -> l
    f (XmlHybrid l
    l Maybe (ModuleHead l)
    mmh [ModulePragma l]
    ops [ImportDecl l]
    iss [Decl l]
    dcls XName l
    xn [XAttr l]
    xas Maybe (Exp l)
    me [Exp l]
    es) =
            l
    -> Maybe (ModuleHead l)
    -> [ModulePragma l]
    -> [ImportDecl l]
    -> [Decl l]
    -> XName l
    -> [XAttr l]
    -> Maybe (Exp l)
    -> [Exp l]
    -> Module l
    forall l.
    l
    -> Maybe (ModuleHead l)
    -> [ModulePragma l]
    -> [ImportDecl l]
    -> [Decl l]
    -> XName l
    -> [XAttr l]
    -> Maybe (Exp l)
    -> [Exp l]
    -> Module l
    XmlHybrid (l -> l
    f l
    l) Maybe (ModuleHead l)
    mmh [ModulePragma l]
    ops [ImportDecl l]
    iss [Decl l]
    dcls XName l
    xn [XAttr l]
    xas Maybe (Exp l)
    me [Exp l]
    es

    instance Annotated ModuleHead where
        ann :: forall l. ModuleHead l -> l
    ann (ModuleHead l
    l ModuleName l
    _ Maybe (WarningText l)
    _ Maybe (ExportSpecList l)
    _)         = l
    l
        amap :: forall l. (l -> l) -> ModuleHead l -> ModuleHead l
    amap l -> l
    f (ModuleHead l
    l ModuleName l
    n Maybe (WarningText l)
    mwt Maybe (ExportSpecList l)
    mesl) = l
    -> ModuleName l
    -> Maybe (WarningText l)
    -> Maybe (ExportSpecList l)
    -> ModuleHead l
    forall l.
    l
    -> ModuleName l
    -> Maybe (WarningText l)
    -> Maybe (ExportSpecList l)
    -> ModuleHead l
    ModuleHead (l -> l
    f l
    l) ModuleName l
    n Maybe (WarningText l)
    mwt Maybe (ExportSpecList l)
    mesl

    instance Annotated ExportSpecList where
        ann :: forall l. ExportSpecList l -> l
    ann (ExportSpecList l
    l [ExportSpec l]
    _)      = l
    l
        amap :: forall l. (l -> l) -> ExportSpecList l -> ExportSpecList l
    amap l -> l
    f (ExportSpecList l
    l [ExportSpec l]
    ess) = l -> [ExportSpec l] -> ExportSpecList l
    forall l. l -> [ExportSpec l] -> ExportSpecList l
    ExportSpecList (l -> l
    f l
    l) [ExportSpec l]
    ess

    instance Annotated ExportSpec where
        ann :: forall l. ExportSpec l -> l
    ann ExportSpec l
    es = case ExportSpec l
    es of
            EVar l
    l QName l
    _            -> l
    l
            EAbs l
    l Namespace l
    _ QName l
    _          -> l
    l
            EThingWith l
    l EWildcard l
    _ QName l
    _ [CName l]
    _    -> l
    l
            EModuleContents l
    l ModuleName l
    _ -> l
    l
        amap :: forall l. (l -> l) -> ExportSpec l -> ExportSpec l
    amap l -> l
    f ExportSpec l
    es = case ExportSpec l
    es of
            EVar l
    l QName l
    qn     -> l -> QName l -> ExportSpec l
    forall l. l -> QName l -> ExportSpec l
    EVar (l -> l
    f l
    l) QName l
    qn
            EAbs l
    l Namespace l
    n QName l
    qn       -> l -> Namespace l -> QName l -> ExportSpec l
    forall l. l -> Namespace l -> QName l -> ExportSpec l
    EAbs (l -> l
    f l
    l) Namespace l
    n QName l
    qn
            EThingWith l
    l EWildcard l
    wc QName l
    qn [CName l]
    cns -> l -> EWildcard l -> QName l -> [CName l] -> ExportSpec l
    forall l. l -> EWildcard l -> QName l -> [CName l] -> ExportSpec l
    EThingWith (l -> l
    f l
    l) EWildcard l
    wc QName l
    qn [CName l]
    cns
            EModuleContents l
    l ModuleName l
    mn    -> l -> ModuleName l -> ExportSpec l
    forall l. l -> ModuleName l -> ExportSpec l
    EModuleContents (l -> l
    f l
    l) ModuleName l
    mn

    instance Annotated EWildcard where
      ann :: forall l. EWildcard l -> l
    ann EWildcard l
    ewc = case EWildcard l
    ewc of
          NoWildcard l
    l  -> l
    l
          EWildcard l
    l Int
    _ -> l
    l
      amap :: forall l. (l -> l) -> EWildcard l -> EWildcard l
    amap l -> l
    f EWildcard l
    ewc = case EWildcard l
    ewc of
          NoWildcard l
    l  -> l -> EWildcard l
    forall l. l -> EWildcard l
    NoWildcard (l -> l
    f l
    l)
          EWildcard l
    l Int
    n -> l -> Int -> EWildcard l
    forall l. l -> Int -> EWildcard l
    EWildcard (l -> l
    f l
    l) Int
    n

    instance Annotated Namespace where
        ann :: forall l. Namespace l -> l
    ann Namespace l
    es = case Namespace l
    es of
            NoNamespace l
    l   -> l
    l
            TypeNamespace l
    l -> l
    l
            PatternNamespace l
    l -> l
    l
        amap :: forall l. (l -> l) -> Namespace l -> Namespace l
    amap l -> l
    f Namespace l
    es = case Namespace l
    es of
            NoNamespace l
    l   -> l -> Namespace l
    forall l. l -> Namespace l
    NoNamespace (l -> l
    f l
    l)
            TypeNamespace l
    l -> l -> Namespace l
    forall l. l -> Namespace l
    TypeNamespace (l -> l
    f l
    l)
            PatternNamespace l
    l -> l -> Namespace l
    forall l. l -> Namespace l
    PatternNamespace (l -> l
    f l
    l)

    instance Annotated ImportDecl where
        ann :: forall l. ImportDecl l -> l
    ann (ImportDecl l
    l ModuleName l
    _ Bool
    _ Bool
    _ Bool
    _ Maybe String
    _ Maybe (ModuleName l)
    _ Maybe (ImportSpecList l)
    _) = l
    l
        amap :: forall l. (l -> l) -> ImportDecl l -> ImportDecl l
    amap l -> l
    f (ImportDecl l
    l ModuleName l
    mn Bool
    qual Bool
    src Bool
    safe Maybe String
    pkg Maybe (ModuleName l)
    mmn Maybe (ImportSpecList l)
    mis) =
            l
    -> ModuleName l
    -> Bool
    -> Bool
    -> Bool
    -> Maybe String
    -> Maybe (ModuleName l)
    -> Maybe (ImportSpecList l)
    -> ImportDecl l
    forall l.
    l
    -> ModuleName l
    -> Bool
    -> Bool
    -> Bool
    -> Maybe String
    -> Maybe (ModuleName l)
    -> Maybe (ImportSpecList l)
    -> ImportDecl l
    ImportDecl (l -> l
    f l
    l) ModuleName l
    mn Bool
    qual Bool
    src Bool
    safe Maybe String
    pkg Maybe (ModuleName l)
    mmn Maybe (ImportSpecList l)
    mis

    instance Annotated ImportSpecList where
        ann :: forall l. ImportSpecList l -> l
    ann (ImportSpecList l
    l Bool
    _ [ImportSpec l]
    _)      = l
    l
        amap :: forall l. (l -> l) -> ImportSpecList l -> ImportSpecList l
    amap l -> l
    f (ImportSpecList l
    l Bool
    b [ImportSpec l]
    iss) = l -> Bool -> [ImportSpec l] -> ImportSpecList l
    forall l. l -> Bool -> [ImportSpec l] -> ImportSpecList l
    ImportSpecList (l -> l
    f l
    l) Bool
    b [ImportSpec l]
    iss

    instance Annotated ImportSpec where
        ann :: forall l. ImportSpec l -> l
    ann ImportSpec l
    is = case ImportSpec l
    is of
            IVar l
    l Name l
    _         -> l
    l
            IAbs l
    l Namespace l
    _ Name l
    _       -> l
    l
            IThingAll l
    l Name l
    _    -> l
    l
            IThingWith l
    l Name l
    _ [CName l]
    _ -> l
    l
        amap :: forall l. (l -> l) -> ImportSpec l -> ImportSpec l
    amap l -> l
    f ImportSpec l
    is = case ImportSpec l
    is of
            IVar l
    l Name l
    n        -> l -> Name l -> ImportSpec l
    forall l. l -> Name l -> ImportSpec l
    IVar (l -> l
    f l
    l) Name l
    n
            IAbs l
    l Namespace l
    ns Name l
    n     -> l -> Namespace l -> Name l -> ImportSpec l
    forall l. l -> Namespace l -> Name l -> ImportSpec l
    IAbs (l -> l
    f l
    l) Namespace l
    ns Name l
    n
            IThingAll l
    l Name l
    n   -> l -> Name l -> ImportSpec l
    forall l. l -> Name l -> ImportSpec l
    IThingAll (l -> l
    f l
    l) Name l
    n
            IThingWith l
    l Name l
    n [CName l]
    cns  -> l -> Name l -> [CName l] -> ImportSpec l
    forall l. l -> Name l -> [CName l] -> ImportSpec l
    IThingWith (l -> l
    f l
    l) Name l
    n [CName l]
    cns

    instance Annotated Assoc where
        ann :: forall l. Assoc l -> l
    ann (AssocNone  l
    l) = l
    l
        ann (AssocLeft  l
    l) = l
    l
        ann (AssocRight l
    l) = l
    l
        amap :: forall l. (l -> l) -> Assoc l -> Assoc l
    amap = (l -> l) -> Assoc l -> Assoc l
    forall a b. (a -> b) -> Assoc a -> Assoc b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated Deriving where
        ann :: forall l. Deriving l -> l
    ann (Deriving l
    l Maybe (DerivStrategy l)
    _ [InstRule l]
    _)        = l
    l
        amap :: forall l. (l -> l) -> Deriving l -> Deriving l
    amap l -> l
    f (Deriving l
    l Maybe (DerivStrategy l)
    mds [InstRule l]
    ihs) = l -> Maybe (DerivStrategy l) -> [InstRule l] -> Deriving l
    forall l.
    l -> Maybe (DerivStrategy l) -> [InstRule l] -> Deriving l
    Deriving (l -> l
    f l
    l) Maybe (DerivStrategy l)
    mds [InstRule l]
    ihs

    instance Annotated DerivStrategy where
        ann :: forall l. DerivStrategy l -> l
    ann (DerivStock l
    l)    = l
    l
        ann (DerivAnyclass l
    l) = l
    l
        ann (DerivNewtype l
    l)  = l
    l
        ann (DerivVia l
    l Type l
    _)    = l
    l

        amap :: forall l. (l -> l) -> DerivStrategy l -> DerivStrategy l
    amap l -> l
    f (DerivStock l
    l)    = l -> DerivStrategy l
    forall l. l -> DerivStrategy l
    DerivStock (l -> l
    f l
    l)
        amap l -> l
    f (DerivAnyclass l
    l) = l -> DerivStrategy l
    forall l. l -> DerivStrategy l
    DerivAnyclass (l -> l
    f l
    l)
        amap l -> l
    f (DerivNewtype l
    l)  = l -> DerivStrategy l
    forall l. l -> DerivStrategy l
    DerivNewtype (l -> l
    f l
    l)
        amap l -> l
    f (DerivVia l
    l Type l
    t)    = l -> Type l -> DerivStrategy l
    forall l. l -> Type l -> DerivStrategy l
    DerivVia (l -> l
    f l
    l) Type l
    t

    instance Annotated TypeEqn where
        ann :: forall l. TypeEqn l -> l
    ann (TypeEqn l
    l Type l
    _ Type l
    _) = l
    l
        amap :: forall l. (l -> l) -> TypeEqn l -> TypeEqn l
    amap l -> l
    f (TypeEqn l
    l Type l
    a Type l
    b) = l -> Type l -> Type l -> TypeEqn l
    forall l. l -> Type l -> Type l -> TypeEqn l
    TypeEqn (l -> l
    f l
    l) Type l
    a Type l
    b

    instance Annotated InjectivityInfo where
      ann :: forall l. InjectivityInfo l -> l
    ann (InjectivityInfo l
    l Name l
    _ [Name l]
    _) = l
    l
      amap :: forall l. (l -> l) -> InjectivityInfo l -> InjectivityInfo l
    amap l -> l
    f (InjectivityInfo l
    l Name l
    to [Name l]
    from) = l -> Name l -> [Name l] -> InjectivityInfo l
    forall l. l -> Name l -> [Name l] -> InjectivityInfo l
    InjectivityInfo (l -> l
    f l
    l) Name l
    to [Name l]
    from

    instance Annotated ResultSig where
      ann :: forall l. ResultSig l -> l
    ann (KindSig l
    l Kind l
    _) = l
    l
      ann (TyVarSig l
    l TyVarBind l
    _) = l
    l

      amap :: forall l. (l -> l) -> ResultSig l -> ResultSig l
    amap l -> l
    f (KindSig l
    l Kind l
    k) = l -> Kind l -> ResultSig l
    forall l. l -> Kind l -> ResultSig l
    KindSig (l -> l
    f l
    l) Kind l
    k
      amap l -> l
    f (TyVarSig l
    l TyVarBind l
    tv) = l -> TyVarBind l -> ResultSig l
    forall l. l -> TyVarBind l -> ResultSig l
    TyVarSig (l -> l
    f l
    l) TyVarBind l
    tv

    instance Annotated Decl where
        ann :: forall l. Decl l -> l
    ann Decl l
    decl = case Decl l
    decl of
            TypeDecl     l
    l DeclHead l
    _ Type l
    _              -> l
    l
            TypeFamDecl  l
    l DeclHead l
    _ Maybe (ResultSig l)
    _ Maybe (InjectivityInfo l)
    _            -> l
    l
            ClosedTypeFamDecl  l
    l DeclHead l
    _ Maybe (ResultSig l)
    _ Maybe (InjectivityInfo l)
    _ [TypeEqn l]
    _    -> l
    l
            DataDecl     l
    l DataOrNew l
    _ Maybe (Context l)
    _ DeclHead l
    _ [QualConDecl l]
    _ [Deriving l]
    _        -> l
    l
            GDataDecl    l
    l DataOrNew l
    _ Maybe (Context l)
    _ DeclHead l
    _ Maybe (Type l)
    _ [GadtDecl l]
    _ [Deriving l]
    _      -> l
    l
            DataFamDecl  l
    l    Maybe (Context l)
    _ DeclHead l
    _ Maybe (ResultSig l)
    _         -> l
    l
            TypeInsDecl  l
    l Type l
    _  Type l
    _             -> l
    l
            DataInsDecl  l
    l DataOrNew l
    _ Type l
    _ [QualConDecl l]
    _ [Deriving l]
    _          -> l
    l
            GDataInsDecl l
    l DataOrNew l
    _ Type l
    _ Maybe (Type l)
    _ [GadtDecl l]
    _ [Deriving l]
    _        -> l
    l
            ClassDecl    l
    l Maybe (Context l)
    _ DeclHead l
    _ [FunDep l]
    _ Maybe [ClassDecl l]
    _          -> l
    l
            InstDecl     l
    l Maybe (Overlap l)
    _ InstRule l
    _ Maybe [InstDecl l]
    _            -> l
    l
            DerivDecl    l
    l Maybe (DerivStrategy l)
    _ Maybe (Overlap l)
    _ InstRule l
    _            -> l
    l
            InfixDecl    l
    l Assoc l
    _ Maybe Int
    _ [Op l]
    _            -> l
    l
            DefaultDecl  l
    l [Type l]
    _                -> l
    l
            SpliceDecl   l
    l Exp l
    _                -> l
    l
            TSpliceDecl  l
    l Exp l
    _                -> l
    l
            TypeSig      l
    l [Name l]
    _ Type l
    _              -> l
    l
            PatSynSig    l
    l [Name l]
    _ Maybe [TyVarBind l]
    _ Maybe (Context l)
    _ Maybe [TyVarBind l]
    _ Maybe (Context l)
    _ Type l
    _      -> l
    l
            FunBind      l
    l [Match l]
    _                -> l
    l
            PatBind      l
    l Pat l
    _ Rhs l
    _ Maybe (Binds l)
    _            -> l
    l
            ForImp       l
    l CallConv l
    _ Maybe (Safety l)
    _ Maybe String
    _ Name l
    _ Type l
    _        -> l
    l
            ForExp       l
    l CallConv l
    _ Maybe String
    _ Name l
    _ Type l
    _          -> l
    l
            RulePragmaDecl   l
    l [Rule l]
    _            -> l
    l
            DeprPragmaDecl   l
    l [([Name l], String)]
    _            -> l
    l
            WarnPragmaDecl   l
    l [([Name l], String)]
    _            -> l
    l
            InlineSig        l
    l Bool
    _ Maybe (Activation l)
    _ QName l
    _        -> l
    l
            InlineConlikeSig l
    l   Maybe (Activation l)
    _ QName l
    _        -> l
    l
            SpecSig          l
    l   Maybe (Activation l)
    _ QName l
    _ [Type l]
    _      -> l
    l
            SpecInlineSig    l
    l Bool
    _ Maybe (Activation l)
    _ QName l
    _ [Type l]
    _      -> l
    l
            InstSig          l
    l InstRule l
    _            -> l
    l
            AnnPragma        l
    l Annotation l
    _            -> l
    l
            MinimalPragma    l
    l Maybe (BooleanFormula l)
    _            -> l
    l
            RoleAnnotDecl    l
    l QName l
    _ [Role l]
    _          -> l
    l
            PatSyn           l
    l Pat l
    _ Pat l
    _ PatternSynDirection l
    _        -> l
    l
            CompletePragma l
    l [Name l]
    _ Maybe (QName l)
    _            -> l
    l
        amap :: forall l. (l -> l) -> Decl l -> Decl l
    amap l -> l
    f Decl l
    decl = case Decl l
    decl of
            TypeDecl     l
    l DeclHead l
    dh Type l
    t      -> l -> DeclHead l -> Type l -> Decl l
    forall l. l -> DeclHead l -> Type l -> Decl l
    TypeDecl    (l -> l
    f l
    l) DeclHead l
    dh Type l
    t
            TypeFamDecl  l
    l DeclHead l
    dh Maybe (ResultSig l)
    mk Maybe (InjectivityInfo l)
    mi  -> l
    -> DeclHead l
    -> Maybe (ResultSig l)
    -> Maybe (InjectivityInfo l)
    -> Decl l
    forall l.
    l
    -> DeclHead l
    -> Maybe (ResultSig l)
    -> Maybe (InjectivityInfo l)
    -> Decl l
    TypeFamDecl (l -> l
    f l
    l) DeclHead l
    dh Maybe (ResultSig l)
    mk Maybe (InjectivityInfo l)
    mi
            ClosedTypeFamDecl  l
    l DeclHead l
    dh Maybe (ResultSig l)
    mk Maybe (InjectivityInfo l)
    mi [TypeEqn l]
    eqns  -> l
    -> DeclHead l
    -> Maybe (ResultSig l)
    -> Maybe (InjectivityInfo l)
    -> [TypeEqn l]
    -> Decl l
    forall l.
    l
    -> DeclHead l
    -> Maybe (ResultSig l)
    -> Maybe (InjectivityInfo l)
    -> [TypeEqn l]
    -> Decl l
    ClosedTypeFamDecl (l -> l
    f l
    l) DeclHead l
    dh Maybe (ResultSig l)
    mk Maybe (InjectivityInfo l)
    mi [TypeEqn l]
    eqns
            DataDecl     l
    l DataOrNew l
    dn Maybe (Context l)
    mcx DeclHead l
    dh [QualConDecl l]
    cds [Deriving l]
    ders ->
                l
    -> DataOrNew l
    -> Maybe (Context l)
    -> DeclHead l
    -> [QualConDecl l]
    -> [Deriving l]
    -> Decl l
    forall l.
    l
    -> DataOrNew l
    -> Maybe (Context l)
    -> DeclHead l
    -> [QualConDecl l]
    -> [Deriving l]
    -> Decl l
    DataDecl (l -> l
    f l
    l) DataOrNew l
    dn Maybe (Context l)
    mcx DeclHead l
    dh [QualConDecl l]
    cds [Deriving l]
    ders
            GDataDecl    l
    l DataOrNew l
    dn Maybe (Context l)
    mcx DeclHead l
    dh Maybe (Type l)
    mk [GadtDecl l]
    gds [Deriving l]
    ders ->
                l
    -> DataOrNew l
    -> Maybe (Context l)
    -> DeclHead l
    -> Maybe (Type l)
    -> [GadtDecl l]
    -> [Deriving l]
    -> Decl l
    forall l.
    l
    -> DataOrNew l
    -> Maybe (Context l)
    -> DeclHead l
    -> Maybe (Type l)
    -> [GadtDecl l]
    -> [Deriving l]
    -> Decl l
    GDataDecl (l -> l
    f l
    l) DataOrNew l
    dn Maybe (Context l)
    mcx DeclHead l
    dh Maybe (Type l)
    mk [GadtDecl l]
    gds [Deriving l]
    ders
            DataFamDecl  l
    l Maybe (Context l)
    mcx DeclHead l
    dh Maybe (ResultSig l)
    mk         -> l
    -> Maybe (Context l) -> DeclHead l -> Maybe (ResultSig l) -> Decl l
    forall l.
    l
    -> Maybe (Context l) -> DeclHead l -> Maybe (ResultSig l) -> Decl l
    DataFamDecl (l -> l
    f l
    l) Maybe (Context l)
    mcx DeclHead l
    dh Maybe (ResultSig l)
    mk
            TypeInsDecl  l
    l Type l
    t1 Type l
    t2             -> l -> Type l -> Type l -> Decl l
    forall l. l -> Type l -> Type l -> Decl l
    TypeInsDecl (l -> l
    f l
    l) Type l
    t1 Type l
    t2
            DataInsDecl  l
    l DataOrNew l
    dn Type l
    t [QualConDecl l]
    cds [Deriving l]
    ders     -> l
    -> DataOrNew l
    -> Type l
    -> [QualConDecl l]
    -> [Deriving l]
    -> Decl l
    forall l.
    l
    -> DataOrNew l
    -> Type l
    -> [QualConDecl l]
    -> [Deriving l]
    -> Decl l
    DataInsDecl (l -> l
    f l
    l) DataOrNew l
    dn Type l
    t [QualConDecl l]
    cds [Deriving l]
    ders
            GDataInsDecl l
    l DataOrNew l
    dn Type l
    t Maybe (Type l)
    mk [GadtDecl l]
    gds [Deriving l]
    ders  -> l
    -> DataOrNew l
    -> Type l
    -> Maybe (Type l)
    -> [GadtDecl l]
    -> [Deriving l]
    -> Decl l
    forall l.
    l
    -> DataOrNew l
    -> Type l
    -> Maybe (Type l)
    -> [GadtDecl l]
    -> [Deriving l]
    -> Decl l
    GDataInsDecl (l -> l
    f l
    l) DataOrNew l
    dn Type l
    t Maybe (Type l)
    mk [GadtDecl l]
    gds [Deriving l]
    ders
            ClassDecl    l
    l Maybe (Context l)
    mcx DeclHead l
    dh [FunDep l]
    fds Maybe [ClassDecl l]
    cds    -> l
    -> Maybe (Context l)
    -> DeclHead l
    -> [FunDep l]
    -> Maybe [ClassDecl l]
    -> Decl l
    forall l.
    l
    -> Maybe (Context l)
    -> DeclHead l
    -> [FunDep l]
    -> Maybe [ClassDecl l]
    -> Decl l
    ClassDecl (l -> l
    f l
    l) Maybe (Context l)
    mcx DeclHead l
    dh [FunDep l]
    fds Maybe [ClassDecl l]
    cds
            InstDecl     l
    l Maybe (Overlap l)
    mo InstRule l
    ih Maybe [InstDecl l]
    ids         -> l
    -> Maybe (Overlap l) -> InstRule l -> Maybe [InstDecl l] -> Decl l
    forall l.
    l
    -> Maybe (Overlap l) -> InstRule l -> Maybe [InstDecl l] -> Decl l
    InstDecl (l -> l
    f l
    l) Maybe (Overlap l)
    mo InstRule l
    ih Maybe [InstDecl l]
    ids
            DerivDecl    l
    l Maybe (DerivStrategy l)
    mds Maybe (Overlap l)
    mo InstRule l
    ih         -> l
    -> Maybe (DerivStrategy l)
    -> Maybe (Overlap l)
    -> InstRule l
    -> Decl l
    forall l.
    l
    -> Maybe (DerivStrategy l)
    -> Maybe (Overlap l)
    -> InstRule l
    -> Decl l
    DerivDecl (l -> l
    f l
    l) Maybe (DerivStrategy l)
    mds Maybe (Overlap l)
    mo InstRule l
    ih
            InfixDecl    l
    l Assoc l
    a Maybe Int
    k [Op l]
    ops           -> l -> Assoc l -> Maybe Int -> [Op l] -> Decl l
    forall l. l -> Assoc l -> Maybe Int -> [Op l] -> Decl l
    InfixDecl (l -> l
    f l
    l) Assoc l
    a Maybe Int
    k [Op l]
    ops
            DefaultDecl  l
    l [Type l]
    ts                -> l -> [Type l] -> Decl l
    forall l. l -> [Type l] -> Decl l
    DefaultDecl (l -> l
    f l
    l) [Type l]
    ts
            SpliceDecl   l
    l Exp l
    sp                -> l -> Exp l -> Decl l
    forall l. l -> Exp l -> Decl l
    SpliceDecl (l -> l
    f l
    l) Exp l
    sp
            TSpliceDecl  l
    l Exp l
    sp                -> l -> Exp l -> Decl l
    forall l. l -> Exp l -> Decl l
    TSpliceDecl (l -> l
    f l
    l) Exp l
    sp
            TypeSig      l
    l [Name l]
    ns Type l
    t              -> l -> [Name l] -> Type l -> Decl l
    forall l. l -> [Name l] -> Type l -> Decl l
    TypeSig (l -> l
    f l
    l) [Name l]
    ns Type l
    t
            PatSynSig    l
    l [Name l]
    n Maybe [TyVarBind l]
    dh Maybe (Context l)
    c1 Maybe [TyVarBind l]
    dh2 Maybe (Context l)
    c2 Type l
    t      -> l
    -> [Name l]
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> Type l
    -> Decl l
    forall l.
    l
    -> [Name l]
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> Type l
    -> Decl l
    PatSynSig (l -> l
    f l
    l) [Name l]
    n Maybe [TyVarBind l]
    dh Maybe (Context l)
    c1 Maybe [TyVarBind l]
    dh2 Maybe (Context l)
    c2 Type l
    t
            FunBind      l
    l [Match l]
    ms                -> l -> [Match l] -> Decl l
    forall l. l -> [Match l] -> Decl l
    FunBind (l -> l
    f l
    l) [Match l]
    ms
            PatBind      l
    l Pat l
    p Rhs l
    rhs Maybe (Binds l)
    bs          -> l -> Pat l -> Rhs l -> Maybe (Binds l) -> Decl l
    forall l. l -> Pat l -> Rhs l -> Maybe (Binds l) -> Decl l
    PatBind (l -> l
    f l
    l) Pat l
    p Rhs l
    rhs Maybe (Binds l)
    bs
            ForImp       l
    l CallConv l
    cc Maybe (Safety l)
    msf Maybe String
    s Name l
    n Type l
    t      -> l
    -> CallConv l
    -> Maybe (Safety l)
    -> Maybe String
    -> Name l
    -> Type l
    -> Decl l
    forall l.
    l
    -> CallConv l
    -> Maybe (Safety l)
    -> Maybe String
    -> Name l
    -> Type l
    -> Decl l
    ForImp (l -> l
    f l
    l) CallConv l
    cc Maybe (Safety l)
    msf Maybe String
    s Name l
    n Type l
    t
            ForExp       l
    l CallConv l
    cc     Maybe String
    s Name l
    n Type l
    t      -> l -> CallConv l -> Maybe String -> Name l -> Type l -> Decl l
    forall l.
    l -> CallConv l -> Maybe String -> Name l -> Type l -> Decl l
    ForExp (l -> l
    f l
    l) CallConv l
    cc     Maybe String
    s Name l
    n Type l
    t
            RulePragmaDecl   l
    l [Rule l]
    rs            -> l -> [Rule l] -> Decl l
    forall l. l -> [Rule l] -> Decl l
    RulePragmaDecl (l -> l
    f l
    l) [Rule l]
    rs
            DeprPragmaDecl   l
    l [([Name l], String)]
    nss           -> l -> [([Name l], String)] -> Decl l
    forall l. l -> [([Name l], String)] -> Decl l
    DeprPragmaDecl (l -> l
    f l
    l) [([Name l], String)]
    nss
            WarnPragmaDecl   l
    l [([Name l], String)]
    nss           -> l -> [([Name l], String)] -> Decl l
    forall l. l -> [([Name l], String)] -> Decl l
    WarnPragmaDecl (l -> l
    f l
    l) [([Name l], String)]
    nss
            InlineSig        l
    l Bool
    b Maybe (Activation l)
    act QName l
    qn      -> l -> Bool -> Maybe (Activation l) -> QName l -> Decl l
    forall l. l -> Bool -> Maybe (Activation l) -> QName l -> Decl l
    InlineSig (l -> l
    f l
    l) Bool
    b Maybe (Activation l)
    act QName l
    qn
            InlineConlikeSig l
    l   Maybe (Activation l)
    act QName l
    qn      -> l -> Maybe (Activation l) -> QName l -> Decl l
    forall l. l -> Maybe (Activation l) -> QName l -> Decl l
    InlineConlikeSig (l -> l
    f l
    l) Maybe (Activation l)
    act QName l
    qn
            SpecSig          l
    l   Maybe (Activation l)
    act QName l
    qn [Type l]
    ts   -> l -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l
    forall l.
    l -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l
    SpecSig       (l -> l
    f l
    l)   Maybe (Activation l)
    act QName l
    qn [Type l]
    ts
            SpecInlineSig    l
    l Bool
    b Maybe (Activation l)
    act QName l
    qn [Type l]
    ts   -> l -> Bool -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l
    forall l.
    l -> Bool -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l
    SpecInlineSig (l -> l
    f l
    l) Bool
    b Maybe (Activation l)
    act QName l
    qn [Type l]
    ts
            InstSig          l
    l InstRule l
    ih            -> l -> InstRule l -> Decl l
    forall l. l -> InstRule l -> Decl l
    InstSig (l -> l
    f l
    l) InstRule l
    ih
            AnnPragma        l
    l Annotation l
    ann'          -> l -> Annotation l -> Decl l
    forall l. l -> Annotation l -> Decl l
    AnnPragma (l -> l
    f l
    l) Annotation l
    ann'
            MinimalPragma    l
    l Maybe (BooleanFormula l)
    b             -> l -> Maybe (BooleanFormula l) -> Decl l
    forall l. l -> Maybe (BooleanFormula l) -> Decl l
    MinimalPragma (l -> l
    f l
    l) Maybe (BooleanFormula l)
    b
            RoleAnnotDecl    l
    l QName l
    t [Role l]
    rs          -> l -> QName l -> [Role l] -> Decl l
    forall l. l -> QName l -> [Role l] -> Decl l
    RoleAnnotDecl (l -> l
    f l
    l) QName l
    t [Role l]
    rs
            PatSyn           l
    l Pat l
    p Pat l
    r PatternSynDirection l
    d         -> l -> Pat l -> Pat l -> PatternSynDirection l -> Decl l
    forall l. l -> Pat l -> Pat l -> PatternSynDirection l -> Decl l
    PatSyn (l -> l
    f l
    l) Pat l
    p Pat l
    r PatternSynDirection l
    d
            CompletePragma   l
    l [Name l]
    cs Maybe (QName l)
    ty         -> l -> [Name l] -> Maybe (QName l) -> Decl l
    forall l. l -> [Name l] -> Maybe (QName l) -> Decl l
    CompletePragma (l -> l
    f l
    l) [Name l]
    cs Maybe (QName l)
    ty

    instance Annotated Role where
        ann :: forall l. Role l -> l
    ann Role l
    r = case Role l
    r of
          RoleWildcard l
    l -> l
    l
          Representational l
    l -> l
    l
          Phantom l
    l -> l
    l
          Nominal l
    l -> l
    l
        amap :: forall l. (l -> l) -> Role l -> Role l
    amap l -> l
    f Role l
    r = case Role l
    r of
          RoleWildcard l
    l -> l -> Role l
    forall l. l -> Role l
    RoleWildcard (l -> l
    f l
    l)
          Representational l
    l -> l -> Role l
    forall l. l -> Role l
    Representational (l -> l
    f l
    l)
          Phantom l
    l -> l -> Role l
    forall l. l -> Role l
    Phantom (l -> l
    f l
    l)
          Nominal l
    l -> l -> Role l
    forall l. l -> Role l
    Nominal (l -> l
    f l
    l)

    instance Annotated Annotation where
        ann :: forall l. Annotation l -> l
    ann (Ann     l
    l Name l
    _ Exp l
    _) = l
    l
        ann (TypeAnn l
    l Name l
    _ Exp l
    _) = l
    l
        ann (ModuleAnn l
    l Exp l
    _) = l
    l
        amap :: forall l. (l -> l) -> Annotation l -> Annotation l
    amap l -> l
    f (Ann     l
    l Name l
    n Exp l
    e) = l -> Name l -> Exp l -> Annotation l
    forall l. l -> Name l -> Exp l -> Annotation l
    Ann     (l -> l
    f l
    l) Name l
    n Exp l
    e
        amap l -> l
    f (TypeAnn l
    l Name l
    n Exp l
    e) = l -> Name l -> Exp l -> Annotation l
    forall l. l -> Name l -> Exp l -> Annotation l
    TypeAnn (l -> l
    f l
    l) Name l
    n Exp l
    e
        amap l -> l
    f (ModuleAnn l
    l Exp l
    e) = l -> Exp l -> Annotation l
    forall l. l -> Exp l -> Annotation l
    ModuleAnn (l -> l
    f l
    l) Exp l
    e

    instance Annotated BooleanFormula where
        ann :: forall l. BooleanFormula l -> l
    ann (VarFormula l
    l Name l
    _)   = l
    l
        ann (AndFormula l
    l [BooleanFormula l]
    _)   = l
    l
        ann (OrFormula l
    l [BooleanFormula l]
    _)    = l
    l
        ann (ParenFormula l
    l BooleanFormula l
    _) = l
    l
        amap :: forall l. (l -> l) -> BooleanFormula l -> BooleanFormula l
    amap l -> l
    f (VarFormula l
    l Name l
    n)   = l -> Name l -> BooleanFormula l
    forall l. l -> Name l -> BooleanFormula l
    VarFormula (l -> l
    f l
    l) Name l
    n
        amap l -> l
    f (AndFormula l
    l [BooleanFormula l]
    bs)  = l -> [BooleanFormula l] -> BooleanFormula l
    forall l. l -> [BooleanFormula l] -> BooleanFormula l
    AndFormula (l -> l
    f l
    l) [BooleanFormula l]
    bs
        amap l -> l
    f (OrFormula l
    l [BooleanFormula l]
    bs)   = l -> [BooleanFormula l] -> BooleanFormula l
    forall l. l -> [BooleanFormula l] -> BooleanFormula l
    OrFormula (l -> l
    f l
    l) [BooleanFormula l]
    bs
        amap l -> l
    f (ParenFormula l
    l BooleanFormula l
    b) = l -> BooleanFormula l -> BooleanFormula l
    forall l. l -> BooleanFormula l -> BooleanFormula l
    ParenFormula (l -> l
    f l
    l) BooleanFormula l
    b

    instance Annotated DataOrNew where
        ann :: forall l. DataOrNew l -> l
    ann (DataType l
    l) = l
    l
        ann (NewType  l
    l) = l
    l
        amap :: forall l. (l -> l) -> DataOrNew l -> DataOrNew l
    amap = (l -> l) -> DataOrNew l -> DataOrNew l
    forall a b. (a -> b) -> DataOrNew a -> DataOrNew b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated DeclHead where
        ann :: forall l. DeclHead l -> l
    ann (DHead l
    l Name l
    _)              = l
    l
        ann (DHInfix l
    l TyVarBind l
    _ Name l
    _)          = l
    l
        ann (DHParen l
    l DeclHead l
    _)            = l
    l
        ann (DHApp l
    l DeclHead l
    _ TyVarBind l
    _)            = l
    l
        amap :: forall l. (l -> l) -> DeclHead l -> DeclHead l
    amap l -> l
    f (DHead l
    l Name l
    n)           = l -> Name l -> DeclHead l
    forall l. l -> Name l -> DeclHead l
    DHead (l -> l
    f l
    l) Name l
    n
        amap l -> l
    f (DHInfix l
    l TyVarBind l
    tva Name l
    n)     = l -> TyVarBind l -> Name l -> DeclHead l
    forall l. l -> TyVarBind l -> Name l -> DeclHead l
    DHInfix (l -> l
    f l
    l) TyVarBind l
    tva Name l
    n
        amap l -> l
    f (DHParen l
    l DeclHead l
    dh)        = l -> DeclHead l -> DeclHead l
    forall l. l -> DeclHead l -> DeclHead l
    DHParen (l -> l
    f l
    l) DeclHead l
    dh
        amap l -> l
    f (DHApp l
    l DeclHead l
    dh TyVarBind l
    t)        = l -> DeclHead l -> TyVarBind l -> DeclHead l
    forall l. l -> DeclHead l -> TyVarBind l -> DeclHead l
    DHApp (l -> l
    f l
    l) DeclHead l
    dh TyVarBind l
    t

    instance Annotated InstRule where
        ann :: forall l. InstRule l -> l
    ann (IRule l
    l Maybe [TyVarBind l]
    _ Maybe (Context l)
    _ InstHead l
    _)         = l
    l
        ann (IParen l
    l InstRule l
    _)            = l
    l
        amap :: forall l. (l -> l) -> InstRule l -> InstRule l
    amap l -> l
    f (IRule l
    l Maybe [TyVarBind l]
    mtv Maybe (Context l)
    cxt InstHead l
    qn) = l
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> InstHead l
    -> InstRule l
    forall l.
    l
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> InstHead l
    -> InstRule l
    IRule (l -> l
    f l
    l) Maybe [TyVarBind l]
    mtv Maybe (Context l)
    cxt InstHead l
    qn
        amap l -> l
    f (IParen l
    l InstRule l
    ih)        = l -> InstRule l -> InstRule l
    forall l. l -> InstRule l -> InstRule l
    IParen (l -> l
    f l
    l) InstRule l
    ih

    instance Annotated InstHead where
        ann :: forall l. InstHead l -> l
    ann (IHCon l
    l QName l
    _)              = l
    l
        ann (IHInfix l
    l Type l
    _ QName l
    _)          = l
    l
        ann (IHParen l
    l InstHead l
    _)            = l
    l
        ann (IHApp l
    l InstHead l
    _ Type l
    _)            = l
    l
        amap :: forall l. (l -> l) -> InstHead l -> InstHead l
    amap l -> l
    f (IHCon l
    l QName l
    n)           = l -> QName l -> InstHead l
    forall l. l -> QName l -> InstHead l
    IHCon (l -> l
    f l
    l) QName l
    n
        amap l -> l
    f (IHInfix l
    l Type l
    tva QName l
    n)     = l -> Type l -> QName l -> InstHead l
    forall l. l -> Type l -> QName l -> InstHead l
    IHInfix (l -> l
    f l
    l) Type l
    tva QName l
    n
        amap l -> l
    f (IHParen l
    l InstHead l
    dh)        = l -> InstHead l -> InstHead l
    forall l. l -> InstHead l -> InstHead l
    IHParen (l -> l
    f l
    l) InstHead l
    dh
        amap l -> l
    f (IHApp l
    l InstHead l
    dh Type l
    t)        = l -> InstHead l -> Type l -> InstHead l
    forall l. l -> InstHead l -> Type l -> InstHead l
    IHApp (l -> l
    f l
    l) InstHead l
    dh Type l
    t

    instance Annotated Binds where
        ann :: forall l. Binds l -> l
    ann (BDecls  l
    l [Decl l]
    _) = l
    l
        ann (IPBinds l
    l [IPBind l]
    _) = l
    l
        amap :: forall l. (l -> l) -> Binds l -> Binds l
    amap l -> l
    f (BDecls  l
    l [Decl l]
    decls) = l -> [Decl l] -> Binds l
    forall l. l -> [Decl l] -> Binds l
    BDecls (l -> l
    f l
    l) [Decl l]
    decls
        amap l -> l
    f (IPBinds l
    l [IPBind l]
    ibs)   = l -> [IPBind l] -> Binds l
    forall l. l -> [IPBind l] -> Binds l
    IPBinds (l -> l
    f l
    l) [IPBind l]
    ibs

    instance Annotated IPBind where
        ann :: forall l. IPBind l -> l
    ann (IPBind l
    l IPName l
    _ Exp l
    _) = l
    l
        amap :: forall l. (l -> l) -> IPBind l -> IPBind l
    amap l -> l
    f (IPBind l
    l IPName l
    ipn Exp l
    e) = l -> IPName l -> Exp l -> IPBind l
    forall l. l -> IPName l -> Exp l -> IPBind l
    IPBind (l -> l
    f l
    l) IPName l
    ipn Exp l
    e

    instance Annotated Match where
        ann :: forall l. Match l -> l
    ann (Match l
    l Name l
    _ [Pat l]
    _ Rhs l
    _ Maybe (Binds l)
    _)        = l
    l
        ann (InfixMatch l
    l Pat l
    _ Name l
    _ [Pat l]
    _ Rhs l
    _ Maybe (Binds l)
    _) = l
    l
        amap :: forall l. (l -> l) -> Match l -> Match l
    amap l -> l
    f (Match l
    l Name l
    n [Pat l]
    ps Rhs l
    rhs Maybe (Binds l)
    bs) = l -> Name l -> [Pat l] -> Rhs l -> Maybe (Binds l) -> Match l
    forall l.
    l -> Name l -> [Pat l] -> Rhs l -> Maybe (Binds l) -> Match l
    Match (l -> l
    f l
    l) Name l
    n [Pat l]
    ps Rhs l
    rhs Maybe (Binds l)
    bs
        amap l -> l
    f (InfixMatch l
    l Pat l
    a Name l
    n [Pat l]
    b Rhs l
    rhs Maybe (Binds l)
    bs) = l
    -> Pat l
    -> Name l
    -> [Pat l]
    -> Rhs l
    -> Maybe (Binds l)
    -> Match l
    forall l.
    l
    -> Pat l
    -> Name l
    -> [Pat l]
    -> Rhs l
    -> Maybe (Binds l)
    -> Match l
    InfixMatch (l -> l
    f l
    l) Pat l
    a Name l
    n [Pat l]
    b Rhs l
    rhs Maybe (Binds l)
    bs

    instance Annotated QualConDecl where
        ann :: forall l. QualConDecl l -> l
    ann (QualConDecl l
    l Maybe [TyVarBind l]
    _ Maybe (Context l)
    _ ConDecl l
    _) = l
    l
        amap :: forall l. (l -> l) -> QualConDecl l -> QualConDecl l
    amap l -> l
    f (QualConDecl l
    l Maybe [TyVarBind l]
    tvs Maybe (Context l)
    cx ConDecl l
    cd) = l
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> ConDecl l
    -> QualConDecl l
    forall l.
    l
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> ConDecl l
    -> QualConDecl l
    QualConDecl (l -> l
    f l
    l) Maybe [TyVarBind l]
    tvs Maybe (Context l)
    cx ConDecl l
    cd

    instance Annotated ConDecl where
        ann :: forall l. ConDecl l -> l
    ann (ConDecl l
    l Name l
    _ [Type l]
    _)        = l
    l
        ann (InfixConDecl l
    l Type l
    _ Name l
    _ Type l
    _) = l
    l
        ann (RecDecl l
    l Name l
    _ [FieldDecl l]
    _)        = l
    l
        amap :: forall l. (l -> l) -> ConDecl l -> ConDecl l
    amap l -> l
    f (ConDecl l
    l Name l
    n [Type l]
    bts) = l -> Name l -> [Type l] -> ConDecl l
    forall l. l -> Name l -> [Type l] -> ConDecl l
    ConDecl (l -> l
    f l
    l) Name l
    n [Type l]
    bts
        amap l -> l
    f (InfixConDecl l
    l Type l
    ta Name l
    n Type l
    tb) = l -> Type l -> Name l -> Type l -> ConDecl l
    forall l. l -> Type l -> Name l -> Type l -> ConDecl l
    InfixConDecl (l -> l
    f l
    l) Type l
    ta Name l
    n Type l
    tb
        amap l -> l
    f (RecDecl l
    l Name l
    n [FieldDecl l]
    fds) = l -> Name l -> [FieldDecl l] -> ConDecl l
    forall l. l -> Name l -> [FieldDecl l] -> ConDecl l
    RecDecl (l -> l
    f l
    l) Name l
    n [FieldDecl l]
    fds

    instance Annotated FieldDecl where
        ann :: forall l. FieldDecl l -> l
    ann (FieldDecl l
    l [Name l]
    _ Type l
    _) = l
    l
        amap :: forall l. (l -> l) -> FieldDecl l -> FieldDecl l
    amap l -> l
    f (FieldDecl l
    l [Name l]
    ns Type l
    t) = l -> [Name l] -> Type l -> FieldDecl l
    forall l. l -> [Name l] -> Type l -> FieldDecl l
    FieldDecl (l -> l
    f l
    l) [Name l]
    ns Type l
    t

    instance Annotated GadtDecl where
        ann :: forall l. GadtDecl l -> l
    ann (GadtDecl l
    l Name l
    _ Maybe [TyVarBind l]
    _ Maybe (Context l)
    _ Maybe [FieldDecl l]
    _ Type l
    _) = l
    l
        amap :: forall l. (l -> l) -> GadtDecl l -> GadtDecl l
    amap l -> l
    f (GadtDecl l
    l Name l
    n Maybe [TyVarBind l]
    t1 Maybe (Context l)
    t2 Maybe [FieldDecl l]
    t3 Type l
    t4) = l
    -> Name l
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> Maybe [FieldDecl l]
    -> Type l
    -> GadtDecl l
    forall l.
    l
    -> Name l
    -> Maybe [TyVarBind l]
    -> Maybe (Context l)
    -> Maybe [FieldDecl l]
    -> Type l
    -> GadtDecl l
    GadtDecl (l -> l
    f l
    l) Name l
    n Maybe [TyVarBind l]
    t1 Maybe (Context l)
    t2 Maybe [FieldDecl l]
    t3 Type l
    t4

    instance Annotated ClassDecl where
        ann :: forall l. ClassDecl l -> l
    ann (ClsDecl    l
    l Decl l
    _)      = l
    l
        ann (ClsDataFam l
    l Maybe (Context l)
    _ DeclHead l
    _ Maybe (ResultSig l)
    _)  = l
    l
        ann (ClsTyFam   l
    l DeclHead l
    _ Maybe (ResultSig l)
    _ Maybe (InjectivityInfo l)
    _) = l
    l
        ann (ClsTyDef   l
    l TypeEqn l
    _)    = l
    l
        ann (ClsDefSig  l
    l Name l
    _ Type l
    _)    = l
    l
        amap :: forall l. (l -> l) -> ClassDecl l -> ClassDecl l
    amap l -> l
    f (ClsDecl    l
    l Decl l
    d) = l -> Decl l -> ClassDecl l
    forall l. l -> Decl l -> ClassDecl l
    ClsDecl (l -> l
    f l
    l) Decl l
    d
        amap l -> l
    f (ClsDataFam l
    l Maybe (Context l)
    mcx DeclHead l
    dh Maybe (ResultSig l)
    mk) = l
    -> Maybe (Context l)
    -> DeclHead l
    -> Maybe (ResultSig l)
    -> ClassDecl l
    forall l.
    l
    -> Maybe (Context l)
    -> DeclHead l
    -> Maybe (ResultSig l)
    -> ClassDecl l
    ClsDataFam (l -> l
    f l
    l) Maybe (Context l)
    mcx DeclHead l
    dh Maybe (ResultSig l)
    mk
        amap l -> l
    f (ClsTyFam   l
    l DeclHead l
    dh Maybe (ResultSig l)
    mk Maybe (InjectivityInfo l)
    mi) = l
    -> DeclHead l
    -> Maybe (ResultSig l)
    -> Maybe (InjectivityInfo l)
    -> ClassDecl l
    forall l.
    l
    -> DeclHead l
    -> Maybe (ResultSig l)
    -> Maybe (InjectivityInfo l)
    -> ClassDecl l
    ClsTyFam (l -> l
    f l
    l) DeclHead l
    dh Maybe (ResultSig l)
    mk Maybe (InjectivityInfo l)
    mi
        amap l -> l
    f (ClsTyDef   l
    l TypeEqn l
    t ) = l -> TypeEqn l -> ClassDecl l
    forall l. l -> TypeEqn l -> ClassDecl l
    ClsTyDef (l -> l
    f l
    l) TypeEqn l
    t
        amap l -> l
    f (ClsDefSig  l
    l Name l
    n Type l
    t) = l -> Name l -> Type l -> ClassDecl l
    forall l. l -> Name l -> Type l -> ClassDecl l
    ClsDefSig (l -> l
    f l
    l) Name l
    n Type l
    t

    instance Annotated InstDecl where
        ann :: forall l. InstDecl l -> l
    ann InstDecl l
    id = case InstDecl l
    id of
            InsDecl   l
    l Decl l
    _            -> l
    l
            InsType   l
    l Type l
    _ Type l
    _          -> l
    l
            InsData   l
    l DataOrNew l
    _ Type l
    _  [QualConDecl l]
    _ [Deriving l]
    _     -> l
    l
            InsGData  l
    l DataOrNew l
    _ Type l
    _ Maybe (Type l)
    _ [GadtDecl l]
    _ [Deriving l]
    _    -> l
    l
    --        InsInline l _ _ _    -> l
        amap :: forall l. (l -> l) -> InstDecl l -> InstDecl l
    amap l -> l
    f InstDecl l
    id = case InstDecl l
    id of
            InsDecl   l
    l Decl l
    d           -> l -> Decl l -> InstDecl l
    forall l. l -> Decl l -> InstDecl l
    InsDecl (l -> l
    f l
    l) Decl l
    d
            InsType   l
    l Type l
    t1 Type l
    t2       -> l -> Type l -> Type l -> InstDecl l
    forall l. l -> Type l -> Type l -> InstDecl l
    InsType (l -> l
    f l
    l) Type l
    t1 Type l
    t2
            InsData   l
    l DataOrNew l
    dn Type l
    t    [QualConDecl l]
    cds [Deriving l]
    ders -> l
    -> DataOrNew l
    -> Type l
    -> [QualConDecl l]
    -> [Deriving l]
    -> InstDecl l
    forall l.
    l
    -> DataOrNew l
    -> Type l
    -> [QualConDecl l]
    -> [Deriving l]
    -> InstDecl l
    InsData  (l -> l
    f l
    l) DataOrNew l
    dn Type l
    t    [QualConDecl l]
    cds [Deriving l]
    ders
            InsGData  l
    l DataOrNew l
    dn Type l
    t Maybe (Type l)
    mk [GadtDecl l]
    gds [Deriving l]
    ders -> l
    -> DataOrNew l
    -> Type l
    -> Maybe (Type l)
    -> [GadtDecl l]
    -> [Deriving l]
    -> InstDecl l
    forall l.
    l
    -> DataOrNew l
    -> Type l
    -> Maybe (Type l)
    -> [GadtDecl l]
    -> [Deriving l]
    -> InstDecl l
    InsGData (l -> l
    f l
    l) DataOrNew l
    dn Type l
    t Maybe (Type l)
    mk [GadtDecl l]
    gds [Deriving l]
    ders
    --        InsInline l b act qn    -> InsInline (f l) b act qn

    instance Annotated BangType where
         ann :: forall l. BangType l -> l
    ann (BangedTy   l
    l)       = l
    l
         ann (LazyTy   l
    l)         = l
    l
         ann (NoStrictAnnot l
    l)    = l
    l

         amap :: forall l. (l -> l) -> BangType l -> BangType l
    amap l -> l
    f (BangedTy   l
    l) = l -> BangType l
    forall l. l -> BangType l
    BangedTy (l -> l
    f l
    l)
         amap l -> l
    f (LazyTy   l
    l)   = l -> BangType l
    forall l. l -> BangType l
    LazyTy (l -> l
    f l
    l)
         amap l -> l
    f (NoStrictAnnot l
    l) = l -> BangType l
    forall l. l -> BangType l
    NoStrictAnnot (l -> l
    f l
    l)

    instance Annotated Unpackedness where
        ann :: forall l. Unpackedness l -> l
    ann (Unpack l
    l) = l
    l
        ann (NoUnpack l
    l) = l
    l
        ann (NoUnpackPragma l
    l) = l
    l

        amap :: forall l. (l -> l) -> Unpackedness l -> Unpackedness l
    amap l -> l
    f (Unpack l
    l) = l -> Unpackedness l
    forall l. l -> Unpackedness l
    Unpack (l -> l
    f l
    l)
        amap l -> l
    f (NoUnpack l
    l) = l -> Unpackedness l
    forall l. l -> Unpackedness l
    Unpack (l -> l
    f l
    l)
        amap l -> l
    f (NoUnpackPragma l
    l) = l -> Unpackedness l
    forall l. l -> Unpackedness l
    Unpack (l -> l
    f l
    l)

    instance Annotated Rhs where
         ann :: forall l. Rhs l -> l
    ann (UnGuardedRhs l
    l Exp l
    _) = l
    l
         ann (GuardedRhss  l
    l [GuardedRhs l]
    _) = l
    l
         amap :: forall l. (l -> l) -> Rhs l -> Rhs l
    amap l -> l
    f (UnGuardedRhs l
    l Exp l
    e)     = l -> Exp l -> Rhs l
    forall l. l -> Exp l -> Rhs l
    UnGuardedRhs (l -> l
    f l
    l) Exp l
    e
         amap l -> l
    f (GuardedRhss  l
    l [GuardedRhs l]
    grhss) = l -> [GuardedRhs l] -> Rhs l
    forall l. l -> [GuardedRhs l] -> Rhs l
    GuardedRhss  (l -> l
    f l
    l) [GuardedRhs l]
    grhss

    instance Annotated GuardedRhs where
         ann :: forall l. GuardedRhs l -> l
    ann (GuardedRhs l
    l [Stmt l]
    _ Exp l
    _) = l
    l
         amap :: forall l. (l -> l) -> GuardedRhs l -> GuardedRhs l
    amap l -> l
    f (GuardedRhs l
    l [Stmt l]
    ss Exp l
    e) = l -> [Stmt l] -> Exp l -> GuardedRhs l
    forall l. l -> [Stmt l] -> Exp l -> GuardedRhs l
    GuardedRhs (l -> l
    f l
    l) [Stmt l]
    ss Exp l
    e

    instance Annotated Type where
        ann :: forall l. Type l -> l
    ann Type l
    t = case Type l
    t of
          TyForall l
    l Maybe [TyVarBind l]
    _ Maybe (Context l)
    _ Type l
    _              -> l
    l
          TyStar  l
    l                     -> l
    l
          TyFun   l
    l Type l
    _ Type l
    _                 -> l
    l
          TyTuple l
    l Boxed
    _ [Type l]
    _                 -> l
    l
          TyUnboxedSum l
    l [Type l]
    _              -> l
    l
          TyList  l
    l Type l
    _                   -> l
    l
          TyParArray  l
    l Type l
    _               -> l
    l
          TyApp   l
    l Type l
    _ Type l
    _                 -> l
    l
          TyVar   l
    l Name l
    _                   -> l
    l
          TyCon   l
    l QName l
    _                   -> l
    l
          TyParen l
    l Type l
    _                   -> l
    l
          TyInfix l
    l Type l
    _ MaybePromotedName l
    _ Type l
    _               -> l
    l
          TyKind  l
    l Type l
    _ Type l
    _                 -> l
    l
          TyPromoted l
    l   Promoted l
    _              -> l
    l
          TyEquals l
    l Type l
    _ Type l
    _                -> l
    l
          TySplice l
    l Splice l
    _                  -> l
    l
          TyBang l
    l BangType l
    _ Unpackedness l
    _ Type l
    _                  -> l
    l
          TyWildCard l
    l Maybe (Name l)
    _                -> l
    l
          TyQuasiQuote l
    l String
    _ String
    _            -> l
    l
        amap :: forall l. (l -> l) -> Type l -> Type l
    amap l -> l
    f Type l
    t1 = case Type l
    t1 of
          TyForall l
    l Maybe [TyVarBind l]
    mtvs Maybe (Context l)
    mcx Type l
    t         -> l -> Maybe [TyVarBind l] -> Maybe (Context l) -> Type l -> Type l
    forall l.
    l -> Maybe [TyVarBind l] -> Maybe (Context l) -> Type l -> Type l
    TyForall (l -> l
    f l
    l) Maybe [TyVarBind l]
    mtvs Maybe (Context l)
    mcx Type l
    t
          TyStar  l
    l                     -> l -> Type l
    forall l. l -> Type l
    TyStar (l -> l
    f l
    l)
          TyFun   l
    l Type l
    t1' Type l
    t2              -> l -> Type l -> Type l -> Type l
    forall l. l -> Type l -> Type l -> Type l
    TyFun (l -> l
    f l
    l) Type l
    t1' Type l
    t2
          TyTuple l
    l Boxed
    b [Type l]
    ts                -> l -> Boxed -> [Type l] -> Type l
    forall l. l -> Boxed -> [Type l] -> Type l
    TyTuple (l -> l
    f l
    l) Boxed
    b [Type l]
    ts
          TyUnboxedSum l
    l [Type l]
    s              -> l -> [Type l] -> Type l
    forall l. l -> [Type l] -> Type l
    TyUnboxedSum (l -> l
    f l
    l) [Type l]
    s
          TyList  l
    l Type l
    t                   -> l -> Type l -> Type l
    forall l. l -> Type l -> Type l
    TyList (l -> l
    f l
    l) Type l
    t
          TyParArray  l
    l Type l
    t               -> l -> Type l -> Type l
    forall l. l -> Type l -> Type l
    TyParArray (l -> l
    f l
    l) Type l
    t
          TyApp   l
    l Type l
    t1' Type l
    t2              -> l -> Type l -> Type l -> Type l
    forall l. l -> Type l -> Type l -> Type l
    TyApp (l -> l
    f l
    l) Type l
    t1' Type l
    t2
          TyVar   l
    l Name l
    n                   -> l -> Name l -> Type l
    forall l. l -> Name l -> Type l
    TyVar (l -> l
    f l
    l) Name l
    n
          TyCon   l
    l QName l
    qn                  -> l -> QName l -> Type l
    forall l. l -> QName l -> Type l
    TyCon (l -> l
    f l
    l) QName l
    qn
          TyParen l
    l Type l
    t                   -> l -> Type l -> Type l
    forall l. l -> Type l -> Type l
    TyParen (l -> l
    f l
    l) Type l
    t
          TyInfix l
    l Type l
    ta MaybePromotedName l
    qn Type l
    tb            -> l -> Type l -> MaybePromotedName l -> Type l -> Type l
    forall l. l -> Type l -> MaybePromotedName l -> Type l -> Type l
    TyInfix (l -> l
    f l
    l) Type l
    ta MaybePromotedName l
    qn Type l
    tb
          TyKind  l
    l Type l
    t Type l
    k                 -> l -> Type l -> Type l -> Type l
    forall l. l -> Type l -> Type l -> Type l
    TyKind (l -> l
    f l
    l) Type l
    t Type l
    k
          TyPromoted l
    l   Promoted l
    p              -> l -> Promoted l -> Type l
    forall l. l -> Promoted l -> Type l
    TyPromoted (l -> l
    f l
    l)   Promoted l
    p
          TyEquals l
    l Type l
    a Type l
    b                -> l -> Type l -> Type l -> Type l
    forall l. l -> Type l -> Type l -> Type l
    TyEquals (l -> l
    f l
    l) Type l
    a Type l
    b
          TySplice l
    l Splice l
    s                  -> l -> Splice l -> Type l
    forall l. l -> Splice l -> Type l
    TySplice (l -> l
    f l
    l) Splice l
    s
          TyBang l
    l BangType l
    b Unpackedness l
    u Type l
    t                  -> l -> BangType l -> Unpackedness l -> Type l -> Type l
    forall l. l -> BangType l -> Unpackedness l -> Type l -> Type l
    TyBang (l -> l
    f l
    l) BangType l
    b Unpackedness l
    u Type l
    t
          TyWildCard l
    l Maybe (Name l)
    n                -> l -> Maybe (Name l) -> Type l
    forall l. l -> Maybe (Name l) -> Type l
    TyWildCard (l -> l
    f l
    l) Maybe (Name l)
    n
          TyQuasiQuote l
    l String
    n String
    s            -> l -> String -> String -> Type l
    forall l. l -> String -> String -> Type l
    TyQuasiQuote (l -> l
    f l
    l) String
    n String
    s

    instance Annotated MaybePromotedName where
      ann :: forall l. MaybePromotedName l -> l
    ann MaybePromotedName l
    t = case MaybePromotedName l
    t of
        PromotedName l
    l QName l
    _ -> l
    l
        UnpromotedName l
    l QName l
    _ -> l
    l
      amap :: forall l. (l -> l) -> MaybePromotedName l -> MaybePromotedName l
    amap l -> l
    f MaybePromotedName l
    tl =  case MaybePromotedName l
    tl of
        PromotedName l
    l QName l
    q -> l -> QName l -> MaybePromotedName l
    forall l. l -> QName l -> MaybePromotedName l
    PromotedName (l -> l
    f l
    l)     QName l
    q
        UnpromotedName l
    l QName l
    q -> l -> QName l -> MaybePromotedName l
    forall l. l -> QName l -> MaybePromotedName l
    UnpromotedName (l -> l
    f l
    l) QName l
    q

    instance Annotated TyVarBind where
        ann :: forall l. TyVarBind l -> l
    ann (KindedVar   l
    l Name l
    _ Kind l
    _) = l
    l
        ann (UnkindedVar l
    l Name l
    _)   = l
    l
        amap :: forall l. (l -> l) -> TyVarBind l -> TyVarBind l
    amap l -> l
    f (KindedVar   l
    l Name l
    n Kind l
    k) = l -> Name l -> Kind l -> TyVarBind l
    forall l. l -> Name l -> Kind l -> TyVarBind l
    KindedVar   (l -> l
    f l
    l) Name l
    n Kind l
    k
        amap l -> l
    f (UnkindedVar l
    l Name l
    n)   = l -> Name l -> TyVarBind l
    forall l. l -> Name l -> TyVarBind l
    UnkindedVar (l -> l
    f l
    l) Name l
    n

    instance Annotated FunDep where
        ann :: forall l. FunDep l -> l
    ann (FunDep l
    l [Name l]
    _ [Name l]
    _) = l
    l
        amap :: forall l. (l -> l) -> FunDep l -> FunDep l
    amap l -> l
    f (FunDep l
    l [Name l]
    ns1 [Name l]
    ns2) = l -> [Name l] -> [Name l] -> FunDep l
    forall l. l -> [Name l] -> [Name l] -> FunDep l
    FunDep (l -> l
    f l
    l) [Name l]
    ns1 [Name l]
    ns2

    instance Annotated Context where
        ann :: forall l. Context l -> l
    ann (CxSingle l
    l Asst l
    _) = l
    l
        ann (CxTuple  l
    l [Asst l]
    _) = l
    l
        ann (CxEmpty  l
    l)   = l
    l
        amap :: forall l. (l -> l) -> Context l -> Context l
    amap l -> l
    f (CxSingle l
    l Asst l
    asst ) = l -> Asst l -> Context l
    forall l. l -> Asst l -> Context l
    CxSingle (l -> l
    f l
    l) Asst l
    asst
        amap l -> l
    f (CxTuple  l
    l [Asst l]
    assts) = l -> [Asst l] -> Context l
    forall l. l -> [Asst l] -> Context l
    CxTuple  (l -> l
    f l
    l) [Asst l]
    assts
        amap l -> l
    f (CxEmpty l
    l) = l -> Context l
    forall l. l -> Context l
    CxEmpty (l -> l
    f l
    l)

    instance Annotated Asst where
        ann :: forall l. Asst l -> l
    ann Asst l
    asst = case Asst l
    asst of
            TypeA l
    l Type l
    _        -> l
    l
            IParam l
    l IPName l
    _ Type l
    _     -> l
    l
            ParenA l
    l Asst l
    _       -> l
    l
        amap :: forall l. (l -> l) -> Asst l -> Asst l
    amap l -> l
    f Asst l
    asst = case Asst l
    asst of
            TypeA l
    l Type l
    t           -> l -> Type l -> Asst l
    forall l. l -> Type l -> Asst l
    TypeA (l -> l
    f l
    l) Type l
    t
            IParam l
    l IPName l
    ipn Type l
    t      -> l -> IPName l -> Type l -> Asst l
    forall l. l -> IPName l -> Type l -> Asst l
    IParam (l -> l
    f l
    l) IPName l
    ipn Type l
    t
            ParenA l
    l Asst l
    a          -> l -> Asst l -> Asst l
    forall l. l -> Asst l -> Asst l
    ParenA (l -> l
    f l
    l) Asst l
    a

    instance Annotated Literal where
        ann :: forall l. Literal l -> l
    ann Literal l
    lit = case Literal l
    lit of
            Char    l
    l Char
    _    String
    _  -> l
    l
            String  l
    l String
    _    String
    _  -> l
    l
            Int     l
    l Integer
    _    String
    _  -> l
    l
            Frac    l
    l Rational
    _    String
    _  -> l
    l
            PrimInt    l
    l Integer
    _ String
    _  -> l
    l
            PrimWord   l
    l Integer
    _ String
    _  -> l
    l
            PrimFloat  l
    l Rational
    _ String
    _  -> l
    l
            PrimDouble l
    l Rational
    _ String
    _  -> l
    l
            PrimChar   l
    l Char
    _ String
    _  -> l
    l
            PrimString l
    l String
    _ String
    _  -> l
    l
        amap :: forall l. (l -> l) -> Literal l -> Literal l
    amap = (l -> l) -> Literal l -> Literal l
    forall a b. (a -> b) -> Literal a -> Literal b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated Sign where
        ann :: forall l. Sign l -> l
    ann Sign l
    sg = case Sign l
    sg of
            Signless l
    l -> l
    l
            Negative l
    l -> l
    l
        amap :: forall l. (l -> l) -> Sign l -> Sign l
    amap = (l -> l) -> Sign l -> Sign l
    forall a b. (a -> b) -> Sign a -> Sign b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated Exp where
        ann :: forall l. Exp l -> l
    ann Exp l
    e = case Exp l
    e of
            Var l
    l QName l
    _                -> l
    l
            OverloadedLabel l
    l String
    _    -> l
    l
            IPVar l
    l IPName l
    _              -> l
    l
            Con l
    l QName l
    _                -> l
    l
            Lit l
    l Literal l
    _                -> l
    l
            InfixApp l
    l Exp l
    _ QOp l
    _ Exp l
    _       -> l
    l
            App l
    l Exp l
    _ Exp l
    _              -> l
    l
            NegApp l
    l Exp l
    _             -> l
    l
            Lambda l
    l [Pat l]
    _ Exp l
    _           -> l
    l
            Let l
    l Binds l
    _ Exp l
    _              -> l
    l
            If l
    l Exp l
    _ Exp l
    _ Exp l
    _             -> l
    l
            MultiIf l
    l [GuardedRhs l]
    _            -> l
    l
            Case l
    l Exp l
    _ [Alt l]
    _             -> l
    l
            Do l
    l [Stmt l]
    _                 -> l
    l
            MDo l
    l [Stmt l]
    _                -> l
    l
            Tuple l
    l Boxed
    _ [Exp l]
    _            -> l
    l
            UnboxedSum l
    l Int
    _ Int
    _ Exp l
    _     -> l
    l
            TupleSection l
    l Boxed
    _ [Maybe (Exp l)]
    _     -> l
    l
            List l
    l [Exp l]
    _               -> l
    l
            ParArray l
    l [Exp l]
    _           -> l
    l
            Paren l
    l Exp l
    _              -> l
    l
            LeftSection l
    l Exp l
    _ QOp l
    _      -> l
    l
            RightSection l
    l QOp l
    _ Exp l
    _     -> l
    l
            RecConstr l
    l QName l
    _ [FieldUpdate l]
    _        -> l
    l
            RecUpdate l
    l Exp l
    _ [FieldUpdate l]
    _        -> l
    l
            EnumFrom l
    l Exp l
    _           -> l
    l
            EnumFromTo l
    l Exp l
    _ Exp l
    _       -> l
    l
            EnumFromThen l
    l Exp l
    _ Exp l
    _     -> l
    l
            EnumFromThenTo l
    l Exp l
    _ Exp l
    _ Exp l
    _ -> l
    l
            ParArrayFromTo l
    l Exp l
    _ Exp l
    _   -> l
    l
            ParArrayFromThenTo l
    l Exp l
    _ Exp l
    _ Exp l
    _ -> l
    l
            ListComp l
    l Exp l
    _ [QualStmt l]
    _         -> l
    l
            ParComp  l
    l Exp l
    _ [[QualStmt l]]
    _         -> l
    l
            ParArrayComp  l
    l Exp l
    _ [[QualStmt l]]
    _    -> l
    l
            ExpTypeSig l
    l Exp l
    _ Type l
    _       -> l
    l
            VarQuote l
    l QName l
    _           -> l
    l
            TypQuote l
    l QName l
    _           -> l
    l
            BracketExp l
    l Bracket l
    _         -> l
    l
            SpliceExp l
    l Splice l
    _          -> l
    l
            QuasiQuote l
    l String
    _ String
    _       -> l
    l
            TypeApp l
    l Type l
    _            -> l
    l

            XTag  l
    l XName l
    _ [XAttr l]
    _ Maybe (Exp l)
    _ [Exp l]
    _        -> l
    l
            XETag l
    l XName l
    _ [XAttr l]
    _ Maybe (Exp l)
    _          -> l
    l
            XPcdata l
    l String
    _            -> l
    l
            XExpTag l
    l Exp l
    _            -> l
    l
            XChildTag l
    l [Exp l]
    _          -> l
    l

            CorePragma l
    l String
    _ Exp l
    _       -> l
    l
            SCCPragma  l
    l String
    _ Exp l
    _       -> l
    l
            GenPragma  l
    l String
    _ (Int, Int)
    _ (Int, Int)
    _ Exp l
    _   -> l
    l

            Proc            l
    l Pat l
    _ Exp l
    _  -> l
    l
            LeftArrApp      l
    l Exp l
    _ Exp l
    _  -> l
    l
            RightArrApp     l
    l Exp l
    _ Exp l
    _  -> l
    l
            LeftArrHighApp  l
    l Exp l
    _ Exp l
    _  -> l
    l
            RightArrHighApp l
    l Exp l
    _ Exp l
    _  -> l
    l
            ArrOp           l
    l Exp l
    _    -> l
    l

            LCase l
    l [Alt l]
    _              -> l
    l

        amap :: forall l. (l -> l) -> Exp l -> Exp l
    amap l -> l
    f Exp l
    e1 = case Exp l
    e1 of
            Var l
    l QName l
    qn        -> l -> QName l -> Exp l
    forall l. l -> QName l -> Exp l
    Var (l -> l
    f l
    l) QName l
    qn
            OverloadedLabel l
    l String
    qn -> l -> String -> Exp l
    forall l. l -> String -> Exp l
    OverloadedLabel (l -> l
    f l
    l) String
    qn
            IPVar l
    l IPName l
    ipn     -> l -> IPName l -> Exp l
    forall l. l -> IPName l -> Exp l
    IPVar (l -> l
    f l
    l) IPName l
    ipn
            Con l
    l QName l
    qn        -> l -> QName l -> Exp l
    forall l. l -> QName l -> Exp l
    Con (l -> l
    f l
    l) QName l
    qn
            Lit l
    l Literal l
    lit       -> l -> Literal l -> Exp l
    forall l. l -> Literal l -> Exp l
    Lit (l -> l
    f l
    l) Literal l
    lit
            InfixApp l
    l Exp l
    e1' QOp l
    qop Exp l
    e2    -> l -> Exp l -> QOp l -> Exp l -> Exp l
    forall l. l -> Exp l -> QOp l -> Exp l -> Exp l
    InfixApp (l -> l
    f l
    l) Exp l
    e1' QOp l
    qop Exp l
    e2
            App l
    l Exp l
    e1' Exp l
    e2    -> l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l
    App (l -> l
    f l
    l) Exp l
    e1' Exp l
    e2
            NegApp l
    l Exp l
    e      -> l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l
    NegApp (l -> l
    f l
    l) Exp l
    e
            Lambda l
    l [Pat l]
    ps Exp l
    e   -> l -> [Pat l] -> Exp l -> Exp l
    forall l. l -> [Pat l] -> Exp l -> Exp l
    Lambda (l -> l
    f l
    l) [Pat l]
    ps Exp l
    e
            Let l
    l Binds l
    bs Exp l
    e      -> l -> Binds l -> Exp l -> Exp l
    forall l. l -> Binds l -> Exp l -> Exp l
    Let (l -> l
    f l
    l) Binds l
    bs Exp l
    e
            If l
    l Exp l
    ec Exp l
    et Exp l
    ee   -> l -> Exp l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l -> Exp l
    If (l -> l
    f l
    l) Exp l
    ec Exp l
    et Exp l
    ee
            Case l
    l Exp l
    e [Alt l]
    alts   -> l -> Exp l -> [Alt l] -> Exp l
    forall l. l -> Exp l -> [Alt l] -> Exp l
    Case (l -> l
    f l
    l) Exp l
    e [Alt l]
    alts
            Do l
    l [Stmt l]
    ss         -> l -> [Stmt l] -> Exp l
    forall l. l -> [Stmt l] -> Exp l
    Do (l -> l
    f l
    l) [Stmt l]
    ss
            MDo l
    l [Stmt l]
    ss        -> l -> [Stmt l] -> Exp l
    forall l. l -> [Stmt l] -> Exp l
    MDo (l -> l
    f l
    l) [Stmt l]
    ss
            Tuple l
    l Boxed
    bx [Exp l]
    es   -> l -> Boxed -> [Exp l] -> Exp l
    forall l. l -> Boxed -> [Exp l] -> Exp l
    Tuple (l -> l
    f l
    l) Boxed
    bx [Exp l]
    es
            UnboxedSum l
    l Int
    b Int
    a Exp l
    es -> l -> Int -> Int -> Exp l -> Exp l
    forall l. l -> Int -> Int -> Exp l -> Exp l
    UnboxedSum (l -> l
    f l
    l) Int
    b Int
    a Exp l
    es
            TupleSection l
    l Boxed
    bx [Maybe (Exp l)]
    mes -> l -> Boxed -> [Maybe (Exp l)] -> Exp l
    forall l. l -> Boxed -> [Maybe (Exp l)] -> Exp l
    TupleSection (l -> l
    f l
    l) Boxed
    bx [Maybe (Exp l)]
    mes
            List l
    l [Exp l]
    es       -> l -> [Exp l] -> Exp l
    forall l. l -> [Exp l] -> Exp l
    List (l -> l
    f l
    l) [Exp l]
    es
            ParArray l
    l [Exp l]
    es   -> l -> [Exp l] -> Exp l
    forall l. l -> [Exp l] -> Exp l
    ParArray (l -> l
    f l
    l) [Exp l]
    es
            Paren l
    l Exp l
    e       -> l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l
    Paren (l -> l
    f l
    l) Exp l
    e
            LeftSection l
    l Exp l
    e QOp l
    qop     -> l -> Exp l -> QOp l -> Exp l
    forall l. l -> Exp l -> QOp l -> Exp l
    LeftSection (l -> l
    f l
    l) Exp l
    e QOp l
    qop
            RightSection l
    l QOp l
    qop Exp l
    e    -> l -> QOp l -> Exp l -> Exp l
    forall l. l -> QOp l -> Exp l -> Exp l
    RightSection (l -> l
    f l
    l) QOp l
    qop Exp l
    e
            RecConstr l
    l QName l
    qn [FieldUpdate l]
    fups     -> l -> QName l -> [FieldUpdate l] -> Exp l
    forall l. l -> QName l -> [FieldUpdate l] -> Exp l
    RecConstr (l -> l
    f l
    l) QName l
    qn [FieldUpdate l]
    fups
            RecUpdate l
    l Exp l
    e  [FieldUpdate l]
    fups     -> l -> Exp l -> [FieldUpdate l] -> Exp l
    forall l. l -> Exp l -> [FieldUpdate l] -> Exp l
    RecUpdate (l -> l
    f l
    l) Exp l
    e  [FieldUpdate l]
    fups
            EnumFrom l
    l Exp l
    e            -> l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l
    EnumFrom (l -> l
    f l
    l) Exp l
    e
            EnumFromTo l
    l Exp l
    ef Exp l
    et      -> l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l
    EnumFromTo (l -> l
    f l
    l) Exp l
    ef Exp l
    et
            EnumFromThen l
    l Exp l
    ef Exp l
    et    -> l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l
    EnumFromThen (l -> l
    f l
    l) Exp l
    ef Exp l
    et
            EnumFromThenTo l
    l Exp l
    ef Exp l
    eth Exp l
    eto -> l -> Exp l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l -> Exp l
    EnumFromThenTo (l -> l
    f l
    l) Exp l
    ef Exp l
    eth Exp l
    eto
            ParArrayFromTo l
    l Exp l
    ef Exp l
    et  -> l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l
    ParArrayFromTo (l -> l
    f l
    l) Exp l
    ef Exp l
    et
            ParArrayFromThenTo l
    l Exp l
    ef Exp l
    eth Exp l
    eto -> l -> Exp l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l -> Exp l
    ParArrayFromThenTo (l -> l
    f l
    l) Exp l
    ef Exp l
    eth Exp l
    eto
            ListComp l
    l Exp l
    e [QualStmt l]
    qss        -> l -> Exp l -> [QualStmt l] -> Exp l
    forall l. l -> Exp l -> [QualStmt l] -> Exp l
    ListComp (l -> l
    f l
    l) Exp l
    e [QualStmt l]
    qss
            ParComp  l
    l Exp l
    e [[QualStmt l]]
    qsss       -> l -> Exp l -> [[QualStmt l]] -> Exp l
    forall l. l -> Exp l -> [[QualStmt l]] -> Exp l
    ParComp  (l -> l
    f l
    l) Exp l
    e [[QualStmt l]]
    qsss
            ParArrayComp  l
    l Exp l
    e [[QualStmt l]]
    qsss  -> l -> Exp l -> [[QualStmt l]] -> Exp l
    forall l. l -> Exp l -> [[QualStmt l]] -> Exp l
    ParArrayComp  (l -> l
    f l
    l) Exp l
    e [[QualStmt l]]
    qsss
            ExpTypeSig l
    l Exp l
    e Type l
    t        -> l -> Exp l -> Type l -> Exp l
    forall l. l -> Exp l -> Type l -> Exp l
    ExpTypeSig (l -> l
    f l
    l) Exp l
    e Type l
    t
            VarQuote l
    l QName l
    qn           -> l -> QName l -> Exp l
    forall l. l -> QName l -> Exp l
    VarQuote (l -> l
    f l
    l) QName l
    qn
            TypQuote l
    l QName l
    qn           -> l -> QName l -> Exp l
    forall l. l -> QName l -> Exp l
    TypQuote (l -> l
    f l
    l) QName l
    qn
            BracketExp l
    l Bracket l
    br         -> l -> Bracket l -> Exp l
    forall l. l -> Bracket l -> Exp l
    BracketExp (l -> l
    f l
    l) Bracket l
    br
            SpliceExp l
    l Splice l
    sp          -> l -> Splice l -> Exp l
    forall l. l -> Splice l -> Exp l
    SpliceExp (l -> l
    f l
    l) Splice l
    sp
            QuasiQuote l
    l String
    sn String
    se      -> l -> String -> String -> Exp l
    forall l. l -> String -> String -> Exp l
    QuasiQuote (l -> l
    f l
    l) String
    sn String
    se
            TypeApp l
    l Type l
    t             -> l -> Type l -> Exp l
    forall l. l -> Type l -> Exp l
    TypeApp (l -> l
    f l
    l) Type l
    t

            XTag  l
    l XName l
    xn [XAttr l]
    xas Maybe (Exp l)
    me [Exp l]
    es     -> l -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Exp l
    forall l.
    l -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Exp l
    XTag  (l -> l
    f l
    l) XName l
    xn [XAttr l]
    xas Maybe (Exp l)
    me [Exp l]
    es
            XETag l
    l XName l
    xn [XAttr l]
    xas Maybe (Exp l)
    me        -> l -> XName l -> [XAttr l] -> Maybe (Exp l) -> Exp l
    forall l. l -> XName l -> [XAttr l] -> Maybe (Exp l) -> Exp l
    XETag (l -> l
    f l
    l) XName l
    xn [XAttr l]
    xas Maybe (Exp l)
    me
            XPcdata l
    l String
    s              -> l -> String -> Exp l
    forall l. l -> String -> Exp l
    XPcdata (l -> l
    f l
    l) String
    s
            XExpTag l
    l Exp l
    e              -> l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l
    XExpTag (l -> l
    f l
    l) Exp l
    e
            XChildTag l
    l [Exp l]
    es           -> l -> [Exp l] -> Exp l
    forall l. l -> [Exp l] -> Exp l
    XChildTag (l -> l
    f l
    l) [Exp l]
    es

            CorePragma l
    l String
    s Exp l
    e   -> l -> String -> Exp l -> Exp l
    forall l. l -> String -> Exp l -> Exp l
    CorePragma (l -> l
    f l
    l) String
    s Exp l
    e
            SCCPragma  l
    l String
    s Exp l
    e   -> l -> String -> Exp l -> Exp l
    forall l. l -> String -> Exp l -> Exp l
    SCCPragma (l -> l
    f l
    l) String
    s Exp l
    e
            GenPragma  l
    l String
    s (Int, Int)
    n12 (Int, Int)
    n34 Exp l
    e -> l -> String -> (Int, Int) -> (Int, Int) -> Exp l -> Exp l
    forall l. l -> String -> (Int, Int) -> (Int, Int) -> Exp l -> Exp l
    GenPragma (l -> l
    f l
    l) String
    s (Int, Int)
    n12 (Int, Int)
    n34 Exp l
    e

            Proc            l
    l Pat l
    p Exp l
    e  -> l -> Pat l -> Exp l -> Exp l
    forall l. l -> Pat l -> Exp l -> Exp l
    Proc (l -> l
    f l
    l) Pat l
    p Exp l
    e
            LeftArrApp      l
    l Exp l
    e1' Exp l
    e2 -> l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l
    LeftArrApp      (l -> l
    f l
    l) Exp l
    e1' Exp l
    e2
            RightArrApp     l
    l Exp l
    e1' Exp l
    e2 -> l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l
    RightArrApp     (l -> l
    f l
    l) Exp l
    e1' Exp l
    e2
            LeftArrHighApp  l
    l Exp l
    e1' Exp l
    e2 -> l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l
    LeftArrHighApp  (l -> l
    f l
    l) Exp l
    e1' Exp l
    e2
            RightArrHighApp l
    l Exp l
    e1' Exp l
    e2 -> l -> Exp l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l -> Exp l
    RightArrHighApp (l -> l
    f l
    l) Exp l
    e1' Exp l
    e2
            ArrOp           l
    l Exp l
    e      -> l -> Exp l -> Exp l
    forall l. l -> Exp l -> Exp l
    ArrOp           (l -> l
    f l
    l) Exp l
    e

            LCase l
    l [Alt l]
    alts -> l -> [Alt l] -> Exp l
    forall l. l -> [Alt l] -> Exp l
    LCase (l -> l
    f l
    l) [Alt l]
    alts
            MultiIf l
    l [GuardedRhs l]
    alts -> l -> [GuardedRhs l] -> Exp l
    forall l. l -> [GuardedRhs l] -> Exp l
    MultiIf (l -> l
    f l
    l) [GuardedRhs l]
    alts

    instance Annotated XName where
        ann :: forall l. XName l -> l
    ann (XName l
    l String
    _)      = l
    l
        ann (XDomName l
    l String
    _ String
    _) = l
    l
        amap :: forall l. (l -> l) -> XName l -> XName l
    amap = (l -> l) -> XName l -> XName l
    forall a b. (a -> b) -> XName a -> XName b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated XAttr where
        ann :: forall l. XAttr l -> l
    ann (XAttr l
    l XName l
    _ Exp l
    _) = l
    l
        amap :: forall l. (l -> l) -> XAttr l -> XAttr l
    amap l -> l
    f (XAttr l
    l XName l
    xn Exp l
    e) = l -> XName l -> Exp l -> XAttr l
    forall l. l -> XName l -> Exp l -> XAttr l
    XAttr (l -> l
    f l
    l) XName l
    xn Exp l
    e

    instance Annotated Bracket where
        ann :: forall l. Bracket l -> l
    ann (ExpBracket l
    l Exp l
    _)  = l
    l
        ann (TExpBracket l
    l Exp l
    _) = l
    l
        ann (PatBracket l
    l Pat l
    _)  = l
    l
        ann (TypeBracket l
    l Type l
    _) = l
    l
        ann (DeclBracket l
    l [Decl l]
    _) = l
    l
        amap :: forall l. (l -> l) -> Bracket l -> Bracket l
    amap l -> l
    f (ExpBracket l
    l Exp l
    e) = l -> Exp l -> Bracket l
    forall l. l -> Exp l -> Bracket l
    ExpBracket (l -> l
    f l
    l) Exp l
    e
        amap l -> l
    f (TExpBracket l
    l Exp l
    e) = l -> Exp l -> Bracket l
    forall l. l -> Exp l -> Bracket l
    TExpBracket (l -> l
    f l
    l) Exp l
    e
        amap l -> l
    f (PatBracket l
    l Pat l
    p) = l -> Pat l -> Bracket l
    forall l. l -> Pat l -> Bracket l
    PatBracket (l -> l
    f l
    l) Pat l
    p
        amap l -> l
    f (TypeBracket l
    l Type l
    t) = l -> Type l -> Bracket l
    forall l. l -> Type l -> Bracket l
    TypeBracket (l -> l
    f l
    l) Type l
    t
        amap l -> l
    f (DeclBracket l
    l [Decl l]
    ds) = l -> [Decl l] -> Bracket l
    forall l. l -> [Decl l] -> Bracket l
    DeclBracket (l -> l
    f l
    l) [Decl l]
    ds

    instance Annotated Splice where
        ann :: forall l. Splice l -> l
    ann (IdSplice l
    l String
    _)    = l
    l
        ann (TIdSplice l
    l String
    _)   = l
    l
        ann (ParenSplice l
    l Exp l
    _) = l
    l
        ann (TParenSplice l
    l Exp l
    _) = l
    l
        amap :: forall l. (l -> l) -> Splice l -> Splice l
    amap l -> l
    f (IdSplice l
    l String
    s) = l -> String -> Splice l
    forall l. l -> String -> Splice l
    IdSplice (l -> l
    f l
    l) String
    s
        amap l -> l
    f (TIdSplice l
    l String
    s) = l -> String -> Splice l
    forall l. l -> String -> Splice l
    TIdSplice (l -> l
    f l
    l) String
    s
        amap l -> l
    f (ParenSplice l
    l Exp l
    e) = l -> Exp l -> Splice l
    forall l. l -> Exp l -> Splice l
    ParenSplice (l -> l
    f l
    l) Exp l
    e
        amap l -> l
    f (TParenSplice l
    l Exp l
    e) = l -> Exp l -> Splice l
    forall l. l -> Exp l -> Splice l
    TParenSplice (l -> l
    f l
    l) Exp l
    e

    instance Annotated Safety where
        ann :: forall l. Safety l -> l
    ann (PlayRisky l
    l) = l
    l
        ann (PlaySafe l
    l Bool
    _) = l
    l
        ann (PlayInterruptible l
    l) = l
    l
        amap :: forall l. (l -> l) -> Safety l -> Safety l
    amap = (l -> l) -> Safety l -> Safety l
    forall a b. (a -> b) -> Safety a -> Safety b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated CallConv where
        ann :: forall l. CallConv l -> l
    ann (StdCall l
    l) = l
    l
        ann (CCall l
    l) = l
    l
        ann (CPlusPlus l
    l) = l
    l
        ann (DotNet l
    l) = l
    l
        ann (Jvm l
    l) = l
    l
        ann (Js l
    l) = l
    l
        ann (JavaScript l
    l) = l
    l
        ann (CApi l
    l) = l
    l
        amap :: forall l. (l -> l) -> CallConv l -> CallConv l
    amap = (l -> l) -> CallConv l -> CallConv l
    forall a b. (a -> b) -> CallConv a -> CallConv b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated ModulePragma where
        ann :: forall l. ModulePragma l -> l
    ann (LanguagePragma   l
    l [Name l]
    _)   = l
    l
        ann (OptionsPragma    l
    l Maybe Tool
    _ String
    _) = l
    l
        ann (AnnModulePragma  l
    l Annotation l
    _)   = l
    l
        amap :: forall l. (l -> l) -> ModulePragma l -> ModulePragma l
    amap l -> l
    f (LanguagePragma   l
    l [Name l]
    ns) = l -> [Name l] -> ModulePragma l
    forall l. l -> [Name l] -> ModulePragma l
    LanguagePragma (l -> l
    f l
    l) [Name l]
    ns
        amap l -> l
    f (AnnModulePragma  l
    l Annotation l
    a) = l -> Annotation l -> ModulePragma l
    forall l. l -> Annotation l -> ModulePragma l
    AnnModulePragma (l -> l
    f l
    l) Annotation l
    a
        amap l -> l
    f ModulePragma l
    p = (l -> l) -> ModulePragma l -> ModulePragma l
    forall a b. (a -> b) -> ModulePragma a -> ModulePragma b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap l -> l
    f ModulePragma l
    p

    instance Annotated Overlap where
        ann :: forall l. Overlap l -> l
    ann (NoOverlap l
    l)  = l
    l
        ann (Overlap l
    l)    = l
    l
        ann (Overlaps l
    l)   = l
    l
        ann (Overlappable l
    l) = l
    l
        ann (Overlapping l
    l)  = l
    l
        ann (Incoherent l
    l) = l
    l
        amap :: forall l. (l -> l) -> Overlap l -> Overlap l
    amap = (l -> l) -> Overlap l -> Overlap l
    forall a b. (a -> b) -> Overlap a -> Overlap b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated Activation where
        ann :: forall l. Activation l -> l
    ann (ActiveFrom   l
    l Int
    _) = l
    l
        ann (ActiveUntil  l
    l Int
    _) = l
    l
        amap :: forall l. (l -> l) -> Activation l -> Activation l
    amap = (l -> l) -> Activation l -> Activation l
    forall a b. (a -> b) -> Activation a -> Activation b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated Rule where
        ann :: forall l. Rule l -> l
    ann (Rule l
    l String
    _ Maybe (Activation l)
    _ Maybe [RuleVar l]
    _ Exp l
    _ Exp l
    _) = l
    l
        amap :: forall l. (l -> l) -> Rule l -> Rule l
    amap l -> l
    f (Rule l
    l String
    s Maybe (Activation l)
    act Maybe [RuleVar l]
    mrvs Exp l
    e1 Exp l
    e2) = l
    -> String
    -> Maybe (Activation l)
    -> Maybe [RuleVar l]
    -> Exp l
    -> Exp l
    -> Rule l
    forall l.
    l
    -> String
    -> Maybe (Activation l)
    -> Maybe [RuleVar l]
    -> Exp l
    -> Exp l
    -> Rule l
    Rule (l -> l
    f l
    l) String
    s Maybe (Activation l)
    act Maybe [RuleVar l]
    mrvs Exp l
    e1 Exp l
    e2

    instance Annotated RuleVar where
        ann :: forall l. RuleVar l -> l
    ann (RuleVar l
    l Name l
    _)        = l
    l
        ann (TypedRuleVar l
    l Name l
    _ Type l
    _) = l
    l
        amap :: forall l. (l -> l) -> RuleVar l -> RuleVar l
    amap l -> l
    f (RuleVar l
    l Name l
    n) = l -> Name l -> RuleVar l
    forall l. l -> Name l -> RuleVar l
    RuleVar (l -> l
    f l
    l) Name l
    n
        amap l -> l
    f (TypedRuleVar l
    l Name l
    n Type l
    t) = l -> Name l -> Type l -> RuleVar l
    forall l. l -> Name l -> Type l -> RuleVar l
    TypedRuleVar (l -> l
    f l
    l) Name l
    n Type l
    t

    instance Annotated WarningText where
        ann :: forall l. WarningText l -> l
    ann (DeprText l
    l String
    _) = l
    l
        ann (WarnText l
    l String
    _) = l
    l
        amap :: forall l. (l -> l) -> WarningText l -> WarningText l
    amap = (l -> l) -> WarningText l -> WarningText l
    forall a b. (a -> b) -> WarningText a -> WarningText b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated Pat where
        ann :: forall l. Pat l -> l
    ann Pat l
    p = case Pat l
    p of
          PVar l
    l Name l
    _          -> l
    l
          PLit l
    l Sign l
    _ Literal l
    _        -> l
    l
          PNPlusK l
    l Name l
    _ Integer
    _     -> l
    l
          PInfixApp l
    l Pat l
    _ QName l
    _ Pat l
    _ -> l
    l
          PApp l
    l QName l
    _ [Pat l]
    _        -> l
    l
          PTuple l
    l Boxed
    _ [Pat l]
    _      -> l
    l
          PUnboxedSum l
    l Int
    _ Int
    _ Pat l
    _ -> l
    l
          PList l
    l [Pat l]
    _         -> l
    l
          PParen l
    l Pat l
    _        -> l
    l
          PRec l
    l QName l
    _ [PatField l]
    _        -> l
    l
          PAsPat l
    l Name l
    _ Pat l
    _      -> l
    l
          PWildCard l
    l       -> l
    l
          PIrrPat l
    l Pat l
    _       -> l
    l
          PatTypeSig l
    l Pat l
    _ Type l
    _  -> l
    l
          PViewPat l
    l Exp l
    _ Pat l
    _    -> l
    l
          PRPat l
    l [RPat l]
    _         -> l
    l
          PXTag l
    l XName l
    _ [PXAttr l]
    _ Maybe (Pat l)
    _ [Pat l]
    _   -> l
    l
          PXETag l
    l XName l
    _ [PXAttr l]
    _ Maybe (Pat l)
    _    -> l
    l
          PXPcdata l
    l String
    _      -> l
    l
          PXPatTag l
    l Pat l
    _      -> l
    l
          PXRPats  l
    l [RPat l]
    _      -> l
    l
          PSplice l
    l Splice l
    _       -> l
    l
          PQuasiQuote l
    l String
    _ String
    _ -> l
    l
          PBangPat l
    l Pat l
    _      -> l
    l
        amap :: forall l. (l -> l) -> Pat l -> Pat l
    amap l -> l
    f Pat l
    p1 = case Pat l
    p1 of
          PVar l
    l Name l
    n          -> l -> Name l -> Pat l
    forall l. l -> Name l -> Pat l
    PVar (l -> l
    f l
    l) Name l
    n
          PLit l
    l Sign l
    sg Literal l
    lit     -> l -> Sign l -> Literal l -> Pat l
    forall l. l -> Sign l -> Literal l -> Pat l
    PLit (l -> l
    f l
    l) Sign l
    sg Literal l
    lit
          PNPlusK l
    l Name l
    n Integer
    k     -> l -> Name l -> Integer -> Pat l
    forall l. l -> Name l -> Integer -> Pat l
    PNPlusK (l -> l
    f l
    l) Name l
    n Integer
    k
          PInfixApp l
    l Pat l
    pa QName l
    qn Pat l
    pb  -> l -> Pat l -> QName l -> Pat l -> Pat l
    forall l. l -> Pat l -> QName l -> Pat l -> Pat l
    PInfixApp (l -> l
    f l
    l) Pat l
    pa QName l
    qn Pat l
    pb
          PApp l
    l QName l
    qn [Pat l]
    ps      -> l -> QName l -> [Pat l] -> Pat l
    forall l. l -> QName l -> [Pat l] -> Pat l
    PApp (l -> l
    f l
    l) QName l
    qn [Pat l]
    ps
          PTuple l
    l Boxed
    bx [Pat l]
    ps    -> l -> Boxed -> [Pat l] -> Pat l
    forall l. l -> Boxed -> [Pat l] -> Pat l
    PTuple (l -> l
    f l
    l) Boxed
    bx [Pat l]
    ps
          PUnboxedSum l
    l Int
    b Int
    a Pat l
    ps -> l -> Int -> Int -> Pat l -> Pat l
    forall l. l -> Int -> Int -> Pat l -> Pat l
    PUnboxedSum (l -> l
    f l
    l) Int
    b Int
    a Pat l
    ps
          PList l
    l [Pat l]
    ps        -> l -> [Pat l] -> Pat l
    forall l. l -> [Pat l] -> Pat l
    PList (l -> l
    f l
    l) [Pat l]
    ps
          PParen l
    l Pat l
    p        -> l -> Pat l -> Pat l
    forall l. l -> Pat l -> Pat l
    PParen (l -> l
    f l
    l) Pat l
    p
          PRec l
    l QName l
    qn [PatField l]
    pfs     -> l -> QName l -> [PatField l] -> Pat l
    forall l. l -> QName l -> [PatField l] -> Pat l
    PRec (l -> l
    f l
    l) QName l
    qn [PatField l]
    pfs
          PAsPat l
    l Name l
    n Pat l
    p      -> l -> Name l -> Pat l -> Pat l
    forall l. l -> Name l -> Pat l -> Pat l
    PAsPat (l -> l
    f l
    l) Name l
    n Pat l
    p
          PWildCard l
    l       -> l -> Pat l
    forall l. l -> Pat l
    PWildCard (l -> l
    f l
    l)
          PIrrPat l
    l Pat l
    p       -> l -> Pat l -> Pat l
    forall l. l -> Pat l -> Pat l
    PIrrPat (l -> l
    f l
    l) Pat l
    p
          PatTypeSig l
    l Pat l
    p Type l
    t  -> l -> Pat l -> Type l -> Pat l
    forall l. l -> Pat l -> Type l -> Pat l
    PatTypeSig (l -> l
    f l
    l) Pat l
    p Type l
    t
          PViewPat l
    l Exp l
    e Pat l
    p    -> l -> Exp l -> Pat l -> Pat l
    forall l. l -> Exp l -> Pat l -> Pat l
    PViewPat (l -> l
    f l
    l) Exp l
    e Pat l
    p
          PRPat l
    l [RPat l]
    rps       -> l -> [RPat l] -> Pat l
    forall l. l -> [RPat l] -> Pat l
    PRPat (l -> l
    f l
    l) [RPat l]
    rps
          PXTag l
    l XName l
    xn [PXAttr l]
    pxas Maybe (Pat l)
    mp [Pat l]
    ps -> l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> [Pat l] -> Pat l
    forall l.
    l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> [Pat l] -> Pat l
    PXTag  (l -> l
    f l
    l) XName l
    xn [PXAttr l]
    pxas Maybe (Pat l)
    mp [Pat l]
    ps
          PXETag l
    l XName l
    xn [PXAttr l]
    pxas Maybe (Pat l)
    mp   -> l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> Pat l
    forall l. l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> Pat l
    PXETag (l -> l
    f l
    l) XName l
    xn [PXAttr l]
    pxas Maybe (Pat l)
    mp
          PXPcdata l
    l String
    s      -> l -> String -> Pat l
    forall l. l -> String -> Pat l
    PXPcdata (l -> l
    f l
    l) String
    s
          PXPatTag l
    l Pat l
    p      -> l -> Pat l -> Pat l
    forall l. l -> Pat l -> Pat l
    PXPatTag (l -> l
    f l
    l) Pat l
    p
          PXRPats  l
    l [RPat l]
    rps    -> l -> [RPat l] -> Pat l
    forall l. l -> [RPat l] -> Pat l
    PXRPats  (l -> l
    f l
    l) [RPat l]
    rps
          PSplice l
    l Splice l
    sp      -> l -> Splice l -> Pat l
    forall l. l -> Splice l -> Pat l
    PSplice (l -> l
    f l
    l) Splice l
    sp
          PQuasiQuote l
    l String
    sn String
    st   -> l -> String -> String -> Pat l
    forall l. l -> String -> String -> Pat l
    PQuasiQuote (l -> l
    f l
    l) String
    sn String
    st
          PBangPat l
    l Pat l
    p          -> l -> Pat l -> Pat l
    forall l. l -> Pat l -> Pat l
    PBangPat (l -> l
    f l
    l) Pat l
    p

    instance Annotated PXAttr where
        ann :: forall l. PXAttr l -> l
    ann (PXAttr l
    l XName l
    _ Pat l
    _) = l
    l
        amap :: forall l. (l -> l) -> PXAttr l -> PXAttr l
    amap l -> l
    f (PXAttr l
    l XName l
    xn Pat l
    p) = l -> XName l -> Pat l -> PXAttr l
    forall l. l -> XName l -> Pat l -> PXAttr l
    PXAttr (l -> l
    f l
    l) XName l
    xn Pat l
    p

    instance Annotated RPatOp where
        ann :: forall l. RPatOp l -> l
    ann (RPStar  l
    l) = l
    l
        ann (RPStarG l
    l) = l
    l
        ann (RPPlus  l
    l) = l
    l
        ann (RPPlusG l
    l) = l
    l
        ann (RPOpt   l
    l) = l
    l
        ann (RPOptG  l
    l) = l
    l
        amap :: forall l. (l -> l) -> RPatOp l -> RPatOp l
    amap = (l -> l) -> RPatOp l -> RPatOp l
    forall a b. (a -> b) -> RPatOp a -> RPatOp b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap

    instance Annotated RPat where
        ann :: forall l. RPat l -> l
    ann RPat l
    rp = case RPat l
    rp of
          RPOp l
    l RPat l
    _ RPatOp l
    _            -> l
    l
          RPEither l
    l RPat l
    _ RPat l
    _        -> l
    l
          RPSeq l
    l [RPat l]
    _             -> l
    l
          RPGuard l
    l Pat l
    _ [Stmt l]
    _         -> l
    l
          RPCAs l
    l Name l
    _ RPat l
    _           -> l
    l
          RPAs l
    l Name l
    _ RPat l
    _            -> l
    l
          RPParen l
    l RPat l
    _           -> l
    l
          RPPat l
    l Pat l
    _             -> l
    l
        amap :: forall l. (l -> l) -> RPat l -> RPat l
    amap l -> l
    f RPat l
    rp1 = case RPat l
    rp1 of
          RPOp l
    l RPat l
    rp RPatOp l
    rop         -> l -> RPat l -> RPatOp l -> RPat l
    forall l. l -> RPat l -> RPatOp l -> RPat l
    RPOp (l -> l
    f l
    l) RPat l
    rp RPatOp l
    rop
          RPEither l
    l RPat l
    rp1' RPat l
    rp2   -> l -> RPat l -> RPat l -> RPat l
    forall l. l -> RPat l -> RPat l -> RPat l
    RPEither (l -> l
    f l
    l) RPat l
    rp1' RPat l
    rp2
          RPSeq l
    l [RPat l]
    rps           -> l -> [RPat l] -> RPat l
    forall l. l -> [RPat l] -> RPat l
    RPSeq (l -> l
    f l
    l) [RPat l]
    rps
          RPGuard l
    l Pat l
    p [Stmt l]
    ss        -> l -> Pat l -> [Stmt l] -> RPat l
    forall l. l -> Pat l -> [Stmt l] -> RPat l
    RPGuard (l -> l
    f l
    l) Pat l
    p [Stmt l]
    ss
          RPCAs l
    l Name l
    n RPat l
    rp          -> l -> Name l -> RPat l -> RPat l
    forall l. l -> Name l -> RPat l -> RPat l
    RPCAs (l -> l
    f l
    l) Name l
    n RPat l
    rp
          RPAs l
    l Name l
    n RPat l
    rp           -> l -> Name l -> RPat l -> RPat l
    forall l. l -> Name l -> RPat l -> RPat l
    RPAs (l -> l
    f l
    l) Name l
    n RPat l
    rp
          RPParen l
    l RPat l
    rp          -> l -> RPat l -> RPat l
    forall l. l -> RPat l -> RPat l
    RPParen (l -> l
    f l
    l) RPat l
    rp
          RPPat l
    l Pat l
    p             -> l -> Pat l -> RPat l
    forall l. l -> Pat l -> RPat l
    RPPat (l -> l
    f l
    l) Pat l
    p

    instance Annotated PatField where
        ann :: forall l. PatField l -> l
    ann (PFieldPat l
    l QName l
    _ Pat l
    _)  = l
    l
        ann (PFieldPun l
    l QName l
    _)    = l
    l
        ann (PFieldWildcard l
    l) = l
    l
        amap :: forall l. (l -> l) -> PatField l -> PatField l
    amap l -> l
    f (PFieldPat l
    l QName l
    qn Pat l
    p) = l -> QName l -> Pat l -> PatField l
    forall l. l -> QName l -> Pat l -> PatField l
    PFieldPat (l -> l
    f l
    l) QName l
    qn Pat l
    p
        amap l -> l
    f (PFieldPun l
    l QName l
    n) = l -> QName l -> PatField l
    forall l. l -> QName l -> PatField l
    PFieldPun (l -> l
    f l
    l) QName l
    n
        amap l -> l
    f (PFieldWildcard l
    l) = l -> PatField l
    forall l. l -> PatField l
    PFieldWildcard (l -> l
    f l
    l)

    instance Annotated Stmt where
        ann :: forall l. Stmt l -> l
    ann (Generator l
    l Pat l
    _ Exp l
    _) = l
    l
        ann (Qualifier l
    l Exp l
    _)   = l
    l
        ann (LetStmt l
    l Binds l
    _)     = l
    l
        ann (RecStmt l
    l [Stmt l]
    _)     = l
    l
        amap :: forall l. (l -> l) -> Stmt l -> Stmt l
    amap l -> l
    f (Generator l
    l Pat l
    p Exp l
    e) = l -> Pat l -> Exp l -> Stmt l
    forall l. l -> Pat l -> Exp l -> Stmt l
    Generator (l -> l
    f l
    l) Pat l
    p Exp l
    e
        amap l -> l
    f (Qualifier l
    l Exp l
    e)   = l -> Exp l -> Stmt l
    forall l. l -> Exp l -> Stmt l
    Qualifier (l -> l
    f l
    l) Exp l
    e
        amap l -> l
    f (LetStmt l
    l Binds l
    bs)    = l -> Binds l -> Stmt l
    forall l. l -> Binds l -> Stmt l
    LetStmt (l -> l
    f l
    l) Binds l
    bs
        amap l -> l
    f (RecStmt l
    l [Stmt l]
    ss)    = l -> [Stmt l] -> Stmt l
    forall l. l -> [Stmt l] -> Stmt l
    RecStmt (l -> l
    f l
    l) [Stmt l]
    ss

    instance Annotated QualStmt where
        ann :: forall l. QualStmt l -> l
    ann (QualStmt     l
    l Stmt l
    _)   = l
    l
        ann (ThenTrans    l
    l Exp l
    _)   = l
    l
        ann (ThenBy       l
    l Exp l
    _ Exp l
    _) = l
    l
        ann (GroupBy      l
    l Exp l
    _)   = l
    l
        ann (GroupUsing   l
    l Exp l
    _)   = l
    l
        ann (GroupByUsing l
    l Exp l
    _ Exp l
    _) = l
    l
        amap :: forall l. (l -> l) -> QualStmt l -> QualStmt l
    amap l -> l
    f (QualStmt     l
    l Stmt l
    s) = l -> Stmt l -> QualStmt l
    forall l. l -> Stmt l -> QualStmt l
    QualStmt (l -> l
    f l
    l) Stmt l
    s
        amap l -> l
    f (ThenTrans    l
    l Exp l
    e) = l -> Exp l -> QualStmt l
    forall l. l -> Exp l -> QualStmt l
    ThenTrans (l -> l
    f l
    l) Exp l
    e
        amap l -> l
    f (ThenBy       l
    l Exp l
    e1 Exp l
    e2) = l -> Exp l -> Exp l -> QualStmt l
    forall l. l -> Exp l -> Exp l -> QualStmt l
    ThenBy (l -> l
    f l
    l) Exp l
    e1 Exp l
    e2
        amap l -> l
    f (GroupBy      l
    l Exp l
    e) = l -> Exp l -> QualStmt l
    forall l. l -> Exp l -> QualStmt l
    GroupBy (l -> l
    f l
    l) Exp l
    e
        amap l -> l
    f (GroupUsing   l
    l Exp l
    e) = l -> Exp l -> QualStmt l
    forall l. l -> Exp l -> QualStmt l
    GroupUsing (l -> l
    f l
    l) Exp l
    e
        amap l -> l
    f (GroupByUsing l
    l Exp l
    e1 Exp l
    e2) = l -> Exp l -> Exp l -> QualStmt l
    forall l. l -> Exp l -> Exp l -> QualStmt l
    GroupByUsing (l -> l
    f l
    l) Exp l
    e1 Exp l
    e2

    instance Annotated FieldUpdate where
        ann :: forall l. FieldUpdate l -> l
    ann (FieldUpdate l
    l QName l
    _ Exp l
    _)  = l
    l
        ann (FieldPun l
    l QName l
    _)       = l
    l
        ann (FieldWildcard l
    l)    = l
    l
        amap :: forall l. (l -> l) -> FieldUpdate l -> FieldUpdate l
    amap l -> l
    f (FieldUpdate l
    l QName l
    qn Exp l
    e) = l -> QName l -> Exp l -> FieldUpdate l
    forall l. l -> QName l -> Exp l -> FieldUpdate l
    FieldUpdate (l -> l
    f l
    l) QName l
    qn Exp l
    e
        amap l -> l
    f (FieldPun l
    l QName l
    n)       = l -> QName l -> FieldUpdate l
    forall l. l -> QName l -> FieldUpdate l
    FieldPun (l -> l
    f l
    l) QName l
    n
        amap l -> l
    f (FieldWildcard l
    l)    = l -> FieldUpdate l
    forall l. l -> FieldUpdate l
    FieldWildcard (l -> l
    f l
    l)

    instance Annotated Alt where
        ann :: forall l. Alt l -> l
    ann (Alt l
    l Pat l
    _ Rhs l
    _ Maybe (Binds l)
    _) = l
    l
        amap :: forall l. (l -> l) -> Alt l -> Alt l
    amap l -> l
    f (Alt l
    l Pat l
    p Rhs l
    gs Maybe (Binds l)
    bs) = l -> Pat l -> Rhs l -> Maybe (Binds l) -> Alt l
    forall l. l -> Pat l -> Rhs l -> Maybe (Binds l) -> Alt l
    Alt (l -> l
    f l
    l) Pat l
    p Rhs l
    gs Maybe (Binds l)
    bs

    instance Annotated Promoted where
        ann :: forall l. Promoted l -> l
    ann (PromotedInteger l
    l Integer
    _ String
    _) = l
    l
        ann (PromotedString l
    l String
    _ String
    _)  = l
    l
        ann (PromotedCon l
    l Bool
    _ QName l
    _)     = l
    l
        ann (PromotedList l
    l Bool
    _ [Type l]
    _)    = l
    l
        ann (PromotedTuple l
    l [Type l]
    _)     = l
    l
        ann (PromotedUnit l
    l)        = l
    l
        amap :: forall l. (l -> l) -> Promoted l -> Promoted l
    amap l -> l
    f (PromotedInteger l
    l Integer
    int String
    raw) = l -> Integer -> String -> Promoted l
    forall l. l -> Integer -> String -> Promoted l
    PromotedInteger (l -> l
    f l
    l) Integer
    int String
    raw
        amap l -> l
    f (PromotedString l
    l String
    str String
    raw) = l -> String -> String -> Promoted l
    forall l. l -> String -> String -> Promoted l
    PromotedString (l -> l
    f l
    l) String
    str String
    raw
        amap l -> l
    f (PromotedCon l
    l Bool
    b QName l
    qn)   = l -> Bool -> QName l -> Promoted l
    forall l. l -> Bool -> QName l -> Promoted l
    PromotedCon (l -> l
    f l
    l) Bool
    b QName l
    qn
        amap l -> l
    f (PromotedList l
    l Bool
    b [Type l]
    ps)  = l -> Bool -> [Type l] -> Promoted l
    forall l. l -> Bool -> [Type l] -> Promoted l
    PromotedList  (l -> l
    f l
    l) Bool
    b [Type l]
    ps
        amap l -> l
    f (PromotedTuple l
    l [Type l]
    ps) = l -> [Type l] -> Promoted l
    forall l. l -> [Type l] -> Promoted l
    PromotedTuple (l -> l
    f l
    l) [Type l]
    ps
        amap l -> l
    f (PromotedUnit l
    l)     = l -> Promoted l
    forall l. l -> Promoted l
    PromotedUnit (l -> l
    f l
    l)