    {-| An info object contains additional information about a piece of abstract
        syntax that isn't part of the actual syntax. For instance, it might contain
        the source code position of an expression or the concrete syntax that
        an internal expression originates from.
    -}

    module Agda.Syntax.Info where

    import Prelude hiding (null)

    import Control.DeepSeq

    import Data.Data (Data)
    import Data.Semigroup (Semigroup)

    import GHC.Generics (Generic)

    import qualified Agda.Syntax.Concrete.Name as C
    import Agda.Syntax.Common
    import Agda.Syntax.Position
    import Agda.Syntax.Concrete
    import Agda.Syntax.Fixity
    import Agda.Syntax.Scope.Base (ScopeInfo, emptyScopeInfo)

    import Agda.Utils.Functor
    import Agda.Utils.Null

    {--------------------------------------------------------------------------
        Meta information
     --------------------------------------------------------------------------}

    data MetaInfo = MetaInfo
      { MetaInfo -> Range
    metaRange          :: Range
      , MetaInfo -> ScopeInfo
    metaScope          :: ScopeInfo
      , MetaInfo -> Maybe MetaId
    metaNumber         :: Maybe MetaId
      , MetaInfo -> String
    metaNameSuggestion :: String
      }
      deriving (Typeable MetaInfo
    Typeable MetaInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> MetaInfo -> c MetaInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c MetaInfo)
    -> (MetaInfo -> Constr)
    -> (MetaInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c MetaInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaInfo))
    -> ((forall b. Data b => b -> b) -> MetaInfo -> MetaInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> MetaInfo -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> MetaInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo)
    -> Data MetaInfo
    MetaInfo -> DataType
    MetaInfo -> Constr
    (forall b. Data b => b -> b) -> MetaInfo -> MetaInfo
    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) -> MetaInfo -> u
    forall u. (forall d. Data d => d -> u) -> MetaInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MetaInfo -> c MetaInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MetaInfo -> m MetaInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MetaInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MetaInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> MetaInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> MetaInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> MetaInfo -> MetaInfo
    $cgmapT :: (forall b. Data b => b -> b) -> MetaInfo -> MetaInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaInfo)
    dataTypeOf :: MetaInfo -> DataType
    $cdataTypeOf :: MetaInfo -> DataType
    toConstr :: MetaInfo -> Constr
    $ctoConstr :: MetaInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MetaInfo -> c MetaInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MetaInfo -> c MetaInfo
    Data, Int -> MetaInfo -> ShowS
    [MetaInfo] -> ShowS
    MetaInfo -> String
    (Int -> MetaInfo -> ShowS)
    -> (MetaInfo -> String) -> ([MetaInfo] -> ShowS) -> Show MetaInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [MetaInfo] -> ShowS
    $cshowList :: [MetaInfo] -> ShowS
    show :: MetaInfo -> String
    $cshow :: MetaInfo -> String
    showsPrec :: Int -> MetaInfo -> ShowS
    $cshowsPrec :: Int -> MetaInfo -> ShowS
    Show, MetaInfo -> MetaInfo -> Bool
    (MetaInfo -> MetaInfo -> Bool)
    -> (MetaInfo -> MetaInfo -> Bool) -> Eq MetaInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: MetaInfo -> MetaInfo -> Bool
    $c/= :: MetaInfo -> MetaInfo -> Bool
    == :: MetaInfo -> MetaInfo -> Bool
    $c== :: MetaInfo -> MetaInfo -> Bool
    Eq, (forall x. MetaInfo -> Rep MetaInfo x)
    -> (forall x. Rep MetaInfo x -> MetaInfo) -> Generic MetaInfo
    forall x. Rep MetaInfo x -> MetaInfo
    forall x. MetaInfo -> Rep MetaInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep MetaInfo x -> MetaInfo
    $cfrom :: forall x. MetaInfo -> Rep MetaInfo x
    Generic)

    emptyMetaInfo :: MetaInfo
    emptyMetaInfo :: MetaInfo
    emptyMetaInfo = MetaInfo :: Range -> ScopeInfo -> Maybe MetaId -> String -> MetaInfo
    MetaInfo
      { metaRange :: Range
    metaRange          = Range
    forall a. Range' a
    noRange
      , metaScope :: ScopeInfo
    metaScope          = ScopeInfo
    emptyScopeInfo
      , metaNumber :: Maybe MetaId
    metaNumber         = Maybe MetaId
    forall a. Maybe a
    Nothing
      , metaNameSuggestion :: String
    metaNameSuggestion = String
    ""
      }

    instance HasRange MetaInfo where
      getRange :: MetaInfo -> Range
    getRange = MetaInfo -> Range
    metaRange

    instance KillRange MetaInfo where
      killRange :: MetaInfo -> MetaInfo
    killRange MetaInfo
    m = MetaInfo
    m { metaRange :: Range
    metaRange = Range
    forall a. Range' a
    noRange }

    instance NFData MetaInfo

    {--------------------------------------------------------------------------
        General expression information
     --------------------------------------------------------------------------}

    newtype ExprInfo = ExprRange Range
      deriving (Typeable ExprInfo
    Typeable ExprInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ExprInfo -> c ExprInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ExprInfo)
    -> (ExprInfo -> Constr)
    -> (ExprInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ExprInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExprInfo))
    -> ((forall b. Data b => b -> b) -> ExprInfo -> ExprInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ExprInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ExprInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ExprInfo -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> ExprInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo)
    -> Data ExprInfo
    ExprInfo -> DataType
    ExprInfo -> Constr
    (forall b. Data b => b -> b) -> ExprInfo -> ExprInfo
    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) -> ExprInfo -> u
    forall u. (forall d. Data d => d -> u) -> ExprInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExprInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExprInfo -> c ExprInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExprInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExprInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExprInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExprInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ExprInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExprInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> ExprInfo -> ExprInfo
    $cgmapT :: (forall b. Data b => b -> b) -> ExprInfo -> ExprInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExprInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExprInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExprInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExprInfo)
    dataTypeOf :: ExprInfo -> DataType
    $cdataTypeOf :: ExprInfo -> DataType
    toConstr :: ExprInfo -> Constr
    $ctoConstr :: ExprInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExprInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExprInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExprInfo -> c ExprInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExprInfo -> c ExprInfo
    Data, Int -> ExprInfo -> ShowS
    [ExprInfo] -> ShowS
    ExprInfo -> String
    (Int -> ExprInfo -> ShowS)
    -> (ExprInfo -> String) -> ([ExprInfo] -> ShowS) -> Show ExprInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ExprInfo] -> ShowS
    $cshowList :: [ExprInfo] -> ShowS
    show :: ExprInfo -> String
    $cshow :: ExprInfo -> String
    showsPrec :: Int -> ExprInfo -> ShowS
    $cshowsPrec :: Int -> ExprInfo -> ShowS
    Show, ExprInfo -> ExprInfo -> Bool
    (ExprInfo -> ExprInfo -> Bool)
    -> (ExprInfo -> ExprInfo -> Bool) -> Eq ExprInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ExprInfo -> ExprInfo -> Bool
    $c/= :: ExprInfo -> ExprInfo -> Bool
    == :: ExprInfo -> ExprInfo -> Bool
    $c== :: ExprInfo -> ExprInfo -> Bool
    Eq, ExprInfo
    ExprInfo -> Bool
    ExprInfo -> (ExprInfo -> Bool) -> Null ExprInfo
    forall a. a -> (a -> Bool) -> Null a
    null :: ExprInfo -> Bool
    $cnull :: ExprInfo -> Bool
    empty :: ExprInfo
    $cempty :: ExprInfo
    Null, ExprInfo -> ()
    (ExprInfo -> ()) -> NFData ExprInfo
    forall a. (a -> ()) -> NFData a
    rnf :: ExprInfo -> ()
    $crnf :: ExprInfo -> ()
    NFData)

    exprNoRange :: ExprInfo
    exprNoRange :: ExprInfo
    exprNoRange = Range -> ExprInfo
    ExprRange Range
    forall a. Range' a
    noRange

    instance HasRange ExprInfo where
      getRange :: ExprInfo -> Range
    getRange (ExprRange Range
    r) = Range
    r

    instance KillRange ExprInfo where
      killRange :: ExprInfo -> ExprInfo
    killRange (ExprRange Range
    r) = ExprInfo
    exprNoRange

    {--------------------------------------------------------------------------
        Application information
     --------------------------------------------------------------------------}

    -- | Information about application
    data AppInfo = AppInfo
      { AppInfo -> Range
    appRange  :: Range
      , AppInfo -> Origin
    appOrigin :: Origin
      , AppInfo -> ParenPreference
    appParens :: ParenPreference -- ^ Do we prefer a lambda argument with or without parens?
      }
      deriving (Typeable AppInfo
    Typeable AppInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> AppInfo -> c AppInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AppInfo)
    -> (AppInfo -> Constr)
    -> (AppInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AppInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AppInfo))
    -> ((forall b. Data b => b -> b) -> AppInfo -> AppInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AppInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AppInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AppInfo -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> AppInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo)
    -> Data AppInfo
    AppInfo -> DataType
    AppInfo -> Constr
    (forall b. Data b => b -> b) -> AppInfo -> AppInfo
    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) -> AppInfo -> u
    forall u. (forall d. Data d => d -> u) -> AppInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AppInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AppInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AppInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AppInfo -> c AppInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AppInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AppInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AppInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AppInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AppInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AppInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AppInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AppInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AppInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AppInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> AppInfo -> AppInfo
    $cgmapT :: (forall b. Data b => b -> b) -> AppInfo -> AppInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AppInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AppInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AppInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AppInfo)
    dataTypeOf :: AppInfo -> DataType
    $cdataTypeOf :: AppInfo -> DataType
    toConstr :: AppInfo -> Constr
    $ctoConstr :: AppInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AppInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AppInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AppInfo -> c AppInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AppInfo -> c AppInfo
    Data, Int -> AppInfo -> ShowS
    [AppInfo] -> ShowS
    AppInfo -> String
    (Int -> AppInfo -> ShowS)
    -> (AppInfo -> String) -> ([AppInfo] -> ShowS) -> Show AppInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [AppInfo] -> ShowS
    $cshowList :: [AppInfo] -> ShowS
    show :: AppInfo -> String
    $cshow :: AppInfo -> String
    showsPrec :: Int -> AppInfo -> ShowS
    $cshowsPrec :: Int -> AppInfo -> ShowS
    Show, AppInfo -> AppInfo -> Bool
    (AppInfo -> AppInfo -> Bool)
    -> (AppInfo -> AppInfo -> Bool) -> Eq AppInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AppInfo -> AppInfo -> Bool
    $c/= :: AppInfo -> AppInfo -> Bool
    == :: AppInfo -> AppInfo -> Bool
    $c== :: AppInfo -> AppInfo -> Bool
    Eq, Eq AppInfo
    Eq AppInfo
    -> (AppInfo -> AppInfo -> Ordering)
    -> (AppInfo -> AppInfo -> Bool)
    -> (AppInfo -> AppInfo -> Bool)
    -> (AppInfo -> AppInfo -> Bool)
    -> (AppInfo -> AppInfo -> Bool)
    -> (AppInfo -> AppInfo -> AppInfo)
    -> (AppInfo -> AppInfo -> AppInfo)
    -> Ord AppInfo
    AppInfo -> AppInfo -> Bool
    AppInfo -> AppInfo -> Ordering
    AppInfo -> AppInfo -> AppInfo
    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
    min :: AppInfo -> AppInfo -> AppInfo
    $cmin :: AppInfo -> AppInfo -> AppInfo
    max :: AppInfo -> AppInfo -> AppInfo
    $cmax :: AppInfo -> AppInfo -> AppInfo
    >= :: AppInfo -> AppInfo -> Bool
    $c>= :: AppInfo -> AppInfo -> Bool
    > :: AppInfo -> AppInfo -> Bool
    $c> :: AppInfo -> AppInfo -> Bool
    <= :: AppInfo -> AppInfo -> Bool
    $c<= :: AppInfo -> AppInfo -> Bool
    < :: AppInfo -> AppInfo -> Bool
    $c< :: AppInfo -> AppInfo -> Bool
    compare :: AppInfo -> AppInfo -> Ordering
    $ccompare :: AppInfo -> AppInfo -> Ordering
    Ord, (forall x. AppInfo -> Rep AppInfo x)
    -> (forall x. Rep AppInfo x -> AppInfo) -> Generic AppInfo
    forall x. Rep AppInfo x -> AppInfo
    forall x. AppInfo -> Rep AppInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AppInfo x -> AppInfo
    $cfrom :: forall x. AppInfo -> Rep AppInfo x
    Generic)

    -- | Default is system inserted and prefer parens.
    defaultAppInfo :: Range -> AppInfo
    defaultAppInfo :: Range -> AppInfo
    defaultAppInfo Range
    r = AppInfo :: Range -> Origin -> ParenPreference -> AppInfo
    AppInfo{ appRange :: Range
    appRange = Range
    r, appOrigin :: Origin
    appOrigin = Origin
    Inserted, appParens :: ParenPreference
    appParens = ParenPreference
    PreferParen }

    -- | `AppInfo` with no range information.
    defaultAppInfo_ :: AppInfo
    defaultAppInfo_ :: AppInfo
    defaultAppInfo_ = Range -> AppInfo
    defaultAppInfo Range
    forall a. Range' a
    noRange

    instance HasRange AppInfo where
      getRange :: AppInfo -> Range
    getRange = AppInfo -> Range
    appRange

    instance KillRange AppInfo where
      killRange :: AppInfo -> AppInfo
    killRange (AppInfo Range
    r Origin
    o ParenPreference
    p) = Range -> Origin -> ParenPreference -> AppInfo
    AppInfo (KillRangeT Range
    forall a. KillRange a => KillRangeT a
    killRange Range
    r) Origin
    o ParenPreference
    p

    instance LensOrigin AppInfo where
      getOrigin :: AppInfo -> Origin
    getOrigin = AppInfo -> Origin
    appOrigin
      mapOrigin :: (Origin -> Origin) -> AppInfo -> AppInfo
    mapOrigin Origin -> Origin
    f AppInfo
    i = AppInfo
    i { appOrigin :: Origin
    appOrigin = Origin -> Origin
    f (AppInfo -> Origin
    appOrigin AppInfo
    i) }

    instance NFData AppInfo

    {--------------------------------------------------------------------------
        Module information
     --------------------------------------------------------------------------}

    data ModuleInfo = ModuleInfo
      { ModuleInfo -> Range
    minfoRange    :: Range
      , ModuleInfo -> Range
    minfoAsTo     :: Range
        -- ^ The range of the \"as\" and \"to\" keywords,
        -- if any. Retained for highlighting purposes.
      , ModuleInfo -> Maybe Name
    minfoAsName   :: Maybe C.Name
        -- ^ The \"as\" module name, if any. Retained for highlighting purposes.
      , ModuleInfo -> Maybe OpenShortHand
    minfoOpenShort :: Maybe OpenShortHand
      , ModuleInfo -> Maybe ImportDirective
    minfoDirective :: Maybe ImportDirective
        -- ^ Retained for @abstractToConcrete@ of 'ModuleMacro'.
      }
      deriving (Typeable ModuleInfo
    Typeable ModuleInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ModuleInfo)
    -> (ModuleInfo -> Constr)
    -> (ModuleInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ModuleInfo))
    -> ((forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
    -> Data ModuleInfo
    ModuleInfo -> DataType
    ModuleInfo -> Constr
    (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
    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) -> ModuleInfo -> u
    forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
    $cgmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
    dataTypeOf :: ModuleInfo -> DataType
    $cdataTypeOf :: ModuleInfo -> DataType
    toConstr :: ModuleInfo -> Constr
    $ctoConstr :: ModuleInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
    Data, ModuleInfo -> ModuleInfo -> Bool
    (ModuleInfo -> ModuleInfo -> Bool)
    -> (ModuleInfo -> ModuleInfo -> Bool) -> Eq ModuleInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ModuleInfo -> ModuleInfo -> Bool
    $c/= :: ModuleInfo -> ModuleInfo -> Bool
    == :: ModuleInfo -> ModuleInfo -> Bool
    $c== :: ModuleInfo -> ModuleInfo -> Bool
    Eq, Int -> ModuleInfo -> ShowS
    [ModuleInfo] -> ShowS
    ModuleInfo -> String
    (Int -> ModuleInfo -> ShowS)
    -> (ModuleInfo -> String)
    -> ([ModuleInfo] -> ShowS)
    -> Show ModuleInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ModuleInfo] -> ShowS
    $cshowList :: [ModuleInfo] -> ShowS
    show :: ModuleInfo -> String
    $cshow :: ModuleInfo -> String
    showsPrec :: Int -> ModuleInfo -> ShowS
    $cshowsPrec :: Int -> ModuleInfo -> ShowS
    Show, (forall x. ModuleInfo -> Rep ModuleInfo x)
    -> (forall x. Rep ModuleInfo x -> ModuleInfo) -> Generic ModuleInfo
    forall x. Rep ModuleInfo x -> ModuleInfo
    forall x. ModuleInfo -> Rep ModuleInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ModuleInfo x -> ModuleInfo
    $cfrom :: forall x. ModuleInfo -> Rep ModuleInfo x
    Generic)

    instance HasRange ModuleInfo where
      getRange :: ModuleInfo -> Range
    getRange = ModuleInfo -> Range
    minfoRange

    instance SetRange ModuleInfo where
      setRange :: Range -> ModuleInfo -> ModuleInfo
    setRange Range
    r ModuleInfo
    i = ModuleInfo
    i { minfoRange :: Range
    minfoRange = Range
    r }

    instance KillRange ModuleInfo where
      killRange :: ModuleInfo -> ModuleInfo
    killRange ModuleInfo
    m = ModuleInfo
    m { minfoRange :: Range
    minfoRange = Range
    forall a. Range' a
    noRange }

    instance NFData ModuleInfo

    ---------------------------------------------------------------------------
    -- Let info
    ---------------------------------------------------------------------------

    newtype LetInfo = LetRange Range
      deriving (Typeable LetInfo
    Typeable LetInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> LetInfo -> c LetInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c LetInfo)
    -> (LetInfo -> Constr)
    -> (LetInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c LetInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetInfo))
    -> ((forall b. Data b => b -> b) -> LetInfo -> LetInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> LetInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> LetInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> LetInfo -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> LetInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo)
    -> Data LetInfo
    LetInfo -> DataType
    LetInfo -> Constr
    (forall b. Data b => b -> b) -> LetInfo -> LetInfo
    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) -> LetInfo -> u
    forall u. (forall d. Data d => d -> u) -> LetInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LetInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LetInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LetInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> LetInfo -> c LetInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LetInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LetInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LetInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> LetInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> LetInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LetInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LetInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LetInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LetInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> LetInfo -> LetInfo
    $cgmapT :: (forall b. Data b => b -> b) -> LetInfo -> LetInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LetInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LetInfo)
    dataTypeOf :: LetInfo -> DataType
    $cdataTypeOf :: LetInfo -> DataType
    toConstr :: LetInfo -> Constr
    $ctoConstr :: LetInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LetInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LetInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> LetInfo -> c LetInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> LetInfo -> c LetInfo
    Data, Int -> LetInfo -> ShowS
    [LetInfo] -> ShowS
    LetInfo -> String
    (Int -> LetInfo -> ShowS)
    -> (LetInfo -> String) -> ([LetInfo] -> ShowS) -> Show LetInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [LetInfo] -> ShowS
    $cshowList :: [LetInfo] -> ShowS
    show :: LetInfo -> String
    $cshow :: LetInfo -> String
    showsPrec :: Int -> LetInfo -> ShowS
    $cshowsPrec :: Int -> LetInfo -> ShowS
    Show, LetInfo -> LetInfo -> Bool
    (LetInfo -> LetInfo -> Bool)
    -> (LetInfo -> LetInfo -> Bool) -> Eq LetInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: LetInfo -> LetInfo -> Bool
    $c/= :: LetInfo -> LetInfo -> Bool
    == :: LetInfo -> LetInfo -> Bool
    $c== :: LetInfo -> LetInfo -> Bool
    Eq, LetInfo
    LetInfo -> Bool
    LetInfo -> (LetInfo -> Bool) -> Null LetInfo
    forall a. a -> (a -> Bool) -> Null a
    null :: LetInfo -> Bool
    $cnull :: LetInfo -> Bool
    empty :: LetInfo
    $cempty :: LetInfo
    Null, LetInfo -> ()
    (LetInfo -> ()) -> NFData LetInfo
    forall a. (a -> ()) -> NFData a
    rnf :: LetInfo -> ()
    $crnf :: LetInfo -> ()
    NFData)

    instance HasRange LetInfo where
      getRange :: LetInfo -> Range
    getRange (LetRange Range
    r)   = Range
    r

    instance KillRange LetInfo where
      killRange :: LetInfo -> LetInfo
    killRange (LetRange Range
    r) = Range -> LetInfo
    LetRange Range
    forall a. Range' a
    noRange

    {--------------------------------------------------------------------------
        Definition information (declarations that actually define something)
     --------------------------------------------------------------------------}

    data DefInfo' t = DefInfo
      { forall t. DefInfo' t -> Fixity'
    defFixity   :: Fixity'
      , forall t. DefInfo' t -> Access
    defAccess   :: Access
      , forall t. DefInfo' t -> IsAbstract
    defAbstract :: IsAbstract
      , forall t. DefInfo' t -> IsInstance
    defInstance :: IsInstance
      , forall t. DefInfo' t -> IsMacro
    defMacro    :: IsMacro
      , forall t. DefInfo' t -> DeclInfo
    defInfo     :: DeclInfo
      , forall t. DefInfo' t -> Maybe t
    defTactic   :: Maybe t
      }
      deriving (Typeable (DefInfo' t)
    Typeable (DefInfo' t)
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (DefInfo' t))
    -> (DefInfo' t -> Constr)
    -> (DefInfo' t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (DefInfo' t)))
    -> ((forall b. Data b => b -> b) -> DefInfo' t -> DefInfo' t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DefInfo' t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DefInfo' t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t))
    -> Data (DefInfo' t)
    DefInfo' t -> DataType
    DefInfo' t -> Constr
    (forall b. Data b => b -> b) -> DefInfo' t -> DefInfo' t
    forall {t}. Data t => Typeable (DefInfo' t)
    forall t. Data t => DefInfo' t -> DataType
    forall t. Data t => DefInfo' t -> Constr
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> DefInfo' t -> DefInfo' t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> DefInfo' t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> DefInfo' t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DefInfo' t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DefInfo' t))
    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) -> DefInfo' t -> u
    forall u. (forall d. Data d => d -> u) -> DefInfo' t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DefInfo' t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DefInfo' t))
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DefInfo' t -> u
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> DefInfo' t -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DefInfo' t -> [u]
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> DefInfo' t -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
    gmapT :: (forall b. Data b => b -> b) -> DefInfo' t -> DefInfo' t
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> DefInfo' t -> DefInfo' t
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DefInfo' t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DefInfo' t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t))
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t))
    dataTypeOf :: DefInfo' t -> DataType
    $cdataTypeOf :: forall t. Data t => DefInfo' t -> DataType
    toConstr :: DefInfo' t -> Constr
    $ctoConstr :: forall t. Data t => DefInfo' t -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DefInfo' t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DefInfo' t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t)
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t)
    Data, Int -> DefInfo' t -> ShowS
    [DefInfo' t] -> ShowS
    DefInfo' t -> String
    (Int -> DefInfo' t -> ShowS)
    -> (DefInfo' t -> String)
    -> ([DefInfo' t] -> ShowS)
    -> Show (DefInfo' t)
    forall t. Show t => Int -> DefInfo' t -> ShowS
    forall t. Show t => [DefInfo' t] -> ShowS
    forall t. Show t => DefInfo' t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [DefInfo' t] -> ShowS
    $cshowList :: forall t. Show t => [DefInfo' t] -> ShowS
    show :: DefInfo' t -> String
    $cshow :: forall t. Show t => DefInfo' t -> String
    showsPrec :: Int -> DefInfo' t -> ShowS
    $cshowsPrec :: forall t. Show t => Int -> DefInfo' t -> ShowS
    Show, DefInfo' t -> DefInfo' t -> Bool
    (DefInfo' t -> DefInfo' t -> Bool)
    -> (DefInfo' t -> DefInfo' t -> Bool) -> Eq (DefInfo' t)
    forall t. Eq t => DefInfo' t -> DefInfo' t -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DefInfo' t -> DefInfo' t -> Bool
    $c/= :: forall t. Eq t => DefInfo' t -> DefInfo' t -> Bool
    == :: DefInfo' t -> DefInfo' t -> Bool
    $c== :: forall t. Eq t => DefInfo' t -> DefInfo' t -> Bool
    Eq, (forall x. DefInfo' t -> Rep (DefInfo' t) x)
    -> (forall x. Rep (DefInfo' t) x -> DefInfo' t)
    -> Generic (DefInfo' t)
    forall x. Rep (DefInfo' t) x -> DefInfo' t
    forall x. DefInfo' t -> Rep (DefInfo' t) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall t x. Rep (DefInfo' t) x -> DefInfo' t
    forall t x. DefInfo' t -> Rep (DefInfo' t) x
    $cto :: forall t x. Rep (DefInfo' t) x -> DefInfo' t
    $cfrom :: forall t x. DefInfo' t -> Rep (DefInfo' t) x
    Generic)

    mkDefInfo :: Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' t
    mkDefInfo :: forall t.
    Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' t
    mkDefInfo Name
    x Fixity'
    f Access
    a IsAbstract
    ab Range
    r = Name
    -> Fixity'
    -> Access
    -> IsAbstract
    -> IsInstance
    -> IsMacro
    -> Range
    -> DefInfo' t
    forall t.
    Name
    -> Fixity'
    -> Access
    -> IsAbstract
    -> IsInstance
    -> IsMacro
    -> Range
    -> DefInfo' t
    mkDefInfoInstance Name
    x Fixity'
    f Access
    a IsAbstract
    ab IsInstance
    NotInstanceDef IsMacro
    NotMacroDef Range
    r

    -- | Same as @mkDefInfo@ but where we can also give the @IsInstance@
    mkDefInfoInstance :: Name -> Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> Range -> DefInfo' t
    mkDefInfoInstance :: forall t.
    Name
    -> Fixity'
    -> Access
    -> IsAbstract
    -> IsInstance
    -> IsMacro
    -> Range
    -> DefInfo' t
    mkDefInfoInstance Name
    x Fixity'
    f Access
    a IsAbstract
    ab IsInstance
    i IsMacro
    m Range
    r = Fixity'
    -> Access
    -> IsAbstract
    -> IsInstance
    -> IsMacro
    -> DeclInfo
    -> Maybe t
    -> DefInfo' t
    forall t.
    Fixity'
    -> Access
    -> IsAbstract
    -> IsInstance
    -> IsMacro
    -> DeclInfo
    -> Maybe t
    -> DefInfo' t
    DefInfo Fixity'
    f Access
    a IsAbstract
    ab IsInstance
    i IsMacro
    m (Name -> Range -> DeclInfo
    DeclInfo Name
    x Range
    r) Maybe t
    forall a. Maybe a
    Nothing

    instance HasRange (DefInfo' t) where
      getRange :: DefInfo' t -> Range
    getRange = DeclInfo -> Range
    forall a. HasRange a => a -> Range
    getRange (DeclInfo -> Range)
    -> (DefInfo' t -> DeclInfo) -> DefInfo' t -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . DefInfo' t -> DeclInfo
    forall t. DefInfo' t -> DeclInfo
    defInfo

    instance SetRange (DefInfo' t) where
      setRange :: Range -> DefInfo' t -> DefInfo' t
    setRange Range
    r DefInfo' t
    i = DefInfo' t
    i { defInfo :: DeclInfo
    defInfo = Range -> DeclInfo -> DeclInfo
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r (DefInfo' t -> DeclInfo
    forall t. DefInfo' t -> DeclInfo
    defInfo DefInfo' t
    i) }

    instance KillRange t => KillRange (DefInfo' t) where
      killRange :: KillRangeT (DefInfo' t)
    killRange DefInfo' t
    i = DefInfo' t
    i { defInfo :: DeclInfo
    defInfo   = DeclInfo -> DeclInfo
    forall a. KillRange a => KillRangeT a
    killRange (DeclInfo -> DeclInfo) -> DeclInfo -> DeclInfo
    forall a b. (a -> b) -> a -> b
    $ DefInfo' t -> DeclInfo
    forall t. DefInfo' t -> DeclInfo
    defInfo DefInfo' t
    i,
                        defTactic :: Maybe t
    defTactic = KillRangeT (Maybe t)
    forall a. KillRange a => KillRangeT a
    killRange KillRangeT (Maybe t) -> KillRangeT (Maybe t)
    forall a b. (a -> b) -> a -> b
    $ DefInfo' t -> Maybe t
    forall t. DefInfo' t -> Maybe t
    defTactic DefInfo' t
    i }

    instance LensIsAbstract (DefInfo' t) where
      lensIsAbstract :: Lens' IsAbstract (DefInfo' t)
    lensIsAbstract IsAbstract -> f IsAbstract
    f DefInfo' t
    i = (IsAbstract -> f IsAbstract
    f (IsAbstract -> f IsAbstract) -> IsAbstract -> f IsAbstract
    forall a b. (a -> b) -> a -> b
    $! DefInfo' t -> IsAbstract
    forall t. DefInfo' t -> IsAbstract
    defAbstract DefInfo' t
    i) f IsAbstract -> (IsAbstract -> DefInfo' t) -> f (DefInfo' t)
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ IsAbstract
    a -> DefInfo' t
    i { defAbstract :: IsAbstract
    defAbstract = IsAbstract
    a }

    instance AnyIsAbstract (DefInfo' t) where
      anyIsAbstract :: DefInfo' t -> IsAbstract
    anyIsAbstract = DefInfo' t -> IsAbstract
    forall t. DefInfo' t -> IsAbstract
    defAbstract

    instance NFData t => NFData (DefInfo' t)

    {--------------------------------------------------------------------------
        General declaration information
     --------------------------------------------------------------------------}

    data DeclInfo = DeclInfo
      { DeclInfo -> Name
    declName  :: Name
      , DeclInfo -> Range
    declRange :: Range
      }
      deriving (Typeable DeclInfo
    Typeable DeclInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> DeclInfo -> c DeclInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DeclInfo)
    -> (DeclInfo -> Constr)
    -> (DeclInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DeclInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclInfo))
    -> ((forall b. Data b => b -> b) -> DeclInfo -> DeclInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DeclInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DeclInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DeclInfo -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DeclInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo)
    -> Data DeclInfo
    DeclInfo -> DataType
    DeclInfo -> Constr
    (forall b. Data b => b -> b) -> DeclInfo -> DeclInfo
    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) -> DeclInfo -> u
    forall u. (forall d. Data d => d -> u) -> DeclInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeclInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclInfo -> c DeclInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeclInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclInfo -> m DeclInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeclInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeclInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DeclInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DeclInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> DeclInfo -> DeclInfo
    $cgmapT :: (forall b. Data b => b -> b) -> DeclInfo -> DeclInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeclInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeclInfo)
    dataTypeOf :: DeclInfo -> DataType
    $cdataTypeOf :: DeclInfo -> DataType
    toConstr :: DeclInfo -> Constr
    $ctoConstr :: DeclInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeclInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeclInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclInfo -> c DeclInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclInfo -> c DeclInfo
    Data, Int -> DeclInfo -> ShowS
    [DeclInfo] -> ShowS
    DeclInfo -> String
    (Int -> DeclInfo -> ShowS)
    -> (DeclInfo -> String) -> ([DeclInfo] -> ShowS) -> Show DeclInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [DeclInfo] -> ShowS
    $cshowList :: [DeclInfo] -> ShowS
    show :: DeclInfo -> String
    $cshow :: DeclInfo -> String
    showsPrec :: Int -> DeclInfo -> ShowS
    $cshowsPrec :: Int -> DeclInfo -> ShowS
    Show, DeclInfo -> DeclInfo -> Bool
    (DeclInfo -> DeclInfo -> Bool)
    -> (DeclInfo -> DeclInfo -> Bool) -> Eq DeclInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DeclInfo -> DeclInfo -> Bool
    $c/= :: DeclInfo -> DeclInfo -> Bool
    == :: DeclInfo -> DeclInfo -> Bool
    $c== :: DeclInfo -> DeclInfo -> Bool
    Eq, (forall x. DeclInfo -> Rep DeclInfo x)
    -> (forall x. Rep DeclInfo x -> DeclInfo) -> Generic DeclInfo
    forall x. Rep DeclInfo x -> DeclInfo
    forall x. DeclInfo -> Rep DeclInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DeclInfo x -> DeclInfo
    $cfrom :: forall x. DeclInfo -> Rep DeclInfo x
    Generic)

    instance HasRange DeclInfo where
      getRange :: DeclInfo -> Range
    getRange = DeclInfo -> Range
    declRange

    instance SetRange DeclInfo where
      setRange :: Range -> DeclInfo -> DeclInfo
    setRange Range
    r DeclInfo
    i = DeclInfo
    i { declRange :: Range
    declRange = Range
    r }

    instance KillRange DeclInfo where
      killRange :: DeclInfo -> DeclInfo
    killRange DeclInfo
    i = DeclInfo
    i { declRange :: Range
    declRange = Range
    forall a. Range' a
    noRange }

    instance NFData DeclInfo

    {--------------------------------------------------------------------------
        Mutual block information
     --------------------------------------------------------------------------}

    data MutualInfo = MutualInfo
      { MutualInfo -> TerminationCheck Name
    mutualTerminationCheck :: TerminationCheck Name
      , MutualInfo -> CoverageCheck
    mutualCoverageCheck    :: CoverageCheck
      , MutualInfo -> PositivityCheck
    mutualPositivityCheck  :: PositivityCheck
      , MutualInfo -> Range
    mutualRange            :: Range
      }
      deriving (Typeable MutualInfo
    Typeable MutualInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> MutualInfo -> c MutualInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c MutualInfo)
    -> (MutualInfo -> Constr)
    -> (MutualInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c MutualInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c MutualInfo))
    -> ((forall b. Data b => b -> b) -> MutualInfo -> MutualInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> MutualInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> MutualInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> MutualInfo -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> MutualInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo)
    -> Data MutualInfo
    MutualInfo -> DataType
    MutualInfo -> Constr
    (forall b. Data b => b -> b) -> MutualInfo -> MutualInfo
    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) -> MutualInfo -> u
    forall u. (forall d. Data d => d -> u) -> MutualInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MutualInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MutualInfo -> c MutualInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MutualInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MutualInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MutualInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> MutualInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> MutualInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> MutualInfo -> MutualInfo
    $cgmapT :: (forall b. Data b => b -> b) -> MutualInfo -> MutualInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MutualInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MutualInfo)
    dataTypeOf :: MutualInfo -> DataType
    $cdataTypeOf :: MutualInfo -> DataType
    toConstr :: MutualInfo -> Constr
    $ctoConstr :: MutualInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MutualInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MutualInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MutualInfo -> c MutualInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MutualInfo -> c MutualInfo
    Data, Int -> MutualInfo -> ShowS
    [MutualInfo] -> ShowS
    MutualInfo -> String
    (Int -> MutualInfo -> ShowS)
    -> (MutualInfo -> String)
    -> ([MutualInfo] -> ShowS)
    -> Show MutualInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [MutualInfo] -> ShowS
    $cshowList :: [MutualInfo] -> ShowS
    show :: MutualInfo -> String
    $cshow :: MutualInfo -> String
    showsPrec :: Int -> MutualInfo -> ShowS
    $cshowsPrec :: Int -> MutualInfo -> ShowS
    Show, MutualInfo -> MutualInfo -> Bool
    (MutualInfo -> MutualInfo -> Bool)
    -> (MutualInfo -> MutualInfo -> Bool) -> Eq MutualInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: MutualInfo -> MutualInfo -> Bool
    $c/= :: MutualInfo -> MutualInfo -> Bool
    == :: MutualInfo -> MutualInfo -> Bool
    $c== :: MutualInfo -> MutualInfo -> Bool
    Eq, (forall x. MutualInfo -> Rep MutualInfo x)
    -> (forall x. Rep MutualInfo x -> MutualInfo) -> Generic MutualInfo
    forall x. Rep MutualInfo x -> MutualInfo
    forall x. MutualInfo -> Rep MutualInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep MutualInfo x -> MutualInfo
    $cfrom :: forall x. MutualInfo -> Rep MutualInfo x
    Generic)

    -- | Default value for 'MutualInfo'.
    instance Null MutualInfo where
      empty :: MutualInfo
    empty = TerminationCheck Name
    -> CoverageCheck -> PositivityCheck -> Range -> MutualInfo
    MutualInfo TerminationCheck Name
    forall m. TerminationCheck m
    TerminationCheck CoverageCheck
    YesCoverageCheck PositivityCheck
    YesPositivityCheck Range
    forall a. Range' a
    noRange

    instance HasRange MutualInfo where
      getRange :: MutualInfo -> Range
    getRange = MutualInfo -> Range
    mutualRange

    instance KillRange MutualInfo where
      killRange :: MutualInfo -> MutualInfo
    killRange MutualInfo
    i = MutualInfo
    i { mutualRange :: Range
    mutualRange = Range
    forall a. Range' a
    noRange }

    instance NFData MutualInfo

    {--------------------------------------------------------------------------
        Left hand side information
     --------------------------------------------------------------------------}

    data LHSInfo = LHSInfo
      { LHSInfo -> Range
    lhsRange    :: Range
      , LHSInfo -> ExpandedEllipsis
    lhsEllipsis :: ExpandedEllipsis
      } deriving (Typeable LHSInfo
    Typeable LHSInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> LHSInfo -> c LHSInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c LHSInfo)
    -> (LHSInfo -> Constr)
    -> (LHSInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c LHSInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LHSInfo))
    -> ((forall b. Data b => b -> b) -> LHSInfo -> LHSInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> LHSInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> LHSInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> LHSInfo -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> LHSInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo)
    -> Data LHSInfo
    LHSInfo -> DataType
    LHSInfo -> Constr
    (forall b. Data b => b -> b) -> LHSInfo -> LHSInfo
    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) -> LHSInfo -> u
    forall u. (forall d. Data d => d -> u) -> LHSInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LHSInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LHSInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LHSInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> LHSInfo -> c LHSInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LHSInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LHSInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LHSInfo -> m LHSInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LHSInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LHSInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> LHSInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> LHSInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LHSInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LHSInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LHSInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LHSInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> LHSInfo -> LHSInfo
    $cgmapT :: (forall b. Data b => b -> b) -> LHSInfo -> LHSInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LHSInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LHSInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LHSInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LHSInfo)
    dataTypeOf :: LHSInfo -> DataType
    $cdataTypeOf :: LHSInfo -> DataType
    toConstr :: LHSInfo -> Constr
    $ctoConstr :: LHSInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LHSInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LHSInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> LHSInfo -> c LHSInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> LHSInfo -> c LHSInfo
    Data, Int -> LHSInfo -> ShowS
    [LHSInfo] -> ShowS
    LHSInfo -> String
    (Int -> LHSInfo -> ShowS)
    -> (LHSInfo -> String) -> ([LHSInfo] -> ShowS) -> Show LHSInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [LHSInfo] -> ShowS
    $cshowList :: [LHSInfo] -> ShowS
    show :: LHSInfo -> String
    $cshow :: LHSInfo -> String
    showsPrec :: Int -> LHSInfo -> ShowS
    $cshowsPrec :: Int -> LHSInfo -> ShowS
    Show, LHSInfo -> LHSInfo -> Bool
    (LHSInfo -> LHSInfo -> Bool)
    -> (LHSInfo -> LHSInfo -> Bool) -> Eq LHSInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: LHSInfo -> LHSInfo -> Bool
    $c/= :: LHSInfo -> LHSInfo -> Bool
    == :: LHSInfo -> LHSInfo -> Bool
    $c== :: LHSInfo -> LHSInfo -> Bool
    Eq, (forall x. LHSInfo -> Rep LHSInfo x)
    -> (forall x. Rep LHSInfo x -> LHSInfo) -> Generic LHSInfo
    forall x. Rep LHSInfo x -> LHSInfo
    forall x. LHSInfo -> Rep LHSInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep LHSInfo x -> LHSInfo
    $cfrom :: forall x. LHSInfo -> Rep LHSInfo x
    Generic)

    instance HasRange LHSInfo where
      getRange :: LHSInfo -> Range
    getRange (LHSInfo Range
    r ExpandedEllipsis
    _) = Range
    r

    instance KillRange LHSInfo where
      killRange :: LHSInfo -> LHSInfo
    killRange (LHSInfo Range
    r ExpandedEllipsis
    ell) = Range -> ExpandedEllipsis -> LHSInfo
    LHSInfo Range
    forall a. Range' a
    noRange ExpandedEllipsis
    ell

    instance Null LHSInfo where
      null :: LHSInfo -> Bool
    null LHSInfo
    i = Range -> Bool
    forall a. Null a => a -> Bool
    null (LHSInfo -> Range
    lhsRange LHSInfo
    i) Bool -> Bool -> Bool
    && ExpandedEllipsis -> Bool
    forall a. Null a => a -> Bool
    null (LHSInfo -> ExpandedEllipsis
    lhsEllipsis LHSInfo
    i)
      empty :: LHSInfo
    empty  = Range -> ExpandedEllipsis -> LHSInfo
    LHSInfo Range
    forall a. Null a => a
    empty ExpandedEllipsis
    forall a. Null a => a
    empty

    instance NFData LHSInfo

    {--------------------------------------------------------------------------
        Pattern information
     --------------------------------------------------------------------------}

    -- | For a general pattern we remember the source code position.
    newtype PatInfo
      = PatRange Range
      deriving (Typeable PatInfo
    Typeable PatInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> PatInfo -> c PatInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c PatInfo)
    -> (PatInfo -> Constr)
    -> (PatInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c PatInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatInfo))
    -> ((forall b. Data b => b -> b) -> PatInfo -> PatInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PatInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PatInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PatInfo -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> PatInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo)
    -> Data PatInfo
    PatInfo -> DataType
    PatInfo -> Constr
    (forall b. Data b => b -> b) -> PatInfo -> PatInfo
    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) -> PatInfo -> u
    forall u. (forall d. Data d => d -> u) -> PatInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatInfo -> c PatInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PatInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> PatInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PatInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PatInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> PatInfo -> PatInfo
    $cgmapT :: (forall b. Data b => b -> b) -> PatInfo -> PatInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PatInfo)
    dataTypeOf :: PatInfo -> DataType
    $cdataTypeOf :: PatInfo -> DataType
    toConstr :: PatInfo -> Constr
    $ctoConstr :: PatInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PatInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatInfo -> c PatInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PatInfo -> c PatInfo
    Data, PatInfo -> PatInfo -> Bool
    (PatInfo -> PatInfo -> Bool)
    -> (PatInfo -> PatInfo -> Bool) -> Eq PatInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PatInfo -> PatInfo -> Bool
    $c/= :: PatInfo -> PatInfo -> Bool
    == :: PatInfo -> PatInfo -> Bool
    $c== :: PatInfo -> PatInfo -> Bool
    Eq, PatInfo
    PatInfo -> Bool
    PatInfo -> (PatInfo -> Bool) -> Null PatInfo
    forall a. a -> (a -> Bool) -> Null a
    null :: PatInfo -> Bool
    $cnull :: PatInfo -> Bool
    empty :: PatInfo
    $cempty :: PatInfo
    Null, NonEmpty PatInfo -> PatInfo
    PatInfo -> PatInfo -> PatInfo
    (PatInfo -> PatInfo -> PatInfo)
    -> (NonEmpty PatInfo -> PatInfo)
    -> (forall b. Integral b => b -> PatInfo -> PatInfo)
    -> Semigroup PatInfo
    forall b. Integral b => b -> PatInfo -> PatInfo
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    stimes :: forall b. Integral b => b -> PatInfo -> PatInfo
    $cstimes :: forall b. Integral b => b -> PatInfo -> PatInfo
    sconcat :: NonEmpty PatInfo -> PatInfo
    $csconcat :: NonEmpty PatInfo -> PatInfo
    <> :: PatInfo -> PatInfo -> PatInfo
    $c<> :: PatInfo -> PatInfo -> PatInfo
    Semigroup, Semigroup PatInfo
    PatInfo
    Semigroup PatInfo
    -> PatInfo
    -> (PatInfo -> PatInfo -> PatInfo)
    -> ([PatInfo] -> PatInfo)
    -> Monoid PatInfo
    [PatInfo] -> PatInfo
    PatInfo -> PatInfo -> PatInfo
    forall a.
    Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    mconcat :: [PatInfo] -> PatInfo
    $cmconcat :: [PatInfo] -> PatInfo
    mappend :: PatInfo -> PatInfo -> PatInfo
    $cmappend :: PatInfo -> PatInfo -> PatInfo
    mempty :: PatInfo
    $cmempty :: PatInfo
    Monoid, Int -> PatInfo -> ShowS
    [PatInfo] -> ShowS
    PatInfo -> String
    (Int -> PatInfo -> ShowS)
    -> (PatInfo -> String) -> ([PatInfo] -> ShowS) -> Show PatInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [PatInfo] -> ShowS
    $cshowList :: [PatInfo] -> ShowS
    show :: PatInfo -> String
    $cshow :: PatInfo -> String
    showsPrec :: Int -> PatInfo -> ShowS
    $cshowsPrec :: Int -> PatInfo -> ShowS
    Show, HasRange PatInfo
    HasRange PatInfo
    -> (Range -> PatInfo -> PatInfo) -> SetRange PatInfo
    Range -> PatInfo -> PatInfo
    forall a. HasRange a -> (Range -> a -> a) -> SetRange a
    setRange :: Range -> PatInfo -> PatInfo
    $csetRange :: Range -> PatInfo -> PatInfo
    SetRange, PatInfo -> Range
    (PatInfo -> Range) -> HasRange PatInfo
    forall a. (a -> Range) -> HasRange a
    getRange :: PatInfo -> Range
    $cgetRange :: PatInfo -> Range
    HasRange,
                PatInfo -> PatInfo
    (PatInfo -> PatInfo) -> KillRange PatInfo
    forall a. KillRangeT a -> KillRange a
    killRange :: PatInfo -> PatInfo
    $ckillRange :: PatInfo -> PatInfo
    KillRange, PatInfo -> ()
    (PatInfo -> ()) -> NFData PatInfo
    forall a. (a -> ()) -> NFData a
    rnf :: PatInfo -> ()
    $crnf :: PatInfo -> ()
    NFData)

    -- | Empty range for patterns.
    patNoRange :: PatInfo
    patNoRange :: PatInfo
    patNoRange = Range -> PatInfo
    PatRange Range
    forall a. Range' a
    noRange

    -- | Constructor pattern info.
    data ConPatInfo = ConPatInfo
      { ConPatInfo -> ConOrigin
    conPatOrigin   :: ConOrigin
        -- ^ Does this pattern come form the eta-expansion of an implicit pattern?
        ---  Or from a user written constructor or record pattern?
      , ConPatInfo -> PatInfo
    conPatInfo     :: PatInfo
      , ConPatInfo -> ConPatLazy
    conPatLazy     :: ConPatLazy
      }
      deriving (Typeable ConPatInfo
    Typeable ConPatInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ConPatInfo -> c ConPatInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ConPatInfo)
    -> (ConPatInfo -> Constr)
    -> (ConPatInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ConPatInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ConPatInfo))
    -> ((forall b. Data b => b -> b) -> ConPatInfo -> ConPatInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ConPatInfo -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ConPatInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo)
    -> Data ConPatInfo
    ConPatInfo -> DataType
    ConPatInfo -> Constr
    (forall b. Data b => b -> b) -> ConPatInfo -> ConPatInfo
    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) -> ConPatInfo -> u
    forall u. (forall d. Data d => d -> u) -> ConPatInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConPatInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConPatInfo -> c ConPatInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConPatInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConPatInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConPatInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ConPatInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConPatInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> ConPatInfo -> ConPatInfo
    $cgmapT :: (forall b. Data b => b -> b) -> ConPatInfo -> ConPatInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConPatInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConPatInfo)
    dataTypeOf :: ConPatInfo -> DataType
    $cdataTypeOf :: ConPatInfo -> DataType
    toConstr :: ConPatInfo -> Constr
    $ctoConstr :: ConPatInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConPatInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConPatInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConPatInfo -> c ConPatInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConPatInfo -> c ConPatInfo
    Data, ConPatInfo -> ConPatInfo -> Bool
    (ConPatInfo -> ConPatInfo -> Bool)
    -> (ConPatInfo -> ConPatInfo -> Bool) -> Eq ConPatInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ConPatInfo -> ConPatInfo -> Bool
    $c/= :: ConPatInfo -> ConPatInfo -> Bool
    == :: ConPatInfo -> ConPatInfo -> Bool
    $c== :: ConPatInfo -> ConPatInfo -> Bool
    Eq, Int -> ConPatInfo -> ShowS
    [ConPatInfo] -> ShowS
    ConPatInfo -> String
    (Int -> ConPatInfo -> ShowS)
    -> (ConPatInfo -> String)
    -> ([ConPatInfo] -> ShowS)
    -> Show ConPatInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ConPatInfo] -> ShowS
    $cshowList :: [ConPatInfo] -> ShowS
    show :: ConPatInfo -> String
    $cshow :: ConPatInfo -> String
    showsPrec :: Int -> ConPatInfo -> ShowS
    $cshowsPrec :: Int -> ConPatInfo -> ShowS
    Show, (forall x. ConPatInfo -> Rep ConPatInfo x)
    -> (forall x. Rep ConPatInfo x -> ConPatInfo) -> Generic ConPatInfo
    forall x. Rep ConPatInfo x -> ConPatInfo
    forall x. ConPatInfo -> Rep ConPatInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ConPatInfo x -> ConPatInfo
    $cfrom :: forall x. ConPatInfo -> Rep ConPatInfo x
    Generic)

    instance HasRange ConPatInfo where
      getRange :: ConPatInfo -> Range
    getRange = PatInfo -> Range
    forall a. HasRange a => a -> Range
    getRange (PatInfo -> Range)
    -> (ConPatInfo -> PatInfo) -> ConPatInfo -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ConPatInfo -> PatInfo
    conPatInfo

    instance KillRange ConPatInfo where
      killRange :: ConPatInfo -> ConPatInfo
    killRange (ConPatInfo ConOrigin
    b PatInfo
    i ConPatLazy
    l) = ConOrigin -> PatInfo -> ConPatLazy -> ConPatInfo
    ConPatInfo ConOrigin
    b (PatInfo -> PatInfo
    forall a. KillRange a => KillRangeT a
    killRange PatInfo
    i) ConPatLazy
    l

    instance SetRange ConPatInfo where
      setRange :: Range -> ConPatInfo -> ConPatInfo
    setRange Range
    r (ConPatInfo ConOrigin
    b PatInfo
    i ConPatLazy
    l) = ConOrigin -> PatInfo -> ConPatLazy -> ConPatInfo
    ConPatInfo ConOrigin
    b (Range -> PatInfo
    PatRange Range
    r) ConPatLazy
    l

    instance NFData ConPatInfo

    -- | Has the constructor pattern a dotted (forced) constructor?
    data ConPatLazy
      = ConPatLazy   -- ^ Dotted constructor.
      | ConPatEager  -- ^ Ordinary constructor.
      deriving (Typeable ConPatLazy
    Typeable ConPatLazy
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ConPatLazy -> c ConPatLazy)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ConPatLazy)
    -> (ConPatLazy -> Constr)
    -> (ConPatLazy -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ConPatLazy))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ConPatLazy))
    -> ((forall b. Data b => b -> b) -> ConPatLazy -> ConPatLazy)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ConPatLazy -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ConPatLazy -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy)
    -> Data ConPatLazy
    ConPatLazy -> DataType
    ConPatLazy -> Constr
    (forall b. Data b => b -> b) -> ConPatLazy -> ConPatLazy
    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) -> ConPatLazy -> u
    forall u. (forall d. Data d => d -> u) -> ConPatLazy -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConPatLazy
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConPatLazy -> c ConPatLazy
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConPatLazy)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatLazy)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConPatLazy -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConPatLazy -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ConPatLazy -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConPatLazy -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
    gmapT :: (forall b. Data b => b -> b) -> ConPatLazy -> ConPatLazy
    $cgmapT :: (forall b. Data b => b -> b) -> ConPatLazy -> ConPatLazy
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatLazy)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatLazy)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConPatLazy)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConPatLazy)
    dataTypeOf :: ConPatLazy -> DataType
    $cdataTypeOf :: ConPatLazy -> DataType
    toConstr :: ConPatLazy -> Constr
    $ctoConstr :: ConPatLazy -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConPatLazy
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConPatLazy
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConPatLazy -> c ConPatLazy
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ConPatLazy -> c ConPatLazy
    Data, ConPatLazy -> ConPatLazy -> Bool
    (ConPatLazy -> ConPatLazy -> Bool)
    -> (ConPatLazy -> ConPatLazy -> Bool) -> Eq ConPatLazy
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ConPatLazy -> ConPatLazy -> Bool
    $c/= :: ConPatLazy -> ConPatLazy -> Bool
    == :: ConPatLazy -> ConPatLazy -> Bool
    $c== :: ConPatLazy -> ConPatLazy -> Bool
    Eq, Eq ConPatLazy
    Eq ConPatLazy
    -> (ConPatLazy -> ConPatLazy -> Ordering)
    -> (ConPatLazy -> ConPatLazy -> Bool)
    -> (ConPatLazy -> ConPatLazy -> Bool)
    -> (ConPatLazy -> ConPatLazy -> Bool)
    -> (ConPatLazy -> ConPatLazy -> Bool)
    -> (ConPatLazy -> ConPatLazy -> ConPatLazy)
    -> (ConPatLazy -> ConPatLazy -> ConPatLazy)
    -> Ord ConPatLazy
    ConPatLazy -> ConPatLazy -> Bool
    ConPatLazy -> ConPatLazy -> Ordering
    ConPatLazy -> ConPatLazy -> ConPatLazy
    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
    min :: ConPatLazy -> ConPatLazy -> ConPatLazy
    $cmin :: ConPatLazy -> ConPatLazy -> ConPatLazy
    max :: ConPatLazy -> ConPatLazy -> ConPatLazy
    $cmax :: ConPatLazy -> ConPatLazy -> ConPatLazy
    >= :: ConPatLazy -> ConPatLazy -> Bool
    $c>= :: ConPatLazy -> ConPatLazy -> Bool
    > :: ConPatLazy -> ConPatLazy -> Bool
    $c> :: ConPatLazy -> ConPatLazy -> Bool
    <= :: ConPatLazy -> ConPatLazy -> Bool
    $c<= :: ConPatLazy -> ConPatLazy -> Bool
    < :: ConPatLazy -> ConPatLazy -> Bool
    $c< :: ConPatLazy -> ConPatLazy -> Bool
    compare :: ConPatLazy -> ConPatLazy -> Ordering
    $ccompare :: ConPatLazy -> ConPatLazy -> Ordering
    Ord, Int -> ConPatLazy -> ShowS
    [ConPatLazy] -> ShowS
    ConPatLazy -> String
    (Int -> ConPatLazy -> ShowS)
    -> (ConPatLazy -> String)
    -> ([ConPatLazy] -> ShowS)
    -> Show ConPatLazy
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ConPatLazy] -> ShowS
    $cshowList :: [ConPatLazy] -> ShowS
    show :: ConPatLazy -> String
    $cshow :: ConPatLazy -> String
    showsPrec :: Int -> ConPatLazy -> ShowS
    $cshowsPrec :: Int -> ConPatLazy -> ShowS
    Show, ConPatLazy
    ConPatLazy -> ConPatLazy -> Bounded ConPatLazy
    forall a. a -> a -> Bounded a
    maxBound :: ConPatLazy
    $cmaxBound :: ConPatLazy
    minBound :: ConPatLazy
    $cminBound :: ConPatLazy
    Bounded, Int -> ConPatLazy
    ConPatLazy -> Int
    ConPatLazy -> [ConPatLazy]
    ConPatLazy -> ConPatLazy
    ConPatLazy -> ConPatLazy -> [ConPatLazy]
    ConPatLazy -> ConPatLazy -> ConPatLazy -> [ConPatLazy]
    (ConPatLazy -> ConPatLazy)
    -> (ConPatLazy -> ConPatLazy)
    -> (Int -> ConPatLazy)
    -> (ConPatLazy -> Int)
    -> (ConPatLazy -> [ConPatLazy])
    -> (ConPatLazy -> ConPatLazy -> [ConPatLazy])
    -> (ConPatLazy -> ConPatLazy -> [ConPatLazy])
    -> (ConPatLazy -> ConPatLazy -> ConPatLazy -> [ConPatLazy])
    -> Enum ConPatLazy
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    enumFromThenTo :: ConPatLazy -> ConPatLazy -> ConPatLazy -> [ConPatLazy]
    $cenumFromThenTo :: ConPatLazy -> ConPatLazy -> ConPatLazy -> [ConPatLazy]
    enumFromTo :: ConPatLazy -> ConPatLazy -> [ConPatLazy]
    $cenumFromTo :: ConPatLazy -> ConPatLazy -> [ConPatLazy]
    enumFromThen :: ConPatLazy -> ConPatLazy -> [ConPatLazy]
    $cenumFromThen :: ConPatLazy -> ConPatLazy -> [ConPatLazy]
    enumFrom :: ConPatLazy -> [ConPatLazy]
    $cenumFrom :: ConPatLazy -> [ConPatLazy]
    fromEnum :: ConPatLazy -> Int
    $cfromEnum :: ConPatLazy -> Int
    toEnum :: Int -> ConPatLazy
    $ctoEnum :: Int -> ConPatLazy
    pred :: ConPatLazy -> ConPatLazy
    $cpred :: ConPatLazy -> ConPatLazy
    succ :: ConPatLazy -> ConPatLazy
    $csucc :: ConPatLazy -> ConPatLazy
    Enum, (forall x. ConPatLazy -> Rep ConPatLazy x)
    -> (forall x. Rep ConPatLazy x -> ConPatLazy) -> Generic ConPatLazy
    forall x. Rep ConPatLazy x -> ConPatLazy
    forall x. ConPatLazy -> Rep ConPatLazy x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ConPatLazy x -> ConPatLazy
    $cfrom :: forall x. ConPatLazy -> Rep ConPatLazy x
    Generic)

    instance NFData ConPatLazy