    {-# LANGUAGE CPP #-}
    -- {-# LANGUAGE UndecidableInstances #-}  -- ghc >= 8.2, GeneralizedNewtypeDeriving MonadTransControl BlockT

    module Agda.TypeChecking.Monad.Base
      ( module Agda.TypeChecking.Monad.Base
      , HasOptions (..)
      ) where

    import Prelude hiding (null)

    import Control.Applicative hiding (empty)
    import qualified Control.Concurrent as C
    import Control.DeepSeq
    import qualified Control.Exception as E

    import qualified Control.Monad.Fail as Fail

    import Control.Monad                ( void )
    import Control.Monad.Except
    import Control.Monad.IO.Class       ( MonadIO(..) )
    import Control.Monad.State          ( MonadState(..), modify, StateT(..), runStateT )
    import Control.Monad.Reader         ( MonadReader(..), ReaderT(..), runReaderT )
    import Control.Monad.Writer         ( WriterT )
    import Control.Monad.Trans          ( MonadTrans(..), lift )
    import Control.Monad.Trans.Control  ( MonadTransControl(..), liftThrough )
    import Control.Monad.Trans.Identity ( IdentityT(..), runIdentityT )
    import Control.Monad.Trans.Maybe    ( MaybeT(..) )

    import Control.Parallel             ( pseq )

    import Data.Array (Ix)
    import Data.Function
    import Data.Int
    import Data.IntMap (IntMap)
    import qualified Data.IntMap as IntMap
    import qualified Data.List as List
    import Data.Maybe
    import Data.Map (Map)
    import qualified Data.Map as Map -- hiding (singleton, null, empty)
    import Data.Sequence (Seq)
    import Data.Set (Set)
    import qualified Data.Set as Set -- hiding (singleton, null, empty)
    import Data.HashMap.Strict (HashMap)
    import qualified Data.HashMap.Strict as HMap
    import Data.Semigroup ( Semigroup, (<>)) --, Any(..) )
    import Data.Data (Data)
    import Data.String
    import Data.Text (Text)
    import qualified Data.Text as T
    import qualified Data.Text.Lazy as TL

    import Data.IORef

    import GHC.Generics (Generic)

    import Agda.Benchmarking (Benchmark, Phase)

    import Agda.Syntax.Concrete (TopLevelModuleName)
    import Agda.Syntax.Common
    import qualified Agda.Syntax.Concrete as C
    import Agda.Syntax.Concrete.Definitions
      (NiceDeclaration, DeclarationWarning, dwWarning, declarationWarningName)
    import qualified Agda.Syntax.Abstract as A
    import Agda.Syntax.Internal as I
    import Agda.Syntax.Internal.MetaVars
    import Agda.Syntax.Internal.Generic (TermLike(..))
    import Agda.Syntax.Parser (ParseWarning)
    import Agda.Syntax.Parser.Monad (parseWarningName)
    import Agda.Syntax.Treeless (Compiled)
    import Agda.Syntax.Notation
    import Agda.Syntax.Position
    import Agda.Syntax.Scope.Base
    import qualified Agda.Syntax.Info as Info

    import Agda.TypeChecking.CompiledClause
    import Agda.TypeChecking.Coverage.SplitTree
    import Agda.TypeChecking.Positivity.Occurrence
    import Agda.TypeChecking.Free.Lazy (Free(freeVars'), underBinder', underBinder)

    -- Args, defined in Agda.Syntax.Treeless and exported from Agda.Compiler.Backend
    -- conflicts with Args, defined in Agda.Syntax.Internal and also imported here.
    -- This only matters when interpreted in ghci, which sees all of the module's
    -- exported symbols, not just the ones defined in the `.hs-boot`. See the
    -- comment in ../../Compiler/Backend.hs-boot
    import {-# SOURCE #-} Agda.Compiler.Backend hiding (Args)

    import Agda.Interaction.Options
    import Agda.Interaction.Options.Warnings
    import {-# SOURCE #-} Agda.Interaction.Response
      (InteractionOutputCallback, defaultInteractionOutputCallback)
    import Agda.Interaction.Highlighting.Precise
      (HighlightingInfo, NameKind)
    import Agda.Interaction.Library

    import Agda.Utils.Benchmark (MonadBench(..))
    import Agda.Utils.BiMap (BiMap, HasTag(..))
    import qualified Agda.Utils.BiMap as BiMap
    import Agda.Utils.CallStack ( CallStack, HasCallStack, withCallerCallStack )
    import Agda.Utils.FileName
    import Agda.Utils.Functor
    import Agda.Utils.Hash
    import Agda.Utils.Lens
    import Agda.Utils.List
    import Agda.Utils.ListT
    import Agda.Utils.List1 (List1, pattern (:|))
    import Agda.Utils.List2 (List2, pattern List2)
    import qualified Agda.Utils.List1 as List1
    import qualified Agda.Utils.Maybe.Strict as Strict
    import Agda.Utils.Monad
    import Agda.Utils.Null
    import Agda.Utils.Permutation
    import Agda.Utils.Pretty
    import Agda.Utils.Singleton
    import Agda.Utils.SmallSet (SmallSet)
    import qualified Agda.Utils.SmallSet as SmallSet
    import Agda.Utils.Update
    import Agda.Utils.WithDefault ( collapseDefault )

    import Agda.Utils.Impossible

    ---------------------------------------------------------------------------
    -- * Type checking state
    ---------------------------------------------------------------------------

    data TCState = TCSt
      { TCState -> PreScopeState
    stPreScopeState   :: !PreScopeState
        -- ^ The state which is frozen after scope checking.
      , TCState -> PostScopeState
    stPostScopeState  :: !PostScopeState
        -- ^ The state which is modified after scope checking.
      , TCState -> PersistentTCState
    stPersistentState :: !PersistentTCState
        -- ^ State which is forever, like a diamond.
      }
      deriving (forall x. TCState -> Rep TCState x)
    -> (forall x. Rep TCState x -> TCState) -> Generic TCState
    forall x. Rep TCState x -> TCState
    forall x. TCState -> Rep TCState x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TCState x -> TCState
    $cfrom :: forall x. TCState -> Rep TCState x
    Generic

    class Monad m => ReadTCState m where
      getTCState :: m TCState
      locallyTCState :: Lens' a TCState -> (a -> a) -> m b -> m b

      withTCState :: (TCState -> TCState) -> m a -> m a
      withTCState = Lens' TCState TCState -> (TCState -> TCState) -> m a -> m a
    forall (m :: * -> *) a b.
    ReadTCState m =>
    Lens' a TCState -> (a -> a) -> m b -> m b
    locallyTCState forall a. a -> a
    Lens' TCState TCState
    id

      default getTCState :: (MonadTrans t, ReadTCState n, t n ~ m) => m TCState
      getTCState = n TCState -> t n TCState
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift n TCState
    forall (m :: * -> *). ReadTCState m => m TCState
    getTCState

      default locallyTCState
        :: (MonadTransControl t, ReadTCState n, t n ~ m)
        => Lens' a TCState -> (a -> a) -> m b -> m b
      locallyTCState Lens' a TCState
    l = (n (StT t b) -> n (StT t b)) -> t n b -> t n b
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b.
    (MonadTransControl t, Monad (t m), Monad m) =>
    (m (StT t a) -> m (StT t b)) -> t m a -> t m b
    liftThrough ((n (StT t b) -> n (StT t b)) -> t n b -> t n b)
    -> ((a -> a) -> n (StT t b) -> n (StT t b))
    -> (a -> a)
    -> t n b
    -> t n b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Lens' a TCState -> (a -> a) -> n (StT t b) -> n (StT t b)
    forall (m :: * -> *) a b.
    ReadTCState m =>
    Lens' a TCState -> (a -> a) -> m b -> m b
    locallyTCState Lens' a TCState
    l

    instance ReadTCState m => ReadTCState (ListT m) where
      locallyTCState :: forall a b. Lens' a TCState -> (a -> a) -> ListT m b -> ListT m b
    locallyTCState Lens' a TCState
    l = (m (Maybe (b, ListT m b)) -> m (Maybe (b, ListT m b)))
    -> ListT m b -> ListT m b
    forall (m :: * -> *) a (n :: * -> *) b.
    (m (Maybe (a, ListT m a)) -> n (Maybe (b, ListT n b)))
    -> ListT m a -> ListT n b
    mapListT ((m (Maybe (b, ListT m b)) -> m (Maybe (b, ListT m b)))
     -> ListT m b -> ListT m b)
    -> ((a -> a)
        -> m (Maybe (b, ListT m b)) -> m (Maybe (b, ListT m b)))
    -> (a -> a)
    -> ListT m b
    -> ListT m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Lens' a TCState
    -> (a -> a) -> m (Maybe (b, ListT m b)) -> m (Maybe (b, ListT m b))
    forall (m :: * -> *) a b.
    ReadTCState m =>
    Lens' a TCState -> (a -> a) -> m b -> m b
    locallyTCState Lens' a TCState
    l

    instance ReadTCState m => ReadTCState (ChangeT m)
    instance ReadTCState m => ReadTCState (ExceptT err m)
    instance ReadTCState m => ReadTCState (IdentityT m)
    instance ReadTCState m => ReadTCState (MaybeT m)
    instance ReadTCState m => ReadTCState (ReaderT r m)
    instance ReadTCState m => ReadTCState (StateT s m)
    instance (Monoid w, ReadTCState m) => ReadTCState (WriterT w m)

    instance Show TCState where
      show :: TCState -> String
    show TCState
    _ = String
    "TCSt{}"

    data PreScopeState = PreScopeState
      { PreScopeState -> HighlightingInfo
    stPreTokens             :: !HighlightingInfo
        -- ^ Highlighting info for tokens and Happy parser warnings (but
        -- not for those tokens/warnings for which highlighting exists in
        -- 'stPostSyntaxInfo').
      , PreScopeState -> Signature
    stPreImports            :: !Signature  -- XX populated by scope checker
        -- ^ Imported declared identifiers.
        --   Those most not be serialized!
      , PreScopeState -> Set ModuleName
    stPreImportedModules    :: !(Set ModuleName)  -- imports logic
      , PreScopeState -> ModuleToSource
    stPreModuleToSource     :: !ModuleToSource   -- imports
      , PreScopeState -> DecodedModules
    stPreVisitedModules     :: !VisitedModules   -- imports
      , PreScopeState -> ScopeInfo
    stPreScope              :: !ScopeInfo
        -- generated by scope checker, current file:
        -- which modules you have, public definitions, current file, maps concrete names to abstract names.
      , PreScopeState -> PatternSynDefns
    stPrePatternSyns        :: !A.PatternSynDefns
        -- ^ Pattern synonyms of the current file.  Serialized.
      , PreScopeState -> PatternSynDefns
    stPrePatternSynImports  :: !A.PatternSynDefns
        -- ^ Imported pattern synonyms.  Must not be serialized!
      , PreScopeState -> Maybe (Set QName)
    stPreGeneralizedVars    :: !(Strict.Maybe (Set QName))
        -- ^ Collected generalizable variables; used during scope checking of terms
      , PreScopeState -> PragmaOptions
    stPrePragmaOptions      :: !PragmaOptions
        -- ^ Options applying to the current file. @OPTIONS@
        -- pragmas only affect this field.
      , PreScopeState -> BuiltinThings PrimFun
    stPreImportedBuiltins   :: !(BuiltinThings PrimFun)
      , PreScopeState -> DisplayForms
    stPreImportedDisplayForms :: !DisplayForms
        -- ^ Display forms added by someone else to imported identifiers
      , PreScopeState -> Map QName (Set QName)
    stPreImportedInstanceDefs :: !InstanceTable
      , PreScopeState -> Map String [ForeignCode]
    stPreForeignCode        :: !(Map BackendName [ForeignCode])
        -- ^ @{-\# FOREIGN \#-}@ code that should be included in the compiled output.
        -- Does not include code for imported modules.
      , PreScopeState -> InteractionId
    stPreFreshInteractionId :: !InteractionId
      , PreScopeState -> Map QName Text
    stPreImportedUserWarnings :: !(Map A.QName Text)
        -- ^ Imported @UserWarning@s, not to be stored in the @Interface@
      , PreScopeState -> Map QName Text
    stPreLocalUserWarnings    :: !(Map A.QName Text)
        -- ^ Locally defined @UserWarning@s, to be stored in the @Interface@
      , PreScopeState -> Maybe Text
    stPreWarningOnImport      :: !(Strict.Maybe Text)
        -- ^ Whether the current module should raise a warning when opened
      , PreScopeState -> Set QName
    stPreImportedPartialDefs :: !(Set QName)
        -- ^ Imported partial definitions, not to be stored in the @Interface@
      , PreScopeState -> Map String ProjectConfig
    stPreProjectConfigs :: !(Map FilePath ProjectConfig)
        -- ^ Map from directories to paths of closest enclosing .agda-lib
        --   files (or @Nothing@ if there are none).
      , PreScopeState -> Map String AgdaLibFile
    stPreAgdaLibFiles   :: !(Map FilePath AgdaLibFile)
        -- ^ Contents of .agda-lib files that have already been parsed.
      }
      deriving (forall x. PreScopeState -> Rep PreScopeState x)
    -> (forall x. Rep PreScopeState x -> PreScopeState)
    -> Generic PreScopeState
    forall x. Rep PreScopeState x -> PreScopeState
    forall x. PreScopeState -> Rep PreScopeState x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PreScopeState x -> PreScopeState
    $cfrom :: forall x. PreScopeState -> Rep PreScopeState x
    Generic

    -- | Name disambiguation for the sake of highlighting.
    data DisambiguatedName = DisambiguatedName NameKind A.QName
      deriving (forall x. DisambiguatedName -> Rep DisambiguatedName x)
    -> (forall x. Rep DisambiguatedName x -> DisambiguatedName)
    -> Generic DisambiguatedName
    forall x. Rep DisambiguatedName x -> DisambiguatedName
    forall x. DisambiguatedName -> Rep DisambiguatedName x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DisambiguatedName x -> DisambiguatedName
    $cfrom :: forall x. DisambiguatedName -> Rep DisambiguatedName x
    Generic
    type DisambiguatedNames = IntMap DisambiguatedName

    type ConcreteNames = Map Name [C.Name]

    data PostScopeState = PostScopeState
      { PostScopeState -> HighlightingInfo
    stPostSyntaxInfo          :: !HighlightingInfo
        -- ^ Highlighting info.
      , PostScopeState -> DisambiguatedNames
    stPostDisambiguatedNames  :: !DisambiguatedNames
        -- ^ Disambiguation carried out by the type checker.
        --   Maps position of first name character to disambiguated @'A.QName'@
        --   for each @'A.AmbiguousQName'@ already passed by the type checker.
      , PostScopeState -> MetaStore
    stPostMetaStore           :: !MetaStore
      , PostScopeState -> InteractionPoints
    stPostInteractionPoints   :: !InteractionPoints -- scope checker first
      , PostScopeState -> Constraints
    stPostAwakeConstraints    :: !Constraints
      , PostScopeState -> Constraints
    stPostSleepingConstraints :: !Constraints
      , PostScopeState -> Bool
    stPostDirty               :: !Bool -- local
        -- ^ Dirty when a constraint is added, used to prevent pointer update.
        -- Currently unused.
      , PostScopeState -> Set QName
    stPostOccursCheckDefs     :: !(Set QName) -- local
        -- ^ Definitions to be considered during occurs check.
        --   Initialized to the current mutual block before the check.
        --   During occurs check, we remove definitions from this set
        --   as soon we have checked them.
      , PostScopeState -> Signature
    stPostSignature           :: !Signature
        -- ^ Declared identifiers of the current file.
        --   These will be serialized after successful type checking.
      , PostScopeState -> Map ModuleName CheckpointId
    stPostModuleCheckpoints   :: !(Map ModuleName CheckpointId)
        -- ^ For each module remember the checkpoint corresponding to the orignal
        --   context of the module parameters.
      , PostScopeState -> DisplayForms
    stPostImportsDisplayForms :: !DisplayForms
        -- ^ Display forms we add for imported identifiers
      , PostScopeState -> Maybe ModuleName
    stPostCurrentModule       :: !(Strict.Maybe ModuleName)
        -- ^ The current module is available after it has been type
        -- checked.
      , PostScopeState -> TempInstanceTable
    stPostInstanceDefs        :: !TempInstanceTable
      , PostScopeState -> ConcreteNames
    stPostConcreteNames       :: !ConcreteNames
        -- ^ Map keeping track of concrete names assigned to each abstract name
        --   (can be more than one name in case the first one is shadowed)
      , PostScopeState -> Map String [String]
    stPostUsedNames           :: !(Map RawName [RawName])
        -- ^ Map keeping track for each name root (= name w/o numeric
        -- suffixes) what names with the same root have been used during a
        -- TC computation. This information is used to build the
        -- @ShadowingNames@ map.
      , PostScopeState -> Map Name [String]
    stPostShadowingNames      :: !(Map Name [RawName])
        -- ^ Map keeping track for each (abstract) name the list of all
        -- (raw) names that it could maybe be shadowed by.
      , PostScopeState -> Statistics
    stPostStatistics          :: !Statistics
        -- ^ Counters to collect various statistics about meta variables etc.
        --   Only for current file.
      , PostScopeState -> [TCWarning]
    stPostTCWarnings          :: ![TCWarning]
      , PostScopeState -> Map MutualId MutualBlock
    stPostMutualBlocks        :: !(Map MutualId MutualBlock)
      , PostScopeState -> BuiltinThings PrimFun
    stPostLocalBuiltins       :: !(BuiltinThings PrimFun)
      , PostScopeState -> MetaId
    stPostFreshMetaId         :: !MetaId
      , PostScopeState -> MutualId
    stPostFreshMutualId       :: !MutualId
      , PostScopeState -> ProblemId
    stPostFreshProblemId      :: !ProblemId
      , PostScopeState -> CheckpointId
    stPostFreshCheckpointId   :: !CheckpointId
      , PostScopeState -> Int
    stPostFreshInt            :: !Int
      , PostScopeState -> NameId
    stPostFreshNameId         :: !NameId
      , PostScopeState -> Bool
    stPostAreWeCaching        :: !Bool
      , PostScopeState -> Bool
    stPostPostponeInstanceSearch :: !Bool
      , PostScopeState -> Bool
    stPostConsideringInstance :: !Bool
      , PostScopeState -> Bool
    stPostInstantiateBlocking :: !Bool
        -- ^ Should we instantiate away blocking metas?
        --   This can produce ill-typed terms but they are often more readable. See issue #3606.
        --   Best set to True only for calls to pretty*/reify to limit unwanted reductions.
      , PostScopeState -> Set QName
    stPostLocalPartialDefs    :: !(Set QName)
        -- ^ Local partial definitions, to be stored in the @Interface@
      }
      deriving ((forall x. PostScopeState -> Rep PostScopeState x)
    -> (forall x. Rep PostScopeState x -> PostScopeState)
    -> Generic PostScopeState
    forall x. Rep PostScopeState x -> PostScopeState
    forall x. PostScopeState -> Rep PostScopeState x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PostScopeState x -> PostScopeState
    $cfrom :: forall x. PostScopeState -> Rep PostScopeState x
    Generic)

    -- | A mutual block of names in the signature.
    data MutualBlock = MutualBlock
      { MutualBlock -> MutualInfo
    mutualInfo  :: Info.MutualInfo
        -- ^ The original info of the mutual block.
      , MutualBlock -> Set QName
    mutualNames :: Set QName
      } deriving (Int -> MutualBlock -> ShowS
    [MutualBlock] -> ShowS
    MutualBlock -> String
    (Int -> MutualBlock -> ShowS)
    -> (MutualBlock -> String)
    -> ([MutualBlock] -> ShowS)
    -> Show MutualBlock
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [MutualBlock] -> ShowS
    $cshowList :: [MutualBlock] -> ShowS
    show :: MutualBlock -> String
    $cshow :: MutualBlock -> String
    showsPrec :: Int -> MutualBlock -> ShowS
    $cshowsPrec :: Int -> MutualBlock -> ShowS
    Show, MutualBlock -> MutualBlock -> Bool
    (MutualBlock -> MutualBlock -> Bool)
    -> (MutualBlock -> MutualBlock -> Bool) -> Eq MutualBlock
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: MutualBlock -> MutualBlock -> Bool
    $c/= :: MutualBlock -> MutualBlock -> Bool
    == :: MutualBlock -> MutualBlock -> Bool
    $c== :: MutualBlock -> MutualBlock -> Bool
    Eq, (forall x. MutualBlock -> Rep MutualBlock x)
    -> (forall x. Rep MutualBlock x -> MutualBlock)
    -> Generic MutualBlock
    forall x. Rep MutualBlock x -> MutualBlock
    forall x. MutualBlock -> Rep MutualBlock x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep MutualBlock x -> MutualBlock
    $cfrom :: forall x. MutualBlock -> Rep MutualBlock x
    Generic)

    instance Null MutualBlock where
      empty :: MutualBlock
    empty = MutualInfo -> Set QName -> MutualBlock
    MutualBlock MutualInfo
    forall a. Null a => a
    empty Set QName
    forall a. Null a => a
    empty

    -- | A part of the state which is not reverted when an error is thrown
    -- or the state is reset.
    data PersistentTCState = PersistentTCSt
      { PersistentTCState -> DecodedModules
    stDecodedModules    :: !DecodedModules
      , PersistentTCState -> CommandLineOptions
    stPersistentOptions :: CommandLineOptions
      , PersistentTCState -> InteractionOutputCallback
    stInteractionOutputCallback  :: InteractionOutputCallback
        -- ^ Callback function to call when there is a response
        --   to give to the interactive frontend.
        --   See the documentation of 'InteractionOutputCallback'.
      , PersistentTCState -> Benchmark
    stBenchmark         :: !Benchmark
        -- ^ Structure to track how much CPU time was spent on which Agda phase.
        --   Needs to be a strict field to avoid space leaks!
      , PersistentTCState -> Statistics
    stAccumStatistics   :: !Statistics
        -- ^ Should be strict field.
      , PersistentTCState -> Maybe LoadedFileCache
    stPersistLoadedFileCache :: !(Strict.Maybe LoadedFileCache)
        -- ^ Cached typechecking state from the last loaded file.
        --   Should be @Nothing@ when checking imports.
      , PersistentTCState -> [Backend]
    stPersistBackends   :: [Backend]
        -- ^ Current backends with their options
      }
      deriving (forall x. PersistentTCState -> Rep PersistentTCState x)
    -> (forall x. Rep PersistentTCState x -> PersistentTCState)
    -> Generic PersistentTCState
    forall x. Rep PersistentTCState x -> PersistentTCState
    forall x. PersistentTCState -> Rep PersistentTCState x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PersistentTCState x -> PersistentTCState
    $cfrom :: forall x. PersistentTCState -> Rep PersistentTCState x
    Generic

    data LoadedFileCache = LoadedFileCache
      { LoadedFileCache -> CachedTypeCheckLog
    lfcCached  :: !CachedTypeCheckLog
      , LoadedFileCache -> CachedTypeCheckLog
    lfcCurrent :: !CurrentTypeCheckLog
      }
      deriving (forall x. LoadedFileCache -> Rep LoadedFileCache x)
    -> (forall x. Rep LoadedFileCache x -> LoadedFileCache)
    -> Generic LoadedFileCache
    forall x. Rep LoadedFileCache x -> LoadedFileCache
    forall x. LoadedFileCache -> Rep LoadedFileCache x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep LoadedFileCache x -> LoadedFileCache
    $cfrom :: forall x. LoadedFileCache -> Rep LoadedFileCache x
    Generic

    -- | A log of what the type checker does and states after the action is
    -- completed.  The cached version is stored first executed action first.
    type CachedTypeCheckLog = [(TypeCheckAction, PostScopeState)]

    -- | Like 'CachedTypeCheckLog', but storing the log for an ongoing type
    -- checking of a module.  Stored in reverse order (last performed action
    -- first).
    type CurrentTypeCheckLog = [(TypeCheckAction, PostScopeState)]

    -- | A complete log for a module will look like this:
    --
    --   * 'Pragmas'
    --
    --   * 'EnterSection', entering the main module.
    --
    --   * 'Decl'/'EnterSection'/'LeaveSection', for declarations and nested
    --     modules
    --
    --   * 'LeaveSection', leaving the main module.
    data TypeCheckAction
      = EnterSection !ModuleName !A.Telescope
      | LeaveSection !ModuleName
      | Decl !A.Declaration
        -- ^ Never a Section or ScopeDecl
      | Pragmas !PragmaOptions
      deriving ((forall x. TypeCheckAction -> Rep TypeCheckAction x)
    -> (forall x. Rep TypeCheckAction x -> TypeCheckAction)
    -> Generic TypeCheckAction
    forall x. Rep TypeCheckAction x -> TypeCheckAction
    forall x. TypeCheckAction -> Rep TypeCheckAction x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TypeCheckAction x -> TypeCheckAction
    $cfrom :: forall x. TypeCheckAction -> Rep TypeCheckAction x
    Generic)

    -- | Empty persistent state.

    initPersistentState :: PersistentTCState
    initPersistentState :: PersistentTCState
    initPersistentState = PersistentTCSt :: DecodedModules
    -> CommandLineOptions
    -> InteractionOutputCallback
    -> Benchmark
    -> Statistics
    -> Maybe LoadedFileCache
    -> [Backend]
    -> PersistentTCState
    PersistentTCSt
      { stPersistentOptions :: CommandLineOptions
    stPersistentOptions         = CommandLineOptions
    defaultOptions
      , stDecodedModules :: DecodedModules
    stDecodedModules            = DecodedModules
    forall k a. Map k a
    Map.empty
      , stInteractionOutputCallback :: InteractionOutputCallback
    stInteractionOutputCallback = InteractionOutputCallback
    defaultInteractionOutputCallback
      , stBenchmark :: Benchmark
    stBenchmark                 = Benchmark
    forall a. Null a => a
    empty
      , stAccumStatistics :: Statistics
    stAccumStatistics           = Statistics
    forall k a. Map k a
    Map.empty
      , stPersistLoadedFileCache :: Maybe LoadedFileCache
    stPersistLoadedFileCache    = Maybe LoadedFileCache
    forall a. Null a => a
    empty
      , stPersistBackends :: [Backend]
    stPersistBackends           = []
      }

    -- | Empty state of type checker.

    initPreScopeState :: PreScopeState
    initPreScopeState :: PreScopeState
    initPreScopeState = PreScopeState :: HighlightingInfo
    -> Signature
    -> Set ModuleName
    -> ModuleToSource
    -> DecodedModules
    -> ScopeInfo
    -> PatternSynDefns
    -> PatternSynDefns
    -> Maybe (Set QName)
    -> PragmaOptions
    -> BuiltinThings PrimFun
    -> DisplayForms
    -> Map QName (Set QName)
    -> Map String [ForeignCode]
    -> InteractionId
    -> Map QName Text
    -> Map QName Text
    -> Maybe Text
    -> Set QName
    -> Map String ProjectConfig
    -> Map String AgdaLibFile
    -> PreScopeState
    PreScopeState
      { stPreTokens :: HighlightingInfo
    stPreTokens               = HighlightingInfo
    forall a. Monoid a => a
    mempty
      , stPreImports :: Signature
    stPreImports              = Signature
    emptySignature
      , stPreImportedModules :: Set ModuleName
    stPreImportedModules      = Set ModuleName
    forall a. Set a
    Set.empty
      , stPreModuleToSource :: ModuleToSource
    stPreModuleToSource       = ModuleToSource
    forall k a. Map k a
    Map.empty
      , stPreVisitedModules :: DecodedModules
    stPreVisitedModules       = DecodedModules
    forall k a. Map k a
    Map.empty
      , stPreScope :: ScopeInfo
    stPreScope                = ScopeInfo
    emptyScopeInfo
      , stPrePatternSyns :: PatternSynDefns
    stPrePatternSyns          = PatternSynDefns
    forall k a. Map k a
    Map.empty
      , stPrePatternSynImports :: PatternSynDefns
    stPrePatternSynImports    = PatternSynDefns
    forall k a. Map k a
    Map.empty
      , stPreGeneralizedVars :: Maybe (Set QName)
    stPreGeneralizedVars      = Maybe (Set QName)
    forall a. Monoid a => a
    mempty
      , stPrePragmaOptions :: PragmaOptions
    stPrePragmaOptions        = PragmaOptions
    defaultInteractionOptions
      , stPreImportedBuiltins :: BuiltinThings PrimFun
    stPreImportedBuiltins     = BuiltinThings PrimFun
    forall k a. Map k a
    Map.empty
      , stPreImportedDisplayForms :: DisplayForms
    stPreImportedDisplayForms = DisplayForms
    forall k v. HashMap k v
    HMap.empty
      , stPreImportedInstanceDefs :: Map QName (Set QName)
    stPreImportedInstanceDefs = Map QName (Set QName)
    forall k a. Map k a
    Map.empty
      , stPreForeignCode :: Map String [ForeignCode]
    stPreForeignCode          = Map String [ForeignCode]
    forall k a. Map k a
    Map.empty
      , stPreFreshInteractionId :: InteractionId
    stPreFreshInteractionId   = InteractionId
    0
      , stPreImportedUserWarnings :: Map QName Text
    stPreImportedUserWarnings = Map QName Text
    forall k a. Map k a
    Map.empty
      , stPreLocalUserWarnings :: Map QName Text
    stPreLocalUserWarnings    = Map QName Text
    forall k a. Map k a
    Map.empty
      , stPreWarningOnImport :: Maybe Text
    stPreWarningOnImport      = Maybe Text
    forall a. Null a => a
    empty
      , stPreImportedPartialDefs :: Set QName
    stPreImportedPartialDefs  = Set QName
    forall a. Set a
    Set.empty
      , stPreProjectConfigs :: Map String ProjectConfig
    stPreProjectConfigs       = Map String ProjectConfig
    forall k a. Map k a
    Map.empty
      , stPreAgdaLibFiles :: Map String AgdaLibFile
    stPreAgdaLibFiles         = Map String AgdaLibFile
    forall k a. Map k a
    Map.empty
      }

    initPostScopeState :: PostScopeState
    initPostScopeState :: PostScopeState
    initPostScopeState = PostScopeState :: HighlightingInfo
    -> DisambiguatedNames
    -> MetaStore
    -> InteractionPoints
    -> Constraints
    -> Constraints
    -> Bool
    -> Set QName
    -> Signature
    -> Map ModuleName CheckpointId
    -> DisplayForms
    -> Maybe ModuleName
    -> TempInstanceTable
    -> ConcreteNames
    -> Map String [String]
    -> Map Name [String]
    -> Statistics
    -> [TCWarning]
    -> Map MutualId MutualBlock
    -> BuiltinThings PrimFun
    -> MetaId
    -> MutualId
    -> ProblemId
    -> CheckpointId
    -> Int
    -> NameId
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> Set QName
    -> PostScopeState
    PostScopeState
      { stPostSyntaxInfo :: HighlightingInfo
    stPostSyntaxInfo           = HighlightingInfo
    forall a. Monoid a => a
    mempty
      , stPostDisambiguatedNames :: DisambiguatedNames
    stPostDisambiguatedNames   = DisambiguatedNames
    forall a. IntMap a
    IntMap.empty
      , stPostMetaStore :: MetaStore
    stPostMetaStore            = MetaStore
    forall a. IntMap a
    IntMap.empty
      , stPostInteractionPoints :: InteractionPoints
    stPostInteractionPoints    = InteractionPoints
    forall a. Null a => a
    empty
      , stPostAwakeConstraints :: Constraints
    stPostAwakeConstraints     = []
      , stPostSleepingConstraints :: Constraints
    stPostSleepingConstraints  = []
      , stPostDirty :: Bool
    stPostDirty                = Bool
    False
      , stPostOccursCheckDefs :: Set QName
    stPostOccursCheckDefs      = Set QName
    forall a. Set a
    Set.empty
      , stPostSignature :: Signature
    stPostSignature            = Signature
    emptySignature
      , stPostModuleCheckpoints :: Map ModuleName CheckpointId
    stPostModuleCheckpoints    = Map ModuleName CheckpointId
    forall k a. Map k a
    Map.empty
      , stPostImportsDisplayForms :: DisplayForms
    stPostImportsDisplayForms  = DisplayForms
    forall k v. HashMap k v
    HMap.empty
      , stPostCurrentModule :: Maybe ModuleName
    stPostCurrentModule        = Maybe ModuleName
    forall a. Null a => a
    empty
      , stPostInstanceDefs :: TempInstanceTable
    stPostInstanceDefs         = (Map QName (Set QName)
    forall k a. Map k a
    Map.empty , Set QName
    forall a. Set a
    Set.empty)
      , stPostConcreteNames :: ConcreteNames
    stPostConcreteNames        = ConcreteNames
    forall k a. Map k a
    Map.empty
      , stPostUsedNames :: Map String [String]
    stPostUsedNames            = Map String [String]
    forall k a. Map k a
    Map.empty
      , stPostShadowingNames :: Map Name [String]
    stPostShadowingNames       = Map Name [String]
    forall k a. Map k a
    Map.empty
      , stPostStatistics :: Statistics
    stPostStatistics           = Statistics
    forall k a. Map k a
    Map.empty
      , stPostTCWarnings :: [TCWarning]
    stPostTCWarnings           = []
      , stPostMutualBlocks :: Map MutualId MutualBlock
    stPostMutualBlocks         = Map MutualId MutualBlock
    forall k a. Map k a
    Map.empty
      , stPostLocalBuiltins :: BuiltinThings PrimFun
    stPostLocalBuiltins        = BuiltinThings PrimFun
    forall k a. Map k a
    Map.empty
      , stPostFreshMetaId :: MetaId
    stPostFreshMetaId          = MetaId
    0
      , stPostFreshMutualId :: MutualId
    stPostFreshMutualId        = MutualId
    0
      , stPostFreshProblemId :: ProblemId
    stPostFreshProblemId       = ProblemId
    1
      , stPostFreshCheckpointId :: CheckpointId
    stPostFreshCheckpointId    = CheckpointId
    1
      , stPostFreshInt :: Int
    stPostFreshInt             = Int
    0
      , stPostFreshNameId :: NameId
    stPostFreshNameId          = Hash -> ModuleNameHash -> NameId
    NameId Hash
    0 ModuleNameHash
    noModuleNameHash
      , stPostAreWeCaching :: Bool
    stPostAreWeCaching         = Bool
    False
      , stPostPostponeInstanceSearch :: Bool
    stPostPostponeInstanceSearch = Bool
    False
      , stPostConsideringInstance :: Bool
    stPostConsideringInstance  = Bool
    False
      , stPostInstantiateBlocking :: Bool
    stPostInstantiateBlocking  = Bool
    False
      , stPostLocalPartialDefs :: Set QName
    stPostLocalPartialDefs     = Set QName
    forall a. Set a
    Set.empty
      }

    initState :: TCState
    initState :: TCState
    initState = TCSt :: PreScopeState -> PostScopeState -> PersistentTCState -> TCState
    TCSt
      { stPreScopeState :: PreScopeState
    stPreScopeState   = PreScopeState
    initPreScopeState
      , stPostScopeState :: PostScopeState
    stPostScopeState  = PostScopeState
    initPostScopeState
      , stPersistentState :: PersistentTCState
    stPersistentState = PersistentTCState
    initPersistentState
      }

    -- * st-prefixed lenses
    ------------------------------------------------------------------------

    stTokens :: Lens' HighlightingInfo TCState
    stTokens :: Lens' HighlightingInfo TCState
    stTokens HighlightingInfo -> f HighlightingInfo
    f TCState
    s =
      HighlightingInfo -> f HighlightingInfo
    f (PreScopeState -> HighlightingInfo
    stPreTokens (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f HighlightingInfo -> (HighlightingInfo -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \HighlightingInfo
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreTokens :: HighlightingInfo
    stPreTokens = HighlightingInfo
    x}}

    stImports :: Lens' Signature TCState
    stImports :: Lens' Signature TCState
    stImports Signature -> f Signature
    f TCState
    s =
      Signature -> f Signature
    f (PreScopeState -> Signature
    stPreImports (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f Signature -> (Signature -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Signature
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreImports :: Signature
    stPreImports = Signature
    x}}

    stImportedModules :: Lens' (Set ModuleName) TCState
    stImportedModules :: Lens' (Set ModuleName) TCState
    stImportedModules Set ModuleName -> f (Set ModuleName)
    f TCState
    s =
      Set ModuleName -> f (Set ModuleName)
    f (PreScopeState -> Set ModuleName
    stPreImportedModules (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Set ModuleName) -> (Set ModuleName -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Set ModuleName
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreImportedModules :: Set ModuleName
    stPreImportedModules = Set ModuleName
    x}}

    stModuleToSource :: Lens' ModuleToSource TCState
    stModuleToSource :: Lens' ModuleToSource TCState
    stModuleToSource ModuleToSource -> f ModuleToSource
    f TCState
    s =
      ModuleToSource -> f ModuleToSource
    f (PreScopeState -> ModuleToSource
    stPreModuleToSource (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f ModuleToSource -> (ModuleToSource -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ModuleToSource
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreModuleToSource :: ModuleToSource
    stPreModuleToSource = ModuleToSource
    x}}

    stVisitedModules :: Lens' VisitedModules TCState
    stVisitedModules :: Lens' DecodedModules TCState
    stVisitedModules DecodedModules -> f DecodedModules
    f TCState
    s =
      DecodedModules -> f DecodedModules
    f (PreScopeState -> DecodedModules
    stPreVisitedModules (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f DecodedModules -> (DecodedModules -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \DecodedModules
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreVisitedModules :: DecodedModules
    stPreVisitedModules = DecodedModules
    x}}

    stScope :: Lens' ScopeInfo TCState
    stScope :: Lens' ScopeInfo TCState
    stScope ScopeInfo -> f ScopeInfo
    f TCState
    s =
      ScopeInfo -> f ScopeInfo
    f (PreScopeState -> ScopeInfo
    stPreScope (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f ScopeInfo -> (ScopeInfo -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ScopeInfo
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreScope :: ScopeInfo
    stPreScope = ScopeInfo
    x}}

    stPatternSyns :: Lens' A.PatternSynDefns TCState
    stPatternSyns :: Lens' PatternSynDefns TCState
    stPatternSyns PatternSynDefns -> f PatternSynDefns
    f TCState
    s =
      PatternSynDefns -> f PatternSynDefns
    f (PreScopeState -> PatternSynDefns
    stPrePatternSyns (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f PatternSynDefns -> (PatternSynDefns -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \PatternSynDefns
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPrePatternSyns :: PatternSynDefns
    stPrePatternSyns = PatternSynDefns
    x}}

    stPatternSynImports :: Lens' A.PatternSynDefns TCState
    stPatternSynImports :: Lens' PatternSynDefns TCState
    stPatternSynImports PatternSynDefns -> f PatternSynDefns
    f TCState
    s =
      PatternSynDefns -> f PatternSynDefns
    f (PreScopeState -> PatternSynDefns
    stPrePatternSynImports (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f PatternSynDefns -> (PatternSynDefns -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \PatternSynDefns
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPrePatternSynImports :: PatternSynDefns
    stPrePatternSynImports = PatternSynDefns
    x}}

    stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState
    stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState
    stGeneralizedVars Maybe (Set QName) -> f (Maybe (Set QName))
    f TCState
    s =
      Maybe (Set QName) -> f (Maybe (Set QName))
    f (Maybe (Set QName) -> Maybe (Set QName)
    forall a. Maybe a -> Maybe a
    Strict.toLazy (Maybe (Set QName) -> Maybe (Set QName))
    -> Maybe (Set QName) -> Maybe (Set QName)
    forall a b. (a -> b) -> a -> b
    $ PreScopeState -> Maybe (Set QName)
    stPreGeneralizedVars (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Maybe (Set QName))
    -> (Maybe (Set QName) -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Maybe (Set QName)
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreGeneralizedVars :: Maybe (Set QName)
    stPreGeneralizedVars = Maybe (Set QName) -> Maybe (Set QName)
    forall a. Maybe a -> Maybe a
    Strict.toStrict Maybe (Set QName)
    x}}

    stPragmaOptions :: Lens' PragmaOptions TCState
    stPragmaOptions :: Lens' PragmaOptions TCState
    stPragmaOptions PragmaOptions -> f PragmaOptions
    f TCState
    s =
      PragmaOptions -> f PragmaOptions
    f (PreScopeState -> PragmaOptions
    stPrePragmaOptions (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f PragmaOptions -> (PragmaOptions -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \PragmaOptions
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPrePragmaOptions :: PragmaOptions
    stPrePragmaOptions = PragmaOptions
    x}}

    stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState
    stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState
    stImportedBuiltins BuiltinThings PrimFun -> f (BuiltinThings PrimFun)
    f TCState
    s =
      BuiltinThings PrimFun -> f (BuiltinThings PrimFun)
    f (PreScopeState -> BuiltinThings PrimFun
    stPreImportedBuiltins (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (BuiltinThings PrimFun)
    -> (BuiltinThings PrimFun -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \BuiltinThings PrimFun
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreImportedBuiltins :: BuiltinThings PrimFun
    stPreImportedBuiltins = BuiltinThings PrimFun
    x}}

    stForeignCode :: Lens' (Map BackendName [ForeignCode]) TCState
    stForeignCode :: Lens' (Map String [ForeignCode]) TCState
    stForeignCode Map String [ForeignCode] -> f (Map String [ForeignCode])
    f TCState
    s =
      Map String [ForeignCode] -> f (Map String [ForeignCode])
    f (PreScopeState -> Map String [ForeignCode]
    stPreForeignCode (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Map String [ForeignCode])
    -> (Map String [ForeignCode] -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Map String [ForeignCode]
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreForeignCode :: Map String [ForeignCode]
    stPreForeignCode = Map String [ForeignCode]
    x}}

    stFreshInteractionId :: Lens' InteractionId TCState
    stFreshInteractionId :: Lens' InteractionId TCState
    stFreshInteractionId InteractionId -> f InteractionId
    f TCState
    s =
      InteractionId -> f InteractionId
    f (PreScopeState -> InteractionId
    stPreFreshInteractionId (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f InteractionId -> (InteractionId -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \InteractionId
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreFreshInteractionId :: InteractionId
    stPreFreshInteractionId = InteractionId
    x}}

    stImportedUserWarnings :: Lens' (Map A.QName Text) TCState
    stImportedUserWarnings :: Lens' (Map QName Text) TCState
    stImportedUserWarnings Map QName Text -> f (Map QName Text)
    f TCState
    s =
      Map QName Text -> f (Map QName Text)
    f (PreScopeState -> Map QName Text
    stPreImportedUserWarnings (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Map QName Text) -> (Map QName Text -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ Map QName Text
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreImportedUserWarnings :: Map QName Text
    stPreImportedUserWarnings = Map QName Text
    x}}

    stLocalUserWarnings :: Lens' (Map A.QName Text) TCState
    stLocalUserWarnings :: Lens' (Map QName Text) TCState
    stLocalUserWarnings Map QName Text -> f (Map QName Text)
    f TCState
    s =
      Map QName Text -> f (Map QName Text)
    f (PreScopeState -> Map QName Text
    stPreLocalUserWarnings (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Map QName Text) -> (Map QName Text -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ Map QName Text
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreLocalUserWarnings :: Map QName Text
    stPreLocalUserWarnings = Map QName Text
    x}}

    getUserWarnings :: ReadTCState m => m (Map A.QName Text)
    getUserWarnings :: forall (m :: * -> *). ReadTCState m => m (Map QName Text)
    getUserWarnings = do
      Map QName Text
    iuw <- Lens' (Map QName Text) TCState -> m (Map QName Text)
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' (Map QName Text) TCState
    stImportedUserWarnings
      Map QName Text
    luw <- Lens' (Map QName Text) TCState -> m (Map QName Text)
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' (Map QName Text) TCState
    stLocalUserWarnings
      Map QName Text -> m (Map QName Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Map QName Text -> m (Map QName Text))
    -> Map QName Text -> m (Map QName Text)
    forall a b. (a -> b) -> a -> b
    $ Map QName Text
    iuw Map QName Text -> Map QName Text -> Map QName Text
    forall k a. Ord k => Map k a -> Map k a -> Map k a
    `Map.union` Map QName Text
    luw

    stWarningOnImport :: Lens' (Maybe Text) TCState
    stWarningOnImport :: Lens' (Maybe Text) TCState
    stWarningOnImport Maybe Text -> f (Maybe Text)
    f TCState
    s =
      Maybe Text -> f (Maybe Text)
    f (Maybe Text -> Maybe Text
    forall a. Maybe a -> Maybe a
    Strict.toLazy (Maybe Text -> Maybe Text) -> Maybe Text -> Maybe Text
    forall a b. (a -> b) -> a -> b
    $ PreScopeState -> Maybe Text
    stPreWarningOnImport (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Maybe Text) -> (Maybe Text -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ Maybe Text
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreWarningOnImport :: Maybe Text
    stPreWarningOnImport = Maybe Text -> Maybe Text
    forall a. Maybe a -> Maybe a
    Strict.toStrict Maybe Text
    x}}

    stImportedPartialDefs :: Lens' (Set QName) TCState
    stImportedPartialDefs :: Lens' (Set QName) TCState
    stImportedPartialDefs Set QName -> f (Set QName)
    f TCState
    s =
      Set QName -> f (Set QName)
    f (PreScopeState -> Set QName
    stPreImportedPartialDefs (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Set QName) -> (Set QName -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ Set QName
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreImportedPartialDefs :: Set QName
    stPreImportedPartialDefs = Set QName
    x}}

    stLocalPartialDefs :: Lens' (Set QName) TCState
    stLocalPartialDefs :: Lens' (Set QName) TCState
    stLocalPartialDefs Set QName -> f (Set QName)
    f TCState
    s =
      Set QName -> f (Set QName)
    f (PostScopeState -> Set QName
    stPostLocalPartialDefs (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f (Set QName) -> (Set QName -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ Set QName
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostLocalPartialDefs :: Set QName
    stPostLocalPartialDefs = Set QName
    x}}

    getPartialDefs :: ReadTCState m => m (Set QName)
    getPartialDefs :: forall (m :: * -> *). ReadTCState m => m (Set QName)
    getPartialDefs = do
      Set QName
    ipd <- Lens' (Set QName) TCState -> m (Set QName)
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' (Set QName) TCState
    stImportedPartialDefs
      Set QName
    lpd <- Lens' (Set QName) TCState -> m (Set QName)
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' (Set QName) TCState
    stLocalPartialDefs
      Set QName -> m (Set QName)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Set QName -> m (Set QName)) -> Set QName -> m (Set QName)
    forall a b. (a -> b) -> a -> b
    $ Set QName
    ipd Set QName -> Set QName -> Set QName
    forall a. Ord a => Set a -> Set a -> Set a
    `Set.union` Set QName
    lpd

    stLoadedFileCache :: Lens' (Maybe LoadedFileCache) TCState
    stLoadedFileCache :: Lens' (Maybe LoadedFileCache) TCState
    stLoadedFileCache Maybe LoadedFileCache -> f (Maybe LoadedFileCache)
    f TCState
    s =
      Maybe LoadedFileCache -> f (Maybe LoadedFileCache)
    f (Maybe LoadedFileCache -> Maybe LoadedFileCache
    forall a. Maybe a -> Maybe a
    Strict.toLazy (Maybe LoadedFileCache -> Maybe LoadedFileCache)
    -> Maybe LoadedFileCache -> Maybe LoadedFileCache
    forall a b. (a -> b) -> a -> b
    $ PersistentTCState -> Maybe LoadedFileCache
    stPersistLoadedFileCache (TCState -> PersistentTCState
    stPersistentState TCState
    s)) f (Maybe LoadedFileCache)
    -> (Maybe LoadedFileCache -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Maybe LoadedFileCache
    x -> TCState
    s {stPersistentState :: PersistentTCState
    stPersistentState = (TCState -> PersistentTCState
    stPersistentState TCState
    s) {stPersistLoadedFileCache :: Maybe LoadedFileCache
    stPersistLoadedFileCache = Maybe LoadedFileCache -> Maybe LoadedFileCache
    forall a. Maybe a -> Maybe a
    Strict.toStrict Maybe LoadedFileCache
    x}}

    stBackends :: Lens' [Backend] TCState
    stBackends :: Lens' [Backend] TCState
    stBackends [Backend] -> f [Backend]
    f TCState
    s =
      [Backend] -> f [Backend]
    f (PersistentTCState -> [Backend]
    stPersistBackends (TCState -> PersistentTCState
    stPersistentState TCState
    s)) f [Backend] -> ([Backend] -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \[Backend]
    x -> TCState
    s {stPersistentState :: PersistentTCState
    stPersistentState = (TCState -> PersistentTCState
    stPersistentState TCState
    s) {stPersistBackends :: [Backend]
    stPersistBackends = [Backend]
    x}}

    stProjectConfigs :: Lens' (Map FilePath ProjectConfig) TCState
    stProjectConfigs :: Lens' (Map String ProjectConfig) TCState
    stProjectConfigs Map String ProjectConfig -> f (Map String ProjectConfig)
    f TCState
    s =
      Map String ProjectConfig -> f (Map String ProjectConfig)
    f (PreScopeState -> Map String ProjectConfig
    stPreProjectConfigs (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Map String ProjectConfig)
    -> (Map String ProjectConfig -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ Map String ProjectConfig
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreProjectConfigs :: Map String ProjectConfig
    stPreProjectConfigs = Map String ProjectConfig
    x}}

    stAgdaLibFiles :: Lens' (Map FilePath AgdaLibFile) TCState
    stAgdaLibFiles :: Lens' (Map String AgdaLibFile) TCState
    stAgdaLibFiles Map String AgdaLibFile -> f (Map String AgdaLibFile)
    f TCState
    s =
      Map String AgdaLibFile -> f (Map String AgdaLibFile)
    f (PreScopeState -> Map String AgdaLibFile
    stPreAgdaLibFiles (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Map String AgdaLibFile)
    -> (Map String AgdaLibFile -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ Map String AgdaLibFile
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreAgdaLibFiles :: Map String AgdaLibFile
    stPreAgdaLibFiles = Map String AgdaLibFile
    x}}

    stFreshNameId :: Lens' NameId TCState
    stFreshNameId :: Lens' NameId TCState
    stFreshNameId NameId -> f NameId
    f TCState
    s =
      NameId -> f NameId
    f (PostScopeState -> NameId
    stPostFreshNameId (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f NameId -> (NameId -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \NameId
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostFreshNameId :: NameId
    stPostFreshNameId = NameId
    x}}

    stSyntaxInfo :: Lens' HighlightingInfo TCState
    stSyntaxInfo :: Lens' HighlightingInfo TCState
    stSyntaxInfo HighlightingInfo -> f HighlightingInfo
    f TCState
    s =
      HighlightingInfo -> f HighlightingInfo
    f (PostScopeState -> HighlightingInfo
    stPostSyntaxInfo (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f HighlightingInfo -> (HighlightingInfo -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \HighlightingInfo
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostSyntaxInfo :: HighlightingInfo
    stPostSyntaxInfo = HighlightingInfo
    x}}

    stDisambiguatedNames :: Lens' DisambiguatedNames TCState
    stDisambiguatedNames :: Lens' DisambiguatedNames TCState
    stDisambiguatedNames DisambiguatedNames -> f DisambiguatedNames
    f TCState
    s =
      DisambiguatedNames -> f DisambiguatedNames
    f (PostScopeState -> DisambiguatedNames
    stPostDisambiguatedNames (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f DisambiguatedNames
    -> (DisambiguatedNames -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \DisambiguatedNames
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostDisambiguatedNames :: DisambiguatedNames
    stPostDisambiguatedNames = DisambiguatedNames
    x}}

    stMetaStore :: Lens' MetaStore TCState
    stMetaStore :: Lens' MetaStore TCState
    stMetaStore MetaStore -> f MetaStore
    f TCState
    s =
      MetaStore -> f MetaStore
    f (PostScopeState -> MetaStore
    stPostMetaStore (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f MetaStore -> (MetaStore -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \MetaStore
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostMetaStore :: MetaStore
    stPostMetaStore = MetaStore
    x}}

    stInteractionPoints :: Lens' InteractionPoints TCState
    stInteractionPoints :: Lens' InteractionPoints TCState
    stInteractionPoints InteractionPoints -> f InteractionPoints
    f TCState
    s =
      InteractionPoints -> f InteractionPoints
    f (PostScopeState -> InteractionPoints
    stPostInteractionPoints (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f InteractionPoints -> (InteractionPoints -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \InteractionPoints
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostInteractionPoints :: InteractionPoints
    stPostInteractionPoints = InteractionPoints
    x}}

    stAwakeConstraints :: Lens' Constraints TCState
    stAwakeConstraints :: Lens' Constraints TCState
    stAwakeConstraints Constraints -> f Constraints
    f TCState
    s =
      Constraints -> f Constraints
    f (PostScopeState -> Constraints
    stPostAwakeConstraints (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Constraints -> (Constraints -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Constraints
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostAwakeConstraints :: Constraints
    stPostAwakeConstraints = Constraints
    x}}

    stSleepingConstraints :: Lens' Constraints TCState
    stSleepingConstraints :: Lens' Constraints TCState
    stSleepingConstraints Constraints -> f Constraints
    f TCState
    s =
      Constraints -> f Constraints
    f (PostScopeState -> Constraints
    stPostSleepingConstraints (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Constraints -> (Constraints -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Constraints
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostSleepingConstraints :: Constraints
    stPostSleepingConstraints = Constraints
    x}}

    stDirty :: Lens' Bool TCState
    stDirty :: Lens' Bool TCState
    stDirty Bool -> f Bool
    f TCState
    s =
      Bool -> f Bool
    f (PostScopeState -> Bool
    stPostDirty (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Bool -> (Bool -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Bool
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostDirty :: Bool
    stPostDirty = Bool
    x}}

    stOccursCheckDefs :: Lens' (Set QName) TCState
    stOccursCheckDefs :: Lens' (Set QName) TCState
    stOccursCheckDefs Set QName -> f (Set QName)
    f TCState
    s =
      Set QName -> f (Set QName)
    f (PostScopeState -> Set QName
    stPostOccursCheckDefs (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f (Set QName) -> (Set QName -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Set QName
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostOccursCheckDefs :: Set QName
    stPostOccursCheckDefs = Set QName
    x}}

    stSignature :: Lens' Signature TCState
    stSignature :: Lens' Signature TCState
    stSignature Signature -> f Signature
    f TCState
    s =
      Signature -> f Signature
    f (PostScopeState -> Signature
    stPostSignature (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Signature -> (Signature -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Signature
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostSignature :: Signature
    stPostSignature = Signature
    x}}

    stModuleCheckpoints :: Lens' (Map ModuleName CheckpointId) TCState
    stModuleCheckpoints :: Lens' (Map ModuleName CheckpointId) TCState
    stModuleCheckpoints Map ModuleName CheckpointId -> f (Map ModuleName CheckpointId)
    f TCState
    s =
      Map ModuleName CheckpointId -> f (Map ModuleName CheckpointId)
    f (PostScopeState -> Map ModuleName CheckpointId
    stPostModuleCheckpoints (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f (Map ModuleName CheckpointId)
    -> (Map ModuleName CheckpointId -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Map ModuleName CheckpointId
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostModuleCheckpoints :: Map ModuleName CheckpointId
    stPostModuleCheckpoints = Map ModuleName CheckpointId
    x}}

    stImportsDisplayForms :: Lens' DisplayForms TCState
    stImportsDisplayForms :: Lens' DisplayForms TCState
    stImportsDisplayForms DisplayForms -> f DisplayForms
    f TCState
    s =
      DisplayForms -> f DisplayForms
    f (PostScopeState -> DisplayForms
    stPostImportsDisplayForms (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f DisplayForms -> (DisplayForms -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \DisplayForms
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostImportsDisplayForms :: DisplayForms
    stPostImportsDisplayForms = DisplayForms
    x}}

    stImportedDisplayForms :: Lens' DisplayForms TCState
    stImportedDisplayForms :: Lens' DisplayForms TCState
    stImportedDisplayForms DisplayForms -> f DisplayForms
    f TCState
    s =
      DisplayForms -> f DisplayForms
    f (PreScopeState -> DisplayForms
    stPreImportedDisplayForms (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f DisplayForms -> (DisplayForms -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \DisplayForms
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreImportedDisplayForms :: DisplayForms
    stPreImportedDisplayForms = DisplayForms
    x}}

    stCurrentModule :: Lens' (Maybe ModuleName) TCState
    stCurrentModule :: Lens' (Maybe ModuleName) TCState
    stCurrentModule Maybe ModuleName -> f (Maybe ModuleName)
    f TCState
    s =
      Maybe ModuleName -> f (Maybe ModuleName)
    f (Maybe ModuleName -> Maybe ModuleName
    forall a. Maybe a -> Maybe a
    Strict.toLazy (Maybe ModuleName -> Maybe ModuleName)
    -> Maybe ModuleName -> Maybe ModuleName
    forall a b. (a -> b) -> a -> b
    $ PostScopeState -> Maybe ModuleName
    stPostCurrentModule (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f (Maybe ModuleName) -> (Maybe ModuleName -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Maybe ModuleName
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostCurrentModule :: Maybe ModuleName
    stPostCurrentModule = Maybe ModuleName -> Maybe ModuleName
    forall a. Maybe a -> Maybe a
    Strict.toStrict Maybe ModuleName
    x}}

    stImportedInstanceDefs :: Lens' InstanceTable TCState
    stImportedInstanceDefs :: Lens' (Map QName (Set QName)) TCState
    stImportedInstanceDefs Map QName (Set QName) -> f (Map QName (Set QName))
    f TCState
    s =
      Map QName (Set QName) -> f (Map QName (Set QName))
    f (PreScopeState -> Map QName (Set QName)
    stPreImportedInstanceDefs (TCState -> PreScopeState
    stPreScopeState TCState
    s)) f (Map QName (Set QName))
    -> (Map QName (Set QName) -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Map QName (Set QName)
    x -> TCState
    s {stPreScopeState :: PreScopeState
    stPreScopeState = (TCState -> PreScopeState
    stPreScopeState TCState
    s) {stPreImportedInstanceDefs :: Map QName (Set QName)
    stPreImportedInstanceDefs = Map QName (Set QName)
    x}}

    stInstanceDefs :: Lens' TempInstanceTable TCState
    stInstanceDefs :: Lens' TempInstanceTable TCState
    stInstanceDefs TempInstanceTable -> f TempInstanceTable
    f TCState
    s =
      TempInstanceTable -> f TempInstanceTable
    f (PostScopeState -> TempInstanceTable
    stPostInstanceDefs (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f TempInstanceTable -> (TempInstanceTable -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \TempInstanceTable
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostInstanceDefs :: TempInstanceTable
    stPostInstanceDefs = TempInstanceTable
    x}}

    stConcreteNames :: Lens' ConcreteNames TCState
    stConcreteNames :: Lens' ConcreteNames TCState
    stConcreteNames ConcreteNames -> f ConcreteNames
    f TCState
    s =
      ConcreteNames -> f ConcreteNames
    f (PostScopeState -> ConcreteNames
    stPostConcreteNames (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f ConcreteNames -> (ConcreteNames -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ConcreteNames
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostConcreteNames :: ConcreteNames
    stPostConcreteNames = ConcreteNames
    x}}

    stUsedNames :: Lens' (Map RawName [RawName]) TCState
    stUsedNames :: Lens' (Map String [String]) TCState
    stUsedNames Map String [String] -> f (Map String [String])
    f TCState
    s =
      Map String [String] -> f (Map String [String])
    f (PostScopeState -> Map String [String]
    stPostUsedNames (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f (Map String [String])
    -> (Map String [String] -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Map String [String]
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostUsedNames :: Map String [String]
    stPostUsedNames = Map String [String]
    x}}

    stShadowingNames :: Lens' (Map Name [RawName]) TCState
    stShadowingNames :: Lens' (Map Name [String]) TCState
    stShadowingNames Map Name [String] -> f (Map Name [String])
    f TCState
    s =
      Map Name [String] -> f (Map Name [String])
    f (PostScopeState -> Map Name [String]
    stPostShadowingNames (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f (Map Name [String])
    -> (Map Name [String] -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Map Name [String]
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostShadowingNames :: Map Name [String]
    stPostShadowingNames = Map Name [String]
    x}}

    stStatistics :: Lens' Statistics TCState
    stStatistics :: Lens' Statistics TCState
    stStatistics Statistics -> f Statistics
    f TCState
    s =
      Statistics -> f Statistics
    f (PostScopeState -> Statistics
    stPostStatistics (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Statistics -> (Statistics -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Statistics
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostStatistics :: Statistics
    stPostStatistics = Statistics
    x}}

    stTCWarnings :: Lens' [TCWarning] TCState
    stTCWarnings :: Lens' [TCWarning] TCState
    stTCWarnings [TCWarning] -> f [TCWarning]
    f TCState
    s =
      [TCWarning] -> f [TCWarning]
    f (PostScopeState -> [TCWarning]
    stPostTCWarnings (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f [TCWarning] -> ([TCWarning] -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \[TCWarning]
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostTCWarnings :: [TCWarning]
    stPostTCWarnings = [TCWarning]
    x}}

    stMutualBlocks :: Lens' (Map MutualId MutualBlock) TCState
    stMutualBlocks :: Lens' (Map MutualId MutualBlock) TCState
    stMutualBlocks Map MutualId MutualBlock -> f (Map MutualId MutualBlock)
    f TCState
    s =
      Map MutualId MutualBlock -> f (Map MutualId MutualBlock)
    f (PostScopeState -> Map MutualId MutualBlock
    stPostMutualBlocks (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f (Map MutualId MutualBlock)
    -> (Map MutualId MutualBlock -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Map MutualId MutualBlock
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostMutualBlocks :: Map MutualId MutualBlock
    stPostMutualBlocks = Map MutualId MutualBlock
    x}}

    stLocalBuiltins :: Lens' (BuiltinThings PrimFun) TCState
    stLocalBuiltins :: Lens' (BuiltinThings PrimFun) TCState
    stLocalBuiltins BuiltinThings PrimFun -> f (BuiltinThings PrimFun)
    f TCState
    s =
      BuiltinThings PrimFun -> f (BuiltinThings PrimFun)
    f (PostScopeState -> BuiltinThings PrimFun
    stPostLocalBuiltins (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f (BuiltinThings PrimFun)
    -> (BuiltinThings PrimFun -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \BuiltinThings PrimFun
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostLocalBuiltins :: BuiltinThings PrimFun
    stPostLocalBuiltins = BuiltinThings PrimFun
    x}}

    stFreshMetaId :: Lens' MetaId TCState
    stFreshMetaId :: Lens' MetaId TCState
    stFreshMetaId MetaId -> f MetaId
    f TCState
    s =
      MetaId -> f MetaId
    f (PostScopeState -> MetaId
    stPostFreshMetaId (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f MetaId -> (MetaId -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \MetaId
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostFreshMetaId :: MetaId
    stPostFreshMetaId = MetaId
    x}}

    stFreshMutualId :: Lens' MutualId TCState
    stFreshMutualId :: Lens' MutualId TCState
    stFreshMutualId MutualId -> f MutualId
    f TCState
    s =
      MutualId -> f MutualId
    f (PostScopeState -> MutualId
    stPostFreshMutualId (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f MutualId -> (MutualId -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \MutualId
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostFreshMutualId :: MutualId
    stPostFreshMutualId = MutualId
    x}}

    stFreshProblemId :: Lens' ProblemId TCState
    stFreshProblemId :: Lens' ProblemId TCState
    stFreshProblemId ProblemId -> f ProblemId
    f TCState
    s =
      ProblemId -> f ProblemId
    f (PostScopeState -> ProblemId
    stPostFreshProblemId (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f ProblemId -> (ProblemId -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ProblemId
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostFreshProblemId :: ProblemId
    stPostFreshProblemId = ProblemId
    x}}

    stFreshCheckpointId :: Lens' CheckpointId TCState
    stFreshCheckpointId :: Lens' CheckpointId TCState
    stFreshCheckpointId CheckpointId -> f CheckpointId
    f TCState
    s =
      CheckpointId -> f CheckpointId
    f (PostScopeState -> CheckpointId
    stPostFreshCheckpointId (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f CheckpointId -> (CheckpointId -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \CheckpointId
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostFreshCheckpointId :: CheckpointId
    stPostFreshCheckpointId = CheckpointId
    x}}

    stFreshInt :: Lens' Int TCState
    stFreshInt :: Lens' Int TCState
    stFreshInt Int -> f Int
    f TCState
    s =
      Int -> f Int
    f (PostScopeState -> Int
    stPostFreshInt (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Int -> (Int -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Int
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostFreshInt :: Int
    stPostFreshInt = Int
    x}}

    -- use @areWeCaching@ from the Caching module instead.
    stAreWeCaching :: Lens' Bool TCState
    stAreWeCaching :: Lens' Bool TCState
    stAreWeCaching Bool -> f Bool
    f TCState
    s =
      Bool -> f Bool
    f (PostScopeState -> Bool
    stPostAreWeCaching (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Bool -> (Bool -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Bool
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostAreWeCaching :: Bool
    stPostAreWeCaching = Bool
    x}}

    stPostponeInstanceSearch :: Lens' Bool TCState
    stPostponeInstanceSearch :: Lens' Bool TCState
    stPostponeInstanceSearch Bool -> f Bool
    f TCState
    s =
      Bool -> f Bool
    f (PostScopeState -> Bool
    stPostPostponeInstanceSearch (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Bool -> (Bool -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Bool
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostPostponeInstanceSearch :: Bool
    stPostPostponeInstanceSearch = Bool
    x}}

    stConsideringInstance :: Lens' Bool TCState
    stConsideringInstance :: Lens' Bool TCState
    stConsideringInstance Bool -> f Bool
    f TCState
    s =
      Bool -> f Bool
    f (PostScopeState -> Bool
    stPostConsideringInstance (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Bool -> (Bool -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Bool
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostConsideringInstance :: Bool
    stPostConsideringInstance = Bool
    x}}

    stInstantiateBlocking :: Lens' Bool TCState
    stInstantiateBlocking :: Lens' Bool TCState
    stInstantiateBlocking Bool -> f Bool
    f TCState
    s =
      Bool -> f Bool
    f (PostScopeState -> Bool
    stPostInstantiateBlocking (TCState -> PostScopeState
    stPostScopeState TCState
    s)) f Bool -> (Bool -> TCState) -> f TCState
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Bool
    x -> TCState
    s {stPostScopeState :: PostScopeState
    stPostScopeState = (TCState -> PostScopeState
    stPostScopeState TCState
    s) {stPostInstantiateBlocking :: Bool
    stPostInstantiateBlocking = Bool
    x}}

    stBuiltinThings :: TCState -> BuiltinThings PrimFun
    stBuiltinThings :: TCState -> BuiltinThings PrimFun
    stBuiltinThings TCState
    s = (TCState
    sTCState
    -> Lens' (BuiltinThings PrimFun) TCState -> BuiltinThings PrimFun
    forall o i. o -> Lens' i o -> i
    ^.Lens' (BuiltinThings PrimFun) TCState
    stLocalBuiltins) BuiltinThings PrimFun
    -> BuiltinThings PrimFun -> BuiltinThings PrimFun
    forall k a. Ord k => Map k a -> Map k a -> Map k a
    `Map.union` (TCState
    sTCState
    -> Lens' (BuiltinThings PrimFun) TCState -> BuiltinThings PrimFun
    forall o i. o -> Lens' i o -> i
    ^.Lens' (BuiltinThings PrimFun) TCState
    stImportedBuiltins)

    -- * Fresh things
    ------------------------------------------------------------------------

    class Enum i => HasFresh i where
        freshLens :: Lens' i TCState
        nextFresh' :: i -> i
        nextFresh' = i -> i
    forall a. Enum a => a -> a
    succ

    nextFresh :: HasFresh i => TCState -> (i, TCState)
    nextFresh :: forall i. HasFresh i => TCState -> (i, TCState)
    nextFresh TCState
    s =
      let !c :: i
    c = TCState
    sTCState -> Lens' i TCState -> i
    forall o i. o -> Lens' i o -> i
    ^.forall i. HasFresh i => Lens' i TCState
    Lens' i TCState
    freshLens
      in (i
    c, Lens' i TCState -> LensSet i TCState
    forall i o. Lens' i o -> LensSet i o
    set forall i. HasFresh i => Lens' i TCState
    Lens' i TCState
    freshLens (i -> i
    forall i. HasFresh i => i -> i
    nextFresh' i
    c) TCState
    s)

    class Monad m => MonadFresh i m where
      fresh :: m i

      default fresh :: (MonadTrans t, MonadFresh i n, t n ~ m) => m i
      fresh = n i -> t n i
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift n i
    forall i (m :: * -> *). MonadFresh i m => m i
    fresh

    instance MonadFresh i m => MonadFresh i (ReaderT r m)
    instance MonadFresh i m => MonadFresh i (StateT s m)
    instance MonadFresh i m => MonadFresh i (ListT m)
    instance MonadFresh i m => MonadFresh i (IdentityT m)

    instance HasFresh i => MonadFresh i TCM where
      fresh :: TCM i
    fresh = do
            !TCState
    s <- TCMT IO TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC
            let (!i
    c , !TCState
    s') = TCState -> (i, TCState)
    forall i. HasFresh i => TCState -> (i, TCState)
    nextFresh TCState
    s
            TCState -> TCMT IO ()
    forall (m :: * -> *). MonadTCState m => TCState -> m ()
    putTC TCState
    s'
            i -> TCM i
    forall (m :: * -> *) a. Monad m => a -> m a
    return i
    c

    instance HasFresh MetaId where
      freshLens :: Lens' MetaId TCState
    freshLens = (MetaId -> f MetaId) -> TCState -> f TCState
    Lens' MetaId TCState
    stFreshMetaId

    instance HasFresh MutualId where
      freshLens :: Lens' MutualId TCState
    freshLens = (MutualId -> f MutualId) -> TCState -> f TCState
    Lens' MutualId TCState
    stFreshMutualId

    instance HasFresh InteractionId where
      freshLens :: Lens' InteractionId TCState
    freshLens = (InteractionId -> f InteractionId) -> TCState -> f TCState
    Lens' InteractionId TCState
    stFreshInteractionId

    instance HasFresh NameId where
      freshLens :: Lens' NameId TCState
    freshLens = (NameId -> f NameId) -> TCState -> f TCState
    Lens' NameId TCState
    stFreshNameId
      -- nextFresh increments the current fresh name by 2 so @NameId@s used
      -- before caching starts do not overlap with the ones used after.
      nextFresh' :: NameId -> NameId
    nextFresh' = NameId -> NameId
    forall a. Enum a => a -> a
    succ (NameId -> NameId) -> (NameId -> NameId) -> NameId -> NameId
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NameId -> NameId
    forall a. Enum a => a -> a
    succ

    instance HasFresh Int where
      freshLens :: Lens' Int TCState
    freshLens = (Int -> f Int) -> TCState -> f TCState
    Lens' Int TCState
    stFreshInt

    instance HasFresh ProblemId where
      freshLens :: Lens' ProblemId TCState
    freshLens = (ProblemId -> f ProblemId) -> TCState -> f TCState
    Lens' ProblemId TCState
    stFreshProblemId

    newtype CheckpointId = CheckpointId Int
      deriving (Typeable CheckpointId
    Typeable CheckpointId
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> CheckpointId -> c CheckpointId)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c CheckpointId)
    -> (CheckpointId -> Constr)
    -> (CheckpointId -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c CheckpointId))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c CheckpointId))
    -> ((forall b. Data b => b -> b) -> CheckpointId -> CheckpointId)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CheckpointId -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CheckpointId -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId)
    -> Data CheckpointId
    CheckpointId -> DataType
    CheckpointId -> Constr
    (forall b. Data b => b -> b) -> CheckpointId -> CheckpointId
    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) -> CheckpointId -> u
    forall u. (forall d. Data d => d -> u) -> CheckpointId -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CheckpointId
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CheckpointId -> c CheckpointId
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CheckpointId)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CheckpointId)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CheckpointId -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CheckpointId -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CheckpointId -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> CheckpointId -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r
    gmapT :: (forall b. Data b => b -> b) -> CheckpointId -> CheckpointId
    $cgmapT :: (forall b. Data b => b -> b) -> CheckpointId -> CheckpointId
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CheckpointId)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CheckpointId)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CheckpointId)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CheckpointId)
    dataTypeOf :: CheckpointId -> DataType
    $cdataTypeOf :: CheckpointId -> DataType
    toConstr :: CheckpointId -> Constr
    $ctoConstr :: CheckpointId -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CheckpointId
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CheckpointId
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CheckpointId -> c CheckpointId
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CheckpointId -> c CheckpointId
    Data, CheckpointId -> CheckpointId -> Bool
    (CheckpointId -> CheckpointId -> Bool)
    -> (CheckpointId -> CheckpointId -> Bool) -> Eq CheckpointId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: CheckpointId -> CheckpointId -> Bool
    $c/= :: CheckpointId -> CheckpointId -> Bool
    == :: CheckpointId -> CheckpointId -> Bool
    $c== :: CheckpointId -> CheckpointId -> Bool
    Eq, Eq CheckpointId
    Eq CheckpointId
    -> (CheckpointId -> CheckpointId -> Ordering)
    -> (CheckpointId -> CheckpointId -> Bool)
    -> (CheckpointId -> CheckpointId -> Bool)
    -> (CheckpointId -> CheckpointId -> Bool)
    -> (CheckpointId -> CheckpointId -> Bool)
    -> (CheckpointId -> CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId -> CheckpointId)
    -> Ord CheckpointId
    CheckpointId -> CheckpointId -> Bool
    CheckpointId -> CheckpointId -> Ordering
    CheckpointId -> CheckpointId -> CheckpointId
    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 :: CheckpointId -> CheckpointId -> CheckpointId
    $cmin :: CheckpointId -> CheckpointId -> CheckpointId
    max :: CheckpointId -> CheckpointId -> CheckpointId
    $cmax :: CheckpointId -> CheckpointId -> CheckpointId
    >= :: CheckpointId -> CheckpointId -> Bool
    $c>= :: CheckpointId -> CheckpointId -> Bool
    > :: CheckpointId -> CheckpointId -> Bool
    $c> :: CheckpointId -> CheckpointId -> Bool
    <= :: CheckpointId -> CheckpointId -> Bool
    $c<= :: CheckpointId -> CheckpointId -> Bool
    < :: CheckpointId -> CheckpointId -> Bool
    $c< :: CheckpointId -> CheckpointId -> Bool
    compare :: CheckpointId -> CheckpointId -> Ordering
    $ccompare :: CheckpointId -> CheckpointId -> Ordering
    Ord, Int -> CheckpointId
    CheckpointId -> Int
    CheckpointId -> [CheckpointId]
    CheckpointId -> CheckpointId
    CheckpointId -> CheckpointId -> [CheckpointId]
    CheckpointId -> CheckpointId -> CheckpointId -> [CheckpointId]
    (CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId)
    -> (Int -> CheckpointId)
    -> (CheckpointId -> Int)
    -> (CheckpointId -> [CheckpointId])
    -> (CheckpointId -> CheckpointId -> [CheckpointId])
    -> (CheckpointId -> CheckpointId -> [CheckpointId])
    -> (CheckpointId -> CheckpointId -> CheckpointId -> [CheckpointId])
    -> Enum CheckpointId
    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 :: CheckpointId -> CheckpointId -> CheckpointId -> [CheckpointId]
    $cenumFromThenTo :: CheckpointId -> CheckpointId -> CheckpointId -> [CheckpointId]
    enumFromTo :: CheckpointId -> CheckpointId -> [CheckpointId]
    $cenumFromTo :: CheckpointId -> CheckpointId -> [CheckpointId]
    enumFromThen :: CheckpointId -> CheckpointId -> [CheckpointId]
    $cenumFromThen :: CheckpointId -> CheckpointId -> [CheckpointId]
    enumFrom :: CheckpointId -> [CheckpointId]
    $cenumFrom :: CheckpointId -> [CheckpointId]
    fromEnum :: CheckpointId -> Int
    $cfromEnum :: CheckpointId -> Int
    toEnum :: Int -> CheckpointId
    $ctoEnum :: Int -> CheckpointId
    pred :: CheckpointId -> CheckpointId
    $cpred :: CheckpointId -> CheckpointId
    succ :: CheckpointId -> CheckpointId
    $csucc :: CheckpointId -> CheckpointId
    Enum, Num CheckpointId
    Ord CheckpointId
    Num CheckpointId
    -> Ord CheckpointId
    -> (CheckpointId -> Rational)
    -> Real CheckpointId
    CheckpointId -> Rational
    forall a. Num a -> Ord a -> (a -> Rational) -> Real a
    toRational :: CheckpointId -> Rational
    $ctoRational :: CheckpointId -> Rational
    Real, Enum CheckpointId
    Real CheckpointId
    Real CheckpointId
    -> Enum CheckpointId
    -> (CheckpointId -> CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId))
    -> (CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId))
    -> (CheckpointId -> Integer)
    -> Integral CheckpointId
    CheckpointId -> Integer
    CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId)
    CheckpointId -> CheckpointId -> CheckpointId
    forall a.
    Real a
    -> Enum a
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    toInteger :: CheckpointId -> Integer
    $ctoInteger :: CheckpointId -> Integer
    divMod :: CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId)
    $cdivMod :: CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId)
    quotRem :: CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId)
    $cquotRem :: CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId)
    mod :: CheckpointId -> CheckpointId -> CheckpointId
    $cmod :: CheckpointId -> CheckpointId -> CheckpointId
    div :: CheckpointId -> CheckpointId -> CheckpointId
    $cdiv :: CheckpointId -> CheckpointId -> CheckpointId
    rem :: CheckpointId -> CheckpointId -> CheckpointId
    $crem :: CheckpointId -> CheckpointId -> CheckpointId
    quot :: CheckpointId -> CheckpointId -> CheckpointId
    $cquot :: CheckpointId -> CheckpointId -> CheckpointId
    Integral, Integer -> CheckpointId
    CheckpointId -> CheckpointId
    CheckpointId -> CheckpointId -> CheckpointId
    (CheckpointId -> CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId)
    -> (CheckpointId -> CheckpointId)
    -> (Integer -> CheckpointId)
    -> Num CheckpointId
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    fromInteger :: Integer -> CheckpointId
    $cfromInteger :: Integer -> CheckpointId
    signum :: CheckpointId -> CheckpointId
    $csignum :: CheckpointId -> CheckpointId
    abs :: CheckpointId -> CheckpointId
    $cabs :: CheckpointId -> CheckpointId
    negate :: CheckpointId -> CheckpointId
    $cnegate :: CheckpointId -> CheckpointId
    * :: CheckpointId -> CheckpointId -> CheckpointId
    $c* :: CheckpointId -> CheckpointId -> CheckpointId
    - :: CheckpointId -> CheckpointId -> CheckpointId
    $c- :: CheckpointId -> CheckpointId -> CheckpointId
    + :: CheckpointId -> CheckpointId -> CheckpointId
    $c+ :: CheckpointId -> CheckpointId -> CheckpointId
    Num, CheckpointId -> ()
    (CheckpointId -> ()) -> NFData CheckpointId
    forall a. (a -> ()) -> NFData a
    rnf :: CheckpointId -> ()
    $crnf :: CheckpointId -> ()
    NFData)

    instance Show CheckpointId where
      show :: CheckpointId -> String
    show (CheckpointId Int
    n) = Int -> String
    forall a. Show a => a -> String
    show Int
    n

    instance Pretty CheckpointId where
      pretty :: CheckpointId -> Doc
    pretty (CheckpointId Int
    n) = Int -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int
    n

    instance HasFresh CheckpointId where
      freshLens :: Lens' CheckpointId TCState
    freshLens = (CheckpointId -> f CheckpointId) -> TCState -> f TCState
    Lens' CheckpointId TCState
    stFreshCheckpointId

    freshName :: MonadFresh NameId m => Range -> String -> m Name
    freshName :: forall (m :: * -> *).
    MonadFresh NameId m =>
    Range -> String -> m Name
    freshName Range
    r String
    s = do
      NameId
    i <- m NameId
    forall i (m :: * -> *). MonadFresh i m => m i
    fresh
      Name -> m Name
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> m Name) -> Name -> m Name
    forall a b. (a -> b) -> a -> b
    $ Range -> NameId -> String -> Name
    forall a. MkName a => Range -> NameId -> a -> Name
    mkName Range
    r NameId
    i String
    s

    freshNoName :: MonadFresh NameId m => Range -> m Name
    freshNoName :: forall (m :: * -> *). MonadFresh NameId m => Range -> m Name
    freshNoName Range
    r =
        do  NameId
    i <- m NameId
    forall i (m :: * -> *). MonadFresh i m => m i
    fresh
            Name -> m Name
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> m Name) -> Name -> m Name
    forall a b. (a -> b) -> a -> b
    $ NameId -> Name -> Range -> Fixity' -> Bool -> Name
    makeName NameId
    i (Range -> NameId -> Name
    C.NoName Range
    forall a. Range' a
    noRange NameId
    i) Range
    r Fixity'
    noFixity' Bool
    False

    freshNoName_ :: MonadFresh NameId m => m Name
    freshNoName_ :: forall (m :: * -> *). MonadFresh NameId m => m Name
    freshNoName_ = Range -> m Name
    forall (m :: * -> *). MonadFresh NameId m => Range -> m Name
    freshNoName Range
    forall a. Range' a
    noRange

    freshRecordName :: MonadFresh NameId m => m Name
    freshRecordName :: forall (m :: * -> *). MonadFresh NameId m => m Name
    freshRecordName = do
      NameId
    i <- m NameId
    forall i (m :: * -> *). MonadFresh i m => m i
    fresh
      Name -> m Name
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Name -> m Name) -> Name -> m Name
    forall a b. (a -> b) -> a -> b
    $ NameId -> Name -> Range -> Fixity' -> Bool -> Name
    makeName NameId
    i (Name -> Name
    forall a. LensInScope a => a -> a
    C.setNotInScope (Name -> Name) -> Name -> Name
    forall a b. (a -> b) -> a -> b
    $ String -> Name
    C.simpleName String
    "r") Range
    forall a. Range' a
    noRange Fixity'
    noFixity' Bool
    True

    -- | Create a fresh name from @a@.
    class FreshName a where
      freshName_ :: MonadFresh NameId m => a -> m Name

    instance FreshName (Range, String) where
      freshName_ :: forall (m :: * -> *).
    MonadFresh NameId m =>
    (Range, String) -> m Name
    freshName_ = (Range -> String -> m Name) -> (Range, String) -> m Name
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Range -> String -> m Name
    forall (m :: * -> *).
    MonadFresh NameId m =>
    Range -> String -> m Name
    freshName

    instance FreshName String where
      freshName_ :: forall (m :: * -> *). MonadFresh NameId m => String -> m Name
    freshName_ = Range -> String -> m Name
    forall (m :: * -> *).
    MonadFresh NameId m =>
    Range -> String -> m Name
    freshName Range
    forall a. Range' a
    noRange

    instance FreshName Range where
      freshName_ :: forall (m :: * -> *). MonadFresh NameId m => Range -> m Name
    freshName_ = Range -> m Name
    forall (m :: * -> *). MonadFresh NameId m => Range -> m Name
    freshNoName

    instance FreshName () where
      freshName_ :: forall (m :: * -> *). MonadFresh NameId m => () -> m Name
    freshName_ () = m Name
    forall (m :: * -> *). MonadFresh NameId m => m Name
    freshNoName_

    ---------------------------------------------------------------------------
    -- ** Managing file names
    ---------------------------------------------------------------------------

    -- | Maps top-level module names to the corresponding source file
    -- names.

    type ModuleToSource = Map TopLevelModuleName AbsolutePath

    -- | Maps source file names to the corresponding top-level module
    -- names.

    type SourceToModule = Map AbsolutePath TopLevelModuleName

    -- | Creates a 'SourceToModule' map based on 'stModuleToSource'.
    --
    --   O(n log n).
    --
    --   For a single reverse lookup in 'stModuleToSource',
    --   rather use 'lookupModuleFromSourse'.

    sourceToModule :: TCM SourceToModule
    sourceToModule :: TCM SourceToModule
    sourceToModule =
      (TopLevelModuleName -> TopLevelModuleName -> TopLevelModuleName)
    -> [(AbsolutePath, TopLevelModuleName)] -> SourceToModule
    forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
    Map.fromListWith TopLevelModuleName -> TopLevelModuleName -> TopLevelModuleName
    forall a. HasCallStack => a
    __IMPOSSIBLE__
         ([(AbsolutePath, TopLevelModuleName)] -> SourceToModule)
    -> (ModuleToSource -> [(AbsolutePath, TopLevelModuleName)])
    -> ModuleToSource
    -> SourceToModule
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .  ((TopLevelModuleName, AbsolutePath)
     -> (AbsolutePath, TopLevelModuleName))
    -> [(TopLevelModuleName, AbsolutePath)]
    -> [(AbsolutePath, TopLevelModuleName)]
    forall a b. (a -> b) -> [a] -> [b]
    List.map (\(TopLevelModuleName
    m, AbsolutePath
    f) -> (AbsolutePath
    f, TopLevelModuleName
    m))
         ([(TopLevelModuleName, AbsolutePath)]
     -> [(AbsolutePath, TopLevelModuleName)])
    -> (ModuleToSource -> [(TopLevelModuleName, AbsolutePath)])
    -> ModuleToSource
    -> [(AbsolutePath, TopLevelModuleName)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .  ModuleToSource -> [(TopLevelModuleName, AbsolutePath)]
    forall k a. Map k a -> [(k, a)]
    Map.toList
        (ModuleToSource -> SourceToModule)
    -> TCMT IO ModuleToSource -> TCM SourceToModule
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Lens' ModuleToSource TCState -> TCMT IO ModuleToSource
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useTC Lens' ModuleToSource TCState
    stModuleToSource

    -- | Lookup an 'AbsolutePath' in 'sourceToModule'.
    --
    --   O(n).

    lookupModuleFromSource :: ReadTCState m => AbsolutePath -> m (Maybe TopLevelModuleName)
    lookupModuleFromSource :: forall (m :: * -> *).
    ReadTCState m =>
    AbsolutePath -> m (Maybe TopLevelModuleName)
    lookupModuleFromSource AbsolutePath
    f =
      ((TopLevelModuleName, AbsolutePath) -> TopLevelModuleName)
    -> Maybe (TopLevelModuleName, AbsolutePath)
    -> Maybe TopLevelModuleName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (TopLevelModuleName, AbsolutePath) -> TopLevelModuleName
    forall a b. (a, b) -> a
    fst (Maybe (TopLevelModuleName, AbsolutePath)
     -> Maybe TopLevelModuleName)
    -> (ModuleToSource -> Maybe (TopLevelModuleName, AbsolutePath))
    -> ModuleToSource
    -> Maybe TopLevelModuleName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((TopLevelModuleName, AbsolutePath) -> Bool)
    -> [(TopLevelModuleName, AbsolutePath)]
    -> Maybe (TopLevelModuleName, AbsolutePath)
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
    List.find ((AbsolutePath
    f AbsolutePath -> AbsolutePath -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) (AbsolutePath -> Bool)
    -> ((TopLevelModuleName, AbsolutePath) -> AbsolutePath)
    -> (TopLevelModuleName, AbsolutePath)
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (TopLevelModuleName, AbsolutePath) -> AbsolutePath
    forall a b. (a, b) -> b
    snd) ([(TopLevelModuleName, AbsolutePath)]
     -> Maybe (TopLevelModuleName, AbsolutePath))
    -> (ModuleToSource -> [(TopLevelModuleName, AbsolutePath)])
    -> ModuleToSource
    -> Maybe (TopLevelModuleName, AbsolutePath)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ModuleToSource -> [(TopLevelModuleName, AbsolutePath)]
    forall k a. Map k a -> [(k, a)]
    Map.toList (ModuleToSource -> Maybe TopLevelModuleName)
    -> m ModuleToSource -> m (Maybe TopLevelModuleName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Lens' ModuleToSource TCState -> m ModuleToSource
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' ModuleToSource TCState
    stModuleToSource

    ---------------------------------------------------------------------------
    -- ** Associating concrete names to an abstract name
    ---------------------------------------------------------------------------

    -- | A monad that has read and write access to the stConcreteNames
    --   part of the TCState. Basically, this is a synonym for `MonadState
    --   ConcreteNames m` (which cannot be used directly because of the
    --   limitations of Haskell's typeclass system).
    class Monad m => MonadStConcreteNames m where
      runStConcreteNames :: StateT ConcreteNames m a -> m a

      useConcreteNames :: m ConcreteNames
      useConcreteNames = StateT ConcreteNames m ConcreteNames -> m ConcreteNames
    forall (m :: * -> *) a.
    MonadStConcreteNames m =>
    StateT ConcreteNames m a -> m a
    runStConcreteNames StateT ConcreteNames m ConcreteNames
    forall s (m :: * -> *). MonadState s m => m s
    get

      modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> m ()
      modifyConcreteNames = StateT ConcreteNames m () -> m ()
    forall (m :: * -> *) a.
    MonadStConcreteNames m =>
    StateT ConcreteNames m a -> m a
    runStConcreteNames (StateT ConcreteNames m () -> m ())
    -> ((ConcreteNames -> ConcreteNames) -> StateT ConcreteNames m ())
    -> (ConcreteNames -> ConcreteNames)
    -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ConcreteNames -> ConcreteNames) -> StateT ConcreteNames m ()
    forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
    modify

    instance MonadStConcreteNames TCM where
      runStConcreteNames :: forall a. StateT ConcreteNames TCM a -> TCM a
    runStConcreteNames StateT ConcreteNames TCM a
    m = Lens' ConcreteNames TCState
    -> (ConcreteNames -> TCM (a, ConcreteNames)) -> TCM a
    forall (m :: * -> *) a r.
    MonadTCState m =>
    Lens' a TCState -> (a -> m (r, a)) -> m r
    stateTCLensM Lens' ConcreteNames TCState
    stConcreteNames ((ConcreteNames -> TCM (a, ConcreteNames)) -> TCM a)
    -> (ConcreteNames -> TCM (a, ConcreteNames)) -> TCM a
    forall a b. (a -> b) -> a -> b
    $ StateT ConcreteNames TCM a
    -> ConcreteNames -> TCM (a, ConcreteNames)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    runStateT StateT ConcreteNames TCM a
    m

    instance MonadStConcreteNames m => MonadStConcreteNames (IdentityT m) where
      runStConcreteNames :: forall a. StateT ConcreteNames (IdentityT m) a -> IdentityT m a
    runStConcreteNames StateT ConcreteNames (IdentityT m) a
    m = m a -> IdentityT m a
    forall {k} (f :: k -> *) (a :: k). f a -> IdentityT f a
    IdentityT (m a -> IdentityT m a) -> m a -> IdentityT m a
    forall a b. (a -> b) -> a -> b
    $ StateT ConcreteNames m a -> m a
    forall (m :: * -> *) a.
    MonadStConcreteNames m =>
    StateT ConcreteNames m a -> m a
    runStConcreteNames (StateT ConcreteNames m a -> m a)
    -> StateT ConcreteNames m a -> m a
    forall a b. (a -> b) -> a -> b
    $ (ConcreteNames -> m (a, ConcreteNames)) -> StateT ConcreteNames m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    StateT ((ConcreteNames -> m (a, ConcreteNames))
     -> StateT ConcreteNames m a)
    -> (ConcreteNames -> m (a, ConcreteNames))
    -> StateT ConcreteNames m a
    forall a b. (a -> b) -> a -> b
    $ IdentityT m (a, ConcreteNames) -> m (a, ConcreteNames)
    forall {k} (f :: k -> *) (a :: k). IdentityT f a -> f a
    runIdentityT (IdentityT m (a, ConcreteNames) -> m (a, ConcreteNames))
    -> (ConcreteNames -> IdentityT m (a, ConcreteNames))
    -> ConcreteNames
    -> m (a, ConcreteNames)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . StateT ConcreteNames (IdentityT m) a
    -> ConcreteNames -> IdentityT m (a, ConcreteNames)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    runStateT StateT ConcreteNames (IdentityT m) a
    m

    instance MonadStConcreteNames m => MonadStConcreteNames (ReaderT r m) where
      runStConcreteNames :: forall a. StateT ConcreteNames (ReaderT r m) a -> ReaderT r m a
    runStConcreteNames StateT ConcreteNames (ReaderT r m) a
    m = (r -> m a) -> ReaderT r m a
    forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
    ReaderT ((r -> m a) -> ReaderT r m a) -> (r -> m a) -> ReaderT r m a
    forall a b. (a -> b) -> a -> b
    $ StateT ConcreteNames m a -> m a
    forall (m :: * -> *) a.
    MonadStConcreteNames m =>
    StateT ConcreteNames m a -> m a
    runStConcreteNames (StateT ConcreteNames m a -> m a)
    -> (r -> StateT ConcreteNames m a) -> r -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ConcreteNames -> m (a, ConcreteNames)) -> StateT ConcreteNames m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    StateT ((ConcreteNames -> m (a, ConcreteNames))
     -> StateT ConcreteNames m a)
    -> (r -> ConcreteNames -> m (a, ConcreteNames))
    -> r
    -> StateT ConcreteNames m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ConcreteNames -> r -> m (a, ConcreteNames))
    -> r -> ConcreteNames -> m (a, ConcreteNames)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (ReaderT r m (a, ConcreteNames) -> r -> m (a, ConcreteNames)
    forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
    runReaderT (ReaderT r m (a, ConcreteNames) -> r -> m (a, ConcreteNames))
    -> (ConcreteNames -> ReaderT r m (a, ConcreteNames))
    -> ConcreteNames
    -> r
    -> m (a, ConcreteNames)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . StateT ConcreteNames (ReaderT r m) a
    -> ConcreteNames -> ReaderT r m (a, ConcreteNames)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    runStateT StateT ConcreteNames (ReaderT r m) a
    m)

    instance MonadStConcreteNames m => MonadStConcreteNames (StateT s m) where
      runStConcreteNames :: forall a. StateT ConcreteNames (StateT s m) a -> StateT s m a
    runStConcreteNames StateT ConcreteNames (StateT s m) a
    m = (s -> m (a, s)) -> StateT s m a
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    StateT ((s -> m (a, s)) -> StateT s m a)
    -> (s -> m (a, s)) -> StateT s m a
    forall a b. (a -> b) -> a -> b
    $ \s
    s -> StateT ConcreteNames m (a, s) -> m (a, s)
    forall (m :: * -> *) a.
    MonadStConcreteNames m =>
    StateT ConcreteNames m a -> m a
    runStConcreteNames (StateT ConcreteNames m (a, s) -> m (a, s))
    -> StateT ConcreteNames m (a, s) -> m (a, s)
    forall a b. (a -> b) -> a -> b
    $ (ConcreteNames -> m ((a, s), ConcreteNames))
    -> StateT ConcreteNames m (a, s)
    forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
    StateT ((ConcreteNames -> m ((a, s), ConcreteNames))
     -> StateT ConcreteNames m (a, s))
    -> (ConcreteNames -> m ((a, s), ConcreteNames))
    -> StateT ConcreteNames m (a, s)
    forall a b. (a -> b) -> a -> b
    $ \ConcreteNames
    ns -> do
        ((a
    x,ConcreteNames
    ns'),s
    s') <- StateT s m (a, ConcreteNames) -> s -> m ((a, ConcreteNames), s)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    runStateT (StateT ConcreteNames (StateT s m) a
    -> ConcreteNames -> StateT s m (a, ConcreteNames)
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
    runStateT StateT ConcreteNames (StateT s m) a
    m ConcreteNames
    ns) s
    s
        ((a, s), ConcreteNames) -> m ((a, s), ConcreteNames)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((a
    x,s
    s'),ConcreteNames
    ns')

    ---------------------------------------------------------------------------
    -- ** Interface
    ---------------------------------------------------------------------------

    -- | Distinguishes between type-checked and scope-checked interfaces
    --   when stored in the map of `VisitedModules`.
    data ModuleCheckMode
      = ModuleScopeChecked
      | ModuleTypeChecked
      deriving (ModuleCheckMode -> ModuleCheckMode -> Bool
    (ModuleCheckMode -> ModuleCheckMode -> Bool)
    -> (ModuleCheckMode -> ModuleCheckMode -> Bool)
    -> Eq ModuleCheckMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ModuleCheckMode -> ModuleCheckMode -> Bool
    $c/= :: ModuleCheckMode -> ModuleCheckMode -> Bool
    == :: ModuleCheckMode -> ModuleCheckMode -> Bool
    $c== :: ModuleCheckMode -> ModuleCheckMode -> Bool
    Eq, Eq ModuleCheckMode
    Eq ModuleCheckMode
    -> (ModuleCheckMode -> ModuleCheckMode -> Ordering)
    -> (ModuleCheckMode -> ModuleCheckMode -> Bool)
    -> (ModuleCheckMode -> ModuleCheckMode -> Bool)
    -> (ModuleCheckMode -> ModuleCheckMode -> Bool)
    -> (ModuleCheckMode -> ModuleCheckMode -> Bool)
    -> (ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode)
    -> (ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode)
    -> Ord ModuleCheckMode
    ModuleCheckMode -> ModuleCheckMode -> Bool
    ModuleCheckMode -> ModuleCheckMode -> Ordering
    ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode
    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 :: ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode
    $cmin :: ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode
    max :: ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode
    $cmax :: ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode
    >= :: ModuleCheckMode -> ModuleCheckMode -> Bool
    $c>= :: ModuleCheckMode -> ModuleCheckMode -> Bool
    > :: ModuleCheckMode -> ModuleCheckMode -> Bool
    $c> :: ModuleCheckMode -> ModuleCheckMode -> Bool
    <= :: ModuleCheckMode -> ModuleCheckMode -> Bool
    $c<= :: ModuleCheckMode -> ModuleCheckMode -> Bool
    < :: ModuleCheckMode -> ModuleCheckMode -> Bool
    $c< :: ModuleCheckMode -> ModuleCheckMode -> Bool
    compare :: ModuleCheckMode -> ModuleCheckMode -> Ordering
    $ccompare :: ModuleCheckMode -> ModuleCheckMode -> Ordering
    Ord, ModuleCheckMode
    ModuleCheckMode -> ModuleCheckMode -> Bounded ModuleCheckMode
    forall a. a -> a -> Bounded a
    maxBound :: ModuleCheckMode
    $cmaxBound :: ModuleCheckMode
    minBound :: ModuleCheckMode
    $cminBound :: ModuleCheckMode
    Bounded, Int -> ModuleCheckMode
    ModuleCheckMode -> Int
    ModuleCheckMode -> [ModuleCheckMode]
    ModuleCheckMode -> ModuleCheckMode
    ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode]
    ModuleCheckMode
    -> ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode]
    (ModuleCheckMode -> ModuleCheckMode)
    -> (ModuleCheckMode -> ModuleCheckMode)
    -> (Int -> ModuleCheckMode)
    -> (ModuleCheckMode -> Int)
    -> (ModuleCheckMode -> [ModuleCheckMode])
    -> (ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode])
    -> (ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode])
    -> (ModuleCheckMode
        -> ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode])
    -> Enum ModuleCheckMode
    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 :: ModuleCheckMode
    -> ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode]
    $cenumFromThenTo :: ModuleCheckMode
    -> ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode]
    enumFromTo :: ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode]
    $cenumFromTo :: ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode]
    enumFromThen :: ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode]
    $cenumFromThen :: ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode]
    enumFrom :: ModuleCheckMode -> [ModuleCheckMode]
    $cenumFrom :: ModuleCheckMode -> [ModuleCheckMode]
    fromEnum :: ModuleCheckMode -> Int
    $cfromEnum :: ModuleCheckMode -> Int
    toEnum :: Int -> ModuleCheckMode
    $ctoEnum :: Int -> ModuleCheckMode
    pred :: ModuleCheckMode -> ModuleCheckMode
    $cpred :: ModuleCheckMode -> ModuleCheckMode
    succ :: ModuleCheckMode -> ModuleCheckMode
    $csucc :: ModuleCheckMode -> ModuleCheckMode
    Enum, Int -> ModuleCheckMode -> ShowS
    [ModuleCheckMode] -> ShowS
    ModuleCheckMode -> String
    (Int -> ModuleCheckMode -> ShowS)
    -> (ModuleCheckMode -> String)
    -> ([ModuleCheckMode] -> ShowS)
    -> Show ModuleCheckMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ModuleCheckMode] -> ShowS
    $cshowList :: [ModuleCheckMode] -> ShowS
    show :: ModuleCheckMode -> String
    $cshow :: ModuleCheckMode -> String
    showsPrec :: Int -> ModuleCheckMode -> ShowS
    $cshowsPrec :: Int -> ModuleCheckMode -> ShowS
    Show, (forall x. ModuleCheckMode -> Rep ModuleCheckMode x)
    -> (forall x. Rep ModuleCheckMode x -> ModuleCheckMode)
    -> Generic ModuleCheckMode
    forall x. Rep ModuleCheckMode x -> ModuleCheckMode
    forall x. ModuleCheckMode -> Rep ModuleCheckMode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ModuleCheckMode x -> ModuleCheckMode
    $cfrom :: forall x. ModuleCheckMode -> Rep ModuleCheckMode x
    Generic)

    data ModuleInfo = ModuleInfo
      { ModuleInfo -> Interface
    miInterface  :: Interface
      , ModuleInfo -> [TCWarning]
    miWarnings   :: [TCWarning]
        -- ^ Warnings were encountered when the module was type checked.
        --   These might include warnings not stored in the interface itself,
        --   specifically unsolved interaction metas.
        --   See "Agda.Interaction.Imports"
      , ModuleInfo -> Bool
    miPrimitive  :: Bool
        -- ^ 'True' if the module is a primitive module, which should always
        -- be importable.
      , ModuleInfo -> ModuleCheckMode
    miMode       :: ModuleCheckMode
        -- ^ The `ModuleCheckMode` used to create the `Interface`
      }
      deriving (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

    -- Note that the use of 'C.TopLevelModuleName' here is a potential
    -- performance problem, because these names do not contain unique
    -- identifiers.

    type VisitedModules = Map C.TopLevelModuleName ModuleInfo
    type DecodedModules = Map C.TopLevelModuleName ModuleInfo

    data ForeignCode = ForeignCode Range String
      deriving (Int -> ForeignCode -> ShowS
    [ForeignCode] -> ShowS
    ForeignCode -> String
    (Int -> ForeignCode -> ShowS)
    -> (ForeignCode -> String)
    -> ([ForeignCode] -> ShowS)
    -> Show ForeignCode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ForeignCode] -> ShowS
    $cshowList :: [ForeignCode] -> ShowS
    show :: ForeignCode -> String
    $cshow :: ForeignCode -> String
    showsPrec :: Int -> ForeignCode -> ShowS
    $cshowsPrec :: Int -> ForeignCode -> ShowS
    Show, (forall x. ForeignCode -> Rep ForeignCode x)
    -> (forall x. Rep ForeignCode x -> ForeignCode)
    -> Generic ForeignCode
    forall x. Rep ForeignCode x -> ForeignCode
    forall x. ForeignCode -> Rep ForeignCode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ForeignCode x -> ForeignCode
    $cfrom :: forall x. ForeignCode -> Rep ForeignCode x
    Generic)

    data Interface = Interface
      { Interface -> Hash
    iSourceHash      :: Hash
        -- ^ Hash of the source code.
      , Interface -> Text
    iSource          :: TL.Text
        -- ^ The source code. The source code is stored so that the HTML
        -- and LaTeX backends can generate their output without having to
        -- re-read the (possibly out of date) source code.
      , Interface -> FileType
    iFileType        :: FileType
        -- ^ Source file type, determined from the file extension
      , Interface -> [(ModuleName, Hash)]
    iImportedModules :: [(ModuleName, Hash)]
        -- ^ Imported modules and their hashes.
      , Interface -> ModuleName
    iModuleName      :: ModuleName
        -- ^ Module name of this interface.
      , Interface -> Map ModuleName Scope
    iScope           :: Map ModuleName Scope
        -- ^ Scope defined by this module.
        --
        --   Andreas, AIM XX: Too avoid duplicate serialization, this field is
        --   not serialized, so if you deserialize an interface, @iScope@
        --   will be empty.
        --   But 'constructIScope' constructs 'iScope' from 'iInsideScope'.
      , Interface -> ScopeInfo
    iInsideScope     :: ScopeInfo
        -- ^ Scope after we loaded this interface.
        --   Used in 'Agda.Interaction.BasicOps.AtTopLevel'
        --   and     'Agda.Interaction.CommandLine.interactionLoop'.
      , Interface -> Signature
    iSignature       :: Signature
      , Interface -> DisplayForms
    iDisplayForms    :: DisplayForms
        -- ^ Display forms added for imported identifiers.
      , Interface -> Map QName Text
    iUserWarnings    :: Map A.QName Text
        -- ^ User warnings for imported identifiers
      , Interface -> Maybe Text
    iImportWarning   :: Maybe Text
        -- ^ Whether this module should raise a warning when imported
      , Interface -> BuiltinThings (String, QName)
    iBuiltin         :: BuiltinThings (String, QName)
      , Interface -> Map String [ForeignCode]
    iForeignCode     :: Map BackendName [ForeignCode]
      , Interface -> HighlightingInfo
    iHighlighting    :: HighlightingInfo
      , Interface -> [[String]]
    iDefaultPragmaOptions :: [OptionsPragma]
        -- ^ Pragma options set in library files.
      , Interface -> [[String]]
    iFilePragmaOptions    :: [OptionsPragma]
        -- ^ Pragma options set in the file.
      , Interface -> PragmaOptions
    iOptionsUsed     :: PragmaOptions
        -- ^ Options/features used when checking the file (can be different
        --   from options set directly in the file).
      , Interface -> PatternSynDefns
    iPatternSyns     :: A.PatternSynDefns
      , Interface -> [TCWarning]
    iWarnings        :: [TCWarning]
      , Interface -> Set QName
    iPartialDefs     :: Set QName
      }
      deriving (Int -> Interface -> ShowS
    [Interface] -> ShowS
    Interface -> String
    (Int -> Interface -> ShowS)
    -> (Interface -> String)
    -> ([Interface] -> ShowS)
    -> Show Interface
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Interface] -> ShowS
    $cshowList :: [Interface] -> ShowS
    show :: Interface -> String
    $cshow :: Interface -> String
    showsPrec :: Int -> Interface -> ShowS
    $cshowsPrec :: Int -> Interface -> ShowS
    Show, (forall x. Interface -> Rep Interface x)
    -> (forall x. Rep Interface x -> Interface) -> Generic Interface
    forall x. Rep Interface x -> Interface
    forall x. Interface -> Rep Interface x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Interface x -> Interface
    $cfrom :: forall x. Interface -> Rep Interface x
    Generic)

    instance Pretty Interface where
      pretty :: Interface -> Doc
    pretty (Interface
                Hash
    sourceH Text
    source FileType
    fileT [(ModuleName, Hash)]
    importedM ModuleName
    moduleN Map ModuleName Scope
    scope ScopeInfo
    insideS Signature
    signature
                DisplayForms
    display Map QName Text
    userwarn Maybe Text
    importwarn BuiltinThings (String, QName)
    builtin Map String [ForeignCode]
    foreignCode HighlightingInfo
    highlighting
                [[String]]
    libPragmaO [[String]]
    filePragmaO
                PragmaOptions
    oUsed PatternSynDefns
    patternS [TCWarning]
    warnings Set QName
    partialdefs) =

        Doc -> Int -> Doc -> Doc
    hang Doc
    "Interface" Int
    2 (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $ [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "source hash:"         Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> (Hash -> String) -> Hash -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Hash -> String
    forall a. Show a => a -> String
    show) Hash
    sourceH
          , Doc
    "source:"              Doc -> Doc -> Doc
    $$  Int -> Doc -> Doc
    nest Int
    2 (String -> Doc
    text (String -> Doc) -> String -> Doc
    forall a b. (a -> b) -> a -> b
    $ Text -> String
    TL.unpack Text
    source)
          , Doc
    "file type:"           Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> (FileType -> String) -> FileType -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FileType -> String
    forall a. Show a => a -> String
    show) FileType
    fileT
          , Doc
    "imported modules:"    Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc)
    -> ([(ModuleName, Hash)] -> String) -> [(ModuleName, Hash)] -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [(ModuleName, Hash)] -> String
    forall a. Show a => a -> String
    show) [(ModuleName, Hash)]
    importedM
          , Doc
    "module name:"         Doc -> Doc -> Doc
    <+> ModuleName -> Doc
    forall a. Pretty a => a -> Doc
    pretty ModuleName
    moduleN
          , Doc
    "scope:"               Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc)
    -> (Map ModuleName Scope -> String) -> Map ModuleName Scope -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Map ModuleName Scope -> String
    forall a. Show a => a -> String
    show) Map ModuleName Scope
    scope
          , Doc
    "inside scope:"        Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> (ScopeInfo -> String) -> ScopeInfo -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ScopeInfo -> String
    forall a. Show a => a -> String
    show) ScopeInfo
    insideS
          , Doc
    "signature:"           Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> (Signature -> String) -> Signature -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Signature -> String
    forall a. Show a => a -> String
    show) Signature
    signature
          , Doc
    "display:"             Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> (DisplayForms -> String) -> DisplayForms -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . DisplayForms -> String
    forall a. Show a => a -> String
    show) DisplayForms
    display
          , Doc
    "user warnings:"       Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc)
    -> (Map QName Text -> String) -> Map QName Text -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Map QName Text -> String
    forall a. Show a => a -> String
    show) Map QName Text
    userwarn
          , Doc
    "import warning:"      Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> (Maybe Text -> String) -> Maybe Text -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Maybe Text -> String
    forall a. Show a => a -> String
    show) Maybe Text
    importwarn
          , Doc
    "builtin:"             Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc)
    -> (BuiltinThings (String, QName) -> String)
    -> BuiltinThings (String, QName)
    -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . BuiltinThings (String, QName) -> String
    forall a. Show a => a -> String
    show) BuiltinThings (String, QName)
    builtin
          , Doc
    "Foreign code:"        Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc)
    -> (Map String [ForeignCode] -> String)
    -> Map String [ForeignCode]
    -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Map String [ForeignCode] -> String
    forall a. Show a => a -> String
    show) Map String [ForeignCode]
    foreignCode
          , Doc
    "highlighting:"        Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc)
    -> (HighlightingInfo -> String) -> HighlightingInfo -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HighlightingInfo -> String
    forall a. Show a => a -> String
    show) HighlightingInfo
    highlighting
          , Doc
    "library pragma options:" Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> ([[String]] -> String) -> [[String]] -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [[String]] -> String
    forall a. Show a => a -> String
    show) [[String]]
    libPragmaO
          , Doc
    "file pragma options:" Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> ([[String]] -> String) -> [[String]] -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [[String]] -> String
    forall a. Show a => a -> String
    show) [[String]]
    filePragmaO
          , Doc
    "options used:"        Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc)
    -> (PragmaOptions -> String) -> PragmaOptions -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PragmaOptions -> String
    forall a. Show a => a -> String
    show) PragmaOptions
    oUsed
          , Doc
    "pattern syns:"        Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc)
    -> (PatternSynDefns -> String) -> PatternSynDefns -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PatternSynDefns -> String
    forall a. Show a => a -> String
    show) PatternSynDefns
    patternS
          , Doc
    "warnings:"            Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> ([TCWarning] -> String) -> [TCWarning] -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [TCWarning] -> String
    forall a. Show a => a -> String
    show) [TCWarning]
    warnings
          , Doc
    "partial definitions:" Doc -> Doc -> Doc
    <+> (String -> Doc
    forall a. Pretty a => a -> Doc
    pretty (String -> Doc) -> (Set QName -> String) -> Set QName -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Set QName -> String
    forall a. Show a => a -> String
    show) Set QName
    partialdefs
          ]

    -- | Combines the source hash and the (full) hashes of the imported modules.
    iFullHash :: Interface -> Hash
    iFullHash :: Interface -> Hash
    iFullHash Interface
    i = [Hash] -> Hash
    combineHashes ([Hash] -> Hash) -> [Hash] -> Hash
    forall a b. (a -> b) -> a -> b
    $ Interface -> Hash
    iSourceHash Interface
    i Hash -> [Hash] -> [Hash]
    forall a. a -> [a] -> [a]
    : ((ModuleName, Hash) -> Hash) -> [(ModuleName, Hash)] -> [Hash]
    forall a b. (a -> b) -> [a] -> [b]
    List.map (ModuleName, Hash) -> Hash
    forall a b. (a, b) -> b
    snd (Interface -> [(ModuleName, Hash)]
    iImportedModules Interface
    i)

    -- | A lens for the 'iSignature' field of the 'Interface' type.

    intSignature :: Lens' Signature Interface
    intSignature :: Lens' Signature Interface
    intSignature Signature -> f Signature
    f Interface
    i = Signature -> f Signature
    f (Interface -> Signature
    iSignature Interface
    i) f Signature -> (Signature -> Interface) -> f Interface
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \Signature
    s -> Interface
    i { iSignature :: Signature
    iSignature = Signature
    s }

    ---------------------------------------------------------------------------
    -- ** Closure
    ---------------------------------------------------------------------------

    data Closure a = Closure
      { forall a. Closure a -> Signature
    clSignature        :: Signature
      , forall a. Closure a -> TCEnv
    clEnv              :: TCEnv
      , forall a. Closure a -> ScopeInfo
    clScope            :: ScopeInfo
      , forall a. Closure a -> Map ModuleName CheckpointId
    clModuleCheckpoints :: Map ModuleName CheckpointId
      , forall a. Closure a -> a
    clValue            :: a
      }
        deriving ((forall a b. (a -> b) -> Closure a -> Closure b)
    -> (forall a b. a -> Closure b -> Closure a) -> Functor Closure
    forall a b. a -> Closure b -> Closure a
    forall a b. (a -> b) -> Closure a -> Closure b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> Closure b -> Closure a
    $c<$ :: forall a b. a -> Closure b -> Closure a
    fmap :: forall a b. (a -> b) -> Closure a -> Closure b
    $cfmap :: forall a b. (a -> b) -> Closure a -> Closure b
    Functor, (forall m. Monoid m => Closure m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Closure a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Closure a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Closure a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Closure a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Closure a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Closure a -> b)
    -> (forall a. (a -> a -> a) -> Closure a -> a)
    -> (forall a. (a -> a -> a) -> Closure a -> a)
    -> (forall a. Closure a -> [a])
    -> (forall a. Closure a -> Bool)
    -> (forall a. Closure a -> Int)
    -> (forall a. Eq a => a -> Closure a -> Bool)
    -> (forall a. Ord a => Closure a -> a)
    -> (forall a. Ord a => Closure a -> a)
    -> (forall a. Num a => Closure a -> a)
    -> (forall a. Num a => Closure a -> a)
    -> Foldable Closure
    forall a. Eq a => a -> Closure a -> Bool
    forall a. Num a => Closure a -> a
    forall a. Ord a => Closure a -> a
    forall m. Monoid m => Closure m -> m
    forall a. Closure a -> Bool
    forall a. Closure a -> Int
    forall a. Closure a -> [a]
    forall a. (a -> a -> a) -> Closure a -> a
    forall m a. Monoid m => (a -> m) -> Closure a -> m
    forall b a. (b -> a -> b) -> b -> Closure a -> b
    forall a b. (a -> b -> b) -> b -> Closure a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => Closure a -> a
    $cproduct :: forall a. Num a => Closure a -> a
    sum :: forall a. Num a => Closure a -> a
    $csum :: forall a. Num a => Closure a -> a
    minimum :: forall a. Ord a => Closure a -> a
    $cminimum :: forall a. Ord a => Closure a -> a
    maximum :: forall a. Ord a => Closure a -> a
    $cmaximum :: forall a. Ord a => Closure a -> a
    elem :: forall a. Eq a => a -> Closure a -> Bool
    $celem :: forall a. Eq a => a -> Closure a -> Bool
    length :: forall a. Closure a -> Int
    $clength :: forall a. Closure a -> Int
    null :: forall a. Closure a -> Bool
    $cnull :: forall a. Closure a -> Bool
    toList :: forall a. Closure a -> [a]
    $ctoList :: forall a. Closure a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> Closure a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Closure a -> a
    foldr1 :: forall a. (a -> a -> a) -> Closure a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> Closure a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> Closure a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Closure a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Closure a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Closure a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Closure a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Closure a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Closure a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Closure a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> Closure a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Closure a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Closure a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Closure a -> m
    fold :: forall m. Monoid m => Closure m -> m
    $cfold :: forall m. Monoid m => Closure m -> m
    Foldable, (forall x. Closure a -> Rep (Closure a) x)
    -> (forall x. Rep (Closure a) x -> Closure a)
    -> Generic (Closure a)
    forall x. Rep (Closure a) x -> Closure a
    forall x. Closure a -> Rep (Closure a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Closure a) x -> Closure a
    forall a x. Closure a -> Rep (Closure a) x
    $cto :: forall a x. Rep (Closure a) x -> Closure a
    $cfrom :: forall a x. Closure a -> Rep (Closure a) x
    Generic)

    instance Show a => Show (Closure a) where
      show :: Closure a -> String
    show Closure a
    cl = String
    "Closure { clValue = " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ a -> String
    forall a. Show a => a -> String
    show (Closure a -> a
    forall a. Closure a -> a
    clValue Closure a
    cl) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " }"

    instance HasRange a => HasRange (Closure a) where
      getRange :: Closure a -> Range
    getRange = a -> Range
    forall a. HasRange a => a -> Range
    getRange (a -> Range) -> (Closure a -> a) -> Closure a -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Closure a -> a
    forall a. Closure a -> a
    clValue

    class LensClosure a b | b -> a where
      lensClosure :: Lens' (Closure a) b

    instance LensClosure a (Closure a) where
      lensClosure :: Lens' (Closure a) (Closure a)
    lensClosure = (Closure a -> f (Closure a)) -> Closure a -> f (Closure a)
    forall a. a -> a
    id

    instance LensTCEnv (Closure a) where
      lensTCEnv :: Lens' TCEnv (Closure a)
    lensTCEnv TCEnv -> f TCEnv
    f Closure a
    cl = (TCEnv -> f TCEnv
    f (TCEnv -> f TCEnv) -> TCEnv -> f TCEnv
    forall a b. (a -> b) -> a -> b
    $! Closure a -> TCEnv
    forall a. Closure a -> TCEnv
    clEnv Closure a
    cl) f TCEnv -> (TCEnv -> Closure a) -> f (Closure a)
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ TCEnv
    env -> Closure a
    cl { clEnv :: TCEnv
    clEnv = TCEnv
    env }

    buildClosure :: (MonadTCEnv m, ReadTCState m) => a -> m (Closure a)
    buildClosure :: forall (m :: * -> *) a.
    (MonadTCEnv m, ReadTCState m) =>
    a -> m (Closure a)
    buildClosure a
    x = do
        TCEnv
    env   <- m TCEnv
    forall (m :: * -> *). MonadTCEnv m => m TCEnv
    askTC
        Signature
    sig   <- Lens' Signature TCState -> m Signature
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' Signature TCState
    stSignature
        ScopeInfo
    scope <- Lens' ScopeInfo TCState -> m ScopeInfo
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' ScopeInfo TCState
    stScope
        Map ModuleName CheckpointId
    cps   <- Lens' (Map ModuleName CheckpointId) TCState
    -> m (Map ModuleName CheckpointId)
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' (Map ModuleName CheckpointId) TCState
    stModuleCheckpoints
        Closure a -> m (Closure a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Closure a -> m (Closure a)) -> Closure a -> m (Closure a)
    forall a b. (a -> b) -> a -> b
    $ Signature
    -> TCEnv
    -> ScopeInfo
    -> Map ModuleName CheckpointId
    -> a
    -> Closure a
    forall a.
    Signature
    -> TCEnv
    -> ScopeInfo
    -> Map ModuleName CheckpointId
    -> a
    -> Closure a
    Closure Signature
    sig TCEnv
    env ScopeInfo
    scope Map ModuleName CheckpointId
    cps a
    x

    ---------------------------------------------------------------------------
    -- ** Constraints
    ---------------------------------------------------------------------------

    type Constraints = [ProblemConstraint]

    data ProblemConstraint = PConstr
      { ProblemConstraint -> Set ProblemId
    constraintProblems  :: Set ProblemId
      , ProblemConstraint -> Blocker
    constraintUnblocker :: Blocker
      , ProblemConstraint -> Closure Constraint
    theConstraint       :: Closure Constraint
      }
      deriving (Int -> ProblemConstraint -> ShowS
    Constraints -> ShowS
    ProblemConstraint -> String
    (Int -> ProblemConstraint -> ShowS)
    -> (ProblemConstraint -> String)
    -> (Constraints -> ShowS)
    -> Show ProblemConstraint
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: Constraints -> ShowS
    $cshowList :: Constraints -> ShowS
    show :: ProblemConstraint -> String
    $cshow :: ProblemConstraint -> String
    showsPrec :: Int -> ProblemConstraint -> ShowS
    $cshowsPrec :: Int -> ProblemConstraint -> ShowS
    Show, (forall x. ProblemConstraint -> Rep ProblemConstraint x)
    -> (forall x. Rep ProblemConstraint x -> ProblemConstraint)
    -> Generic ProblemConstraint
    forall x. Rep ProblemConstraint x -> ProblemConstraint
    forall x. ProblemConstraint -> Rep ProblemConstraint x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ProblemConstraint x -> ProblemConstraint
    $cfrom :: forall x. ProblemConstraint -> Rep ProblemConstraint x
    Generic)

    instance HasRange ProblemConstraint where
      getRange :: ProblemConstraint -> Range
    getRange = Closure Constraint -> Range
    forall a. HasRange a => a -> Range
    getRange (Closure Constraint -> Range)
    -> (ProblemConstraint -> Closure Constraint)
    -> ProblemConstraint
    -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ProblemConstraint -> Closure Constraint
    theConstraint

    data Constraint
      = ValueCmp Comparison CompareAs Term Term
      | ValueCmpOnFace Comparison Term Type Term Term
      | ElimCmp [Polarity] [IsForced] Type Term [Elim] [Elim]
      | SortCmp Comparison Sort Sort
      | LevelCmp Comparison Level Level
    --  | ShortCut MetaId Term Type
    --    -- ^ A delayed instantiation.  Replaces @ValueCmp@ in 'postponeTypeCheckingProblem'.
      | HasBiggerSort Sort
      | HasPTSRule (Dom Type) (Abs Sort)
      | CheckMetaInst MetaId
      | CheckType Type
      | UnBlock MetaId
        -- ^ Meta created for a term blocked by a postponed type checking problem or unsolved
        --   constraints. The 'MetaInstantiation' for the meta (when unsolved) is either 'BlockedConst'
        --   or 'PostponedTypeCheckingProblem'.
      | IsEmpty Range Type
        -- ^ The range is the one of the absurd pattern.
      | CheckSizeLtSat Term
        -- ^ Check that the 'Term' is either not a SIZELT or a non-empty SIZELT.
      | FindInstance MetaId (Maybe [Candidate])
        -- ^ the first argument is the instance argument and the second one is the list of candidates
        --   (or Nothing if we haven’t determined the list of candidates yet)
      | CheckFunDef Delayed A.DefInfo QName [A.Clause] TCErr
        -- ^ Last argument is the error causing us to postpone.
      | UnquoteTactic Term Term Type   -- ^ First argument is computation and the others are hole and goal type
      | CheckLockedVars Term Type (Arg Term) Type     -- ^ @CheckLockedVars t ty lk lk_ty@ with @t : ty@, @lk : lk_ty@ and @t lk@ well-typed.
      | UsableAtModality Modality Term   -- ^ is the term usable at the given modality?
      deriving (Int -> Constraint -> ShowS
    [Constraint] -> ShowS
    Constraint -> String
    (Int -> Constraint -> ShowS)
    -> (Constraint -> String)
    -> ([Constraint] -> ShowS)
    -> Show Constraint
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Constraint] -> ShowS
    $cshowList :: [Constraint] -> ShowS
    show :: Constraint -> String
    $cshow :: Constraint -> String
    showsPrec :: Int -> Constraint -> ShowS
    $cshowsPrec :: Int -> Constraint -> ShowS
    Show, (forall x. Constraint -> Rep Constraint x)
    -> (forall x. Rep Constraint x -> Constraint) -> Generic Constraint
    forall x. Rep Constraint x -> Constraint
    forall x. Constraint -> Rep Constraint x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Constraint x -> Constraint
    $cfrom :: forall x. Constraint -> Rep Constraint x
    Generic)

    instance HasRange Constraint where
      getRange :: Constraint -> Range
    getRange (IsEmpty Range
    r Type
    t) = Range
    r
      getRange Constraint
    _ = Range
    forall a. Range' a
    noRange
    {- no Range instances for Term, Type, Elm, Tele, Sort, Level, MetaId
      getRange (ValueCmp cmp a u v) = getRange (a,u,v)
      getRange (ElimCmp pol a v es es') = getRange (a,v,es,es')
      getRange (TelCmp a b cmp tel tel') = getRange (a,b,tel,tel')
      getRange (SortCmp cmp s s') = getRange (s,s')
      getRange (LevelCmp cmp l l') = getRange (l,l')
      getRange (UnBlock x) = getRange x
      getRange (FindInstance x cands) = getRange x
    -}

    instance Free Constraint where
      freeVars' :: forall a c. IsVarSet a c => Constraint -> FreeM a c
    freeVars' Constraint
    c =
        case Constraint
    c of
          ValueCmp Comparison
    _ CompareAs
    t Term
    u Term
    v      -> (CompareAs, (Term, Term)) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' (CompareAs
    t, (Term
    u, Term
    v))
          ValueCmpOnFace Comparison
    _ Term
    p Type
    t Term
    u Term
    v -> (Term, (Type, (Term, Term))) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' (Term
    p, (Type
    t, (Term
    u, Term
    v)))
          ElimCmp [Polarity]
    _ [IsForced]
    _ Type
    t Term
    u [Elim]
    es [Elim]
    es'  -> ((Type, Term), ([Elim], [Elim])) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' ((Type
    t, Term
    u), ([Elim]
    es, [Elim]
    es'))
          SortCmp Comparison
    _ Sort
    s Sort
    s'        -> (Sort, Sort) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' (Sort
    s, Sort
    s')
          LevelCmp Comparison
    _ Level
    l Level
    l'       -> (Level, Level) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' (Level
    l, Level
    l')
          UnBlock MetaId
    _             -> FreeM a c
    forall a. Monoid a => a
    mempty
          IsEmpty Range
    _ Type
    t           -> Type -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Type
    t
          CheckSizeLtSat Term
    u      -> Term -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Term
    u
          FindInstance MetaId
    _ Maybe [Candidate]
    cs     -> Maybe [Candidate] -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Maybe [Candidate]
    cs
          CheckFunDef{}         -> FreeM a c
    forall a. Monoid a => a
    mempty
          HasBiggerSort Sort
    s       -> Sort -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Sort
    s
          HasPTSRule Dom Type
    a Abs Sort
    s        -> (Dom Type, Abs Sort) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' (Dom Type
    a , Abs Sort
    s)
          CheckLockedVars Term
    a Type
    b Arg Term
    c Type
    d -> ((Term, Type), (Arg Term, Type)) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' ((Term
    a,Type
    b),(Arg Term
    c,Type
    d))
          UnquoteTactic Term
    t Term
    h Type
    g   -> (Term, (Term, Type)) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' (Term
    t, (Term
    h, Type
    g))
          CheckMetaInst MetaId
    m       -> FreeM a c
    forall a. Monoid a => a
    mempty
          CheckType Type
    t           -> Type -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Type
    t
          UsableAtModality Modality
    mod Term
    t -> Term -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Term
    t

    instance TermLike Constraint where
      foldTerm :: forall m. Monoid m => (Term -> m) -> Constraint -> m
    foldTerm Term -> m
    f = \case
          ValueCmp Comparison
    _ CompareAs
    t Term
    u Term
    v       -> (Term -> m) -> (CompareAs, Term, Term) -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f (CompareAs
    t, Term
    u, Term
    v)
          ValueCmpOnFace Comparison
    _ Term
    p Type
    t Term
    u Term
    v -> (Term -> m) -> (Term, Type, Term, Term) -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f (Term
    p, Type
    t, Term
    u, Term
    v)
          ElimCmp [Polarity]
    _ [IsForced]
    _ Type
    t Term
    u [Elim]
    es [Elim]
    es' -> (Term -> m) -> (Type, Term, [Elim], [Elim]) -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f (Type
    t, Term
    u, [Elim]
    es, [Elim]
    es')
          LevelCmp Comparison
    _ Level
    l Level
    l'        -> (Term -> m) -> (Term, Term) -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f (Level -> Term
    Level Level
    l, Level -> Term
    Level Level
    l')  -- Note wrapping as term, to ensure f gets to act on l and l'
          IsEmpty Range
    _ Type
    t            -> (Term -> m) -> Type -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f Type
    t
          CheckSizeLtSat Term
    u       -> (Term -> m) -> Term -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f Term
    u
          UnquoteTactic Term
    t Term
    h Type
    g    -> (Term -> m) -> (Term, Term, Type) -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f (Term
    t, Term
    h, Type
    g)
          SortCmp Comparison
    _ Sort
    s1 Sort
    s2        -> (Term -> m) -> (Term, Term) -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f (Sort -> Term
    Sort Sort
    s1, Sort -> Term
    Sort Sort
    s2)   -- Same as LevelCmp case
          UnBlock MetaId
    _              -> m
    forall a. Monoid a => a
    mempty
          CheckLockedVars Term
    a Type
    b Arg Term
    c Type
    d -> (Term -> m) -> (Term, Type, Arg Term, Type) -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f (Term
    a, Type
    b, Arg Term
    c, Type
    d)
          FindInstance MetaId
    _ Maybe [Candidate]
    _       -> m
    forall a. Monoid a => a
    mempty
          CheckFunDef{}          -> m
    forall a. Monoid a => a
    mempty
          HasBiggerSort Sort
    s        -> (Term -> m) -> Sort -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f Sort
    s
          HasPTSRule Dom Type
    a Abs Sort
    s         -> (Term -> m) -> (Dom Type, Abs Term) -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f (Dom Type
    a, Sort -> Term
    Sort (Sort -> Term) -> Abs Sort -> Abs Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Abs Sort
    s)
          CheckMetaInst MetaId
    m        -> m
    forall a. Monoid a => a
    mempty
          CheckType Type
    t            -> (Term -> m) -> Type -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f Type
    t
          UsableAtModality Modality
    m Term
    t   -> (Term -> m) -> Term -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f Term
    t

      traverseTermM :: forall (m :: * -> *).
    Monad m =>
    (Term -> m Term) -> Constraint -> m Constraint
    traverseTermM Term -> m Term
    f Constraint
    c = m Constraint
    forall a. HasCallStack => a
    __IMPOSSIBLE__ -- Not yet implemented

    instance AllMetas Constraint

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

    instance Pretty Comparison where
      pretty :: Comparison -> Doc
    pretty Comparison
    CmpEq  = Doc
    "="
      pretty Comparison
    CmpLeq = Doc
    "=<"

    -- | An extension of 'Comparison' to @>=@.
    data CompareDirection = DirEq | DirLeq | DirGeq
      deriving (CompareDirection -> CompareDirection -> Bool
    (CompareDirection -> CompareDirection -> Bool)
    -> (CompareDirection -> CompareDirection -> Bool)
    -> Eq CompareDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: CompareDirection -> CompareDirection -> Bool
    $c/= :: CompareDirection -> CompareDirection -> Bool
    == :: CompareDirection -> CompareDirection -> Bool
    $c== :: CompareDirection -> CompareDirection -> Bool
    Eq, Int -> CompareDirection -> ShowS
    [CompareDirection] -> ShowS
    CompareDirection -> String
    (Int -> CompareDirection -> ShowS)
    -> (CompareDirection -> String)
    -> ([CompareDirection] -> ShowS)
    -> Show CompareDirection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [CompareDirection] -> ShowS
    $cshowList :: [CompareDirection] -> ShowS
    show :: CompareDirection -> String
    $cshow :: CompareDirection -> String
    showsPrec :: Int -> CompareDirection -> ShowS
    $cshowsPrec :: Int -> CompareDirection -> ShowS
    Show)

    instance Pretty CompareDirection where
      pretty :: CompareDirection -> Doc
    pretty = String -> Doc
    text (String -> Doc)
    -> (CompareDirection -> String) -> CompareDirection -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . \case
        CompareDirection
    DirEq  -> String
    "="
        CompareDirection
    DirLeq -> String
    "=<"
        CompareDirection
    DirGeq -> String
    ">="

    -- | Embed 'Comparison' into 'CompareDirection'.
    fromCmp :: Comparison -> CompareDirection
    fromCmp :: Comparison -> CompareDirection
    fromCmp Comparison
    CmpEq  = CompareDirection
    DirEq
    fromCmp Comparison
    CmpLeq = CompareDirection
    DirLeq

    -- | Flip the direction of comparison.
    flipCmp :: CompareDirection -> CompareDirection
    flipCmp :: CompareDirection -> CompareDirection
    flipCmp CompareDirection
    DirEq  = CompareDirection
    DirEq
    flipCmp CompareDirection
    DirLeq = CompareDirection
    DirGeq
    flipCmp CompareDirection
    DirGeq = CompareDirection
    DirLeq

    -- | Turn a 'Comparison' function into a 'CompareDirection' function.
    --
    --   Property: @dirToCmp f (fromCmp cmp) = f cmp@
    dirToCmp :: (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c
    dirToCmp :: forall a c.
    (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c
    dirToCmp Comparison -> a -> a -> c
    cont CompareDirection
    DirEq  = Comparison -> a -> a -> c
    cont Comparison
    CmpEq
    dirToCmp Comparison -> a -> a -> c
    cont CompareDirection
    DirLeq = Comparison -> a -> a -> c
    cont Comparison
    CmpLeq
    dirToCmp Comparison -> a -> a -> c
    cont CompareDirection
    DirGeq = (a -> a -> c) -> a -> a -> c
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((a -> a -> c) -> a -> a -> c) -> (a -> a -> c) -> a -> a -> c
    forall a b. (a -> b) -> a -> b
    $ Comparison -> a -> a -> c
    cont Comparison
    CmpLeq

    -- | We can either compare two terms at a given type, or compare two
    --   types without knowing (or caring about) their sorts.
    data CompareAs
      = AsTermsOf Type -- ^ @Type@ should not be @Size@.
                       --   But currently, we do not rely on this invariant.
      | AsSizes        -- ^ Replaces @AsTermsOf Size@.
      | AsTypes
      deriving (Typeable CompareAs
    Typeable CompareAs
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> CompareAs -> c CompareAs)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c CompareAs)
    -> (CompareAs -> Constr)
    -> (CompareAs -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c CompareAs))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompareAs))
    -> ((forall b. Data b => b -> b) -> CompareAs -> CompareAs)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CompareAs -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CompareAs -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CompareAs -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CompareAs -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs)
    -> Data CompareAs
    CompareAs -> DataType
    CompareAs -> Constr
    (forall b. Data b => b -> b) -> CompareAs -> CompareAs
    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) -> CompareAs -> u
    forall u. (forall d. Data d => d -> u) -> CompareAs -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CompareAs -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CompareAs -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CompareAs
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CompareAs -> c CompareAs
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CompareAs)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompareAs)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CompareAs -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CompareAs -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CompareAs -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> CompareAs -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CompareAs -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CompareAs -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CompareAs -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CompareAs -> r
    gmapT :: (forall b. Data b => b -> b) -> CompareAs -> CompareAs
    $cgmapT :: (forall b. Data b => b -> b) -> CompareAs -> CompareAs
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompareAs)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompareAs)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CompareAs)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CompareAs)
    dataTypeOf :: CompareAs -> DataType
    $cdataTypeOf :: CompareAs -> DataType
    toConstr :: CompareAs -> Constr
    $ctoConstr :: CompareAs -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CompareAs
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CompareAs
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CompareAs -> c CompareAs
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CompareAs -> c CompareAs
    Data, Int -> CompareAs -> ShowS
    [CompareAs] -> ShowS
    CompareAs -> String
    (Int -> CompareAs -> ShowS)
    -> (CompareAs -> String)
    -> ([CompareAs] -> ShowS)
    -> Show CompareAs
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [CompareAs] -> ShowS
    $cshowList :: [CompareAs] -> ShowS
    show :: CompareAs -> String
    $cshow :: CompareAs -> String
    showsPrec :: Int -> CompareAs -> ShowS
    $cshowsPrec :: Int -> CompareAs -> ShowS
    Show, (forall x. CompareAs -> Rep CompareAs x)
    -> (forall x. Rep CompareAs x -> CompareAs) -> Generic CompareAs
    forall x. Rep CompareAs x -> CompareAs
    forall x. CompareAs -> Rep CompareAs x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep CompareAs x -> CompareAs
    $cfrom :: forall x. CompareAs -> Rep CompareAs x
    Generic)

    instance Free CompareAs where
      freeVars' :: forall a c. IsVarSet a c => CompareAs -> FreeM a c
    freeVars' (AsTermsOf Type
    a) = Type -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Type
    a
      freeVars' CompareAs
    AsSizes       = FreeM a c
    forall a. Monoid a => a
    mempty
      freeVars' CompareAs
    AsTypes       = FreeM a c
    forall a. Monoid a => a
    mempty

    instance TermLike CompareAs where
      foldTerm :: forall m. Monoid m => (Term -> m) -> CompareAs -> m
    foldTerm Term -> m
    f (AsTermsOf Type
    a) = (Term -> m) -> Type -> m
    forall a m. (TermLike a, Monoid m) => (Term -> m) -> a -> m
    foldTerm Term -> m
    f Type
    a
      foldTerm Term -> m
    f CompareAs
    AsSizes       = m
    forall a. Monoid a => a
    mempty
      foldTerm Term -> m
    f CompareAs
    AsTypes       = m
    forall a. Monoid a => a
    mempty

      traverseTermM :: forall (m :: * -> *).
    Monad m =>
    (Term -> m Term) -> CompareAs -> m CompareAs
    traverseTermM Term -> m Term
    f = \case
        AsTermsOf Type
    a -> Type -> CompareAs
    AsTermsOf (Type -> CompareAs) -> m Type -> m CompareAs
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Term -> m Term) -> Type -> m Type
    forall a (m :: * -> *).
    (TermLike a, Monad m) =>
    (Term -> m Term) -> a -> m a
    traverseTermM Term -> m Term
    f Type
    a
        CompareAs
    AsSizes     -> CompareAs -> m CompareAs
    forall (m :: * -> *) a. Monad m => a -> m a
    return CompareAs
    AsSizes
        CompareAs
    AsTypes     -> CompareAs -> m CompareAs
    forall (m :: * -> *) a. Monad m => a -> m a
    return CompareAs
    AsTypes

    instance AllMetas CompareAs

    ---------------------------------------------------------------------------
    -- * Open things
    ---------------------------------------------------------------------------

    -- | A thing tagged with the context it came from. Also keeps the substitution from previous
    --   checkpoints. This lets us handle the case when an open thing was created in a context that we
    --   have since exited. Remember which module it's from to make sure we don't get confused by
    --   checkpoints from other files.
    data Open a = OpenThing { forall a. Open a -> CheckpointId
    openThingCheckpoint    :: CheckpointId
                            , forall a. Open a -> Map CheckpointId Substitution
    openThingCheckpointMap :: Map CheckpointId Substitution
                            , forall a. Open a -> ModuleNameHash
    openThingModule        :: ModuleNameHash
                            , forall a. Open a -> a
    openThing              :: a }
        deriving (Int -> Open a -> ShowS
    [Open a] -> ShowS
    Open a -> String
    (Int -> Open a -> ShowS)
    -> (Open a -> String) -> ([Open a] -> ShowS) -> Show (Open a)
    forall a. Show a => Int -> Open a -> ShowS
    forall a. Show a => [Open a] -> ShowS
    forall a. Show a => Open a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Open a] -> ShowS
    $cshowList :: forall a. Show a => [Open a] -> ShowS
    show :: Open a -> String
    $cshow :: forall a. Show a => Open a -> String
    showsPrec :: Int -> Open a -> ShowS
    $cshowsPrec :: forall a. Show a => Int -> Open a -> ShowS
    Show, (forall a b. (a -> b) -> Open a -> Open b)
    -> (forall a b. a -> Open b -> Open a) -> Functor Open
    forall a b. a -> Open b -> Open a
    forall a b. (a -> b) -> Open a -> Open b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> Open b -> Open a
    $c<$ :: forall a b. a -> Open b -> Open a
    fmap :: forall a b. (a -> b) -> Open a -> Open b
    $cfmap :: forall a b. (a -> b) -> Open a -> Open b
    Functor, (forall m. Monoid m => Open m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Open a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Open a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Open a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Open a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Open a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Open a -> b)
    -> (forall a. (a -> a -> a) -> Open a -> a)
    -> (forall a. (a -> a -> a) -> Open a -> a)
    -> (forall a. Open a -> [a])
    -> (forall a. Open a -> Bool)
    -> (forall a. Open a -> Int)
    -> (forall a. Eq a => a -> Open a -> Bool)
    -> (forall a. Ord a => Open a -> a)
    -> (forall a. Ord a => Open a -> a)
    -> (forall a. Num a => Open a -> a)
    -> (forall a. Num a => Open a -> a)
    -> Foldable Open
    forall a. Eq a => a -> Open a -> Bool
    forall a. Num a => Open a -> a
    forall a. Ord a => Open a -> a
    forall m. Monoid m => Open m -> m
    forall a. Open a -> Bool
    forall a. Open a -> Int
    forall a. Open a -> [a]
    forall a. (a -> a -> a) -> Open a -> a
    forall m a. Monoid m => (a -> m) -> Open a -> m
    forall b a. (b -> a -> b) -> b -> Open a -> b
    forall a b. (a -> b -> b) -> b -> Open a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => Open a -> a
    $cproduct :: forall a. Num a => Open a -> a
    sum :: forall a. Num a => Open a -> a
    $csum :: forall a. Num a => Open a -> a
    minimum :: forall a. Ord a => Open a -> a
    $cminimum :: forall a. Ord a => Open a -> a
    maximum :: forall a. Ord a => Open a -> a
    $cmaximum :: forall a. Ord a => Open a -> a
    elem :: forall a. Eq a => a -> Open a -> Bool
    $celem :: forall a. Eq a => a -> Open a -> Bool
    length :: forall a. Open a -> Int
    $clength :: forall a. Open a -> Int
    null :: forall a. Open a -> Bool
    $cnull :: forall a. Open a -> Bool
    toList :: forall a. Open a -> [a]
    $ctoList :: forall a. Open a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> Open a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Open a -> a
    foldr1 :: forall a. (a -> a -> a) -> Open a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> Open a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> Open a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Open a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Open a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Open a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Open a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Open a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Open a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Open a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> Open a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Open a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Open a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Open a -> m
    fold :: forall m. Monoid m => Open m -> m
    $cfold :: forall m. Monoid m => Open m -> m
    Foldable, Functor Open
    Foldable Open
    Functor Open
    -> Foldable Open
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> Open a -> f (Open b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Open (f a) -> f (Open a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Open a -> m (Open b))
    -> (forall (m :: * -> *) a. Monad m => Open (m a) -> m (Open a))
    -> Traversable Open
    forall (t :: * -> *).
    Functor t
    -> Foldable t
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Open (m a) -> m (Open a)
    forall (f :: * -> *) a. Applicative f => Open (f a) -> f (Open a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Open a -> m (Open b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Open a -> f (Open b)
    sequence :: forall (m :: * -> *) a. Monad m => Open (m a) -> m (Open a)
    $csequence :: forall (m :: * -> *) a. Monad m => Open (m a) -> m (Open a)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Open a -> m (Open b)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Open a -> m (Open b)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Open (f a) -> f (Open a)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Open (f a) -> f (Open a)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Open a -> f (Open b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Open a -> f (Open b)
    Traversable, (forall x. Open a -> Rep (Open a) x)
    -> (forall x. Rep (Open a) x -> Open a) -> Generic (Open a)
    forall x. Rep (Open a) x -> Open a
    forall x. Open a -> Rep (Open a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Open a) x -> Open a
    forall a x. Open a -> Rep (Open a) x
    $cto :: forall a x. Rep (Open a) x -> Open a
    $cfrom :: forall a x. Open a -> Rep (Open a) x
    Generic)

    instance Decoration Open where
      traverseF :: forall (m :: * -> *) a b.
    Functor m =>
    (a -> m b) -> Open a -> m (Open b)
    traverseF a -> m b
    f (OpenThing CheckpointId
    cp Map CheckpointId Substitution
    env ModuleNameHash
    m a
    x) = CheckpointId
    -> Map CheckpointId Substitution -> ModuleNameHash -> b -> Open b
    forall a.
    CheckpointId
    -> Map CheckpointId Substitution -> ModuleNameHash -> a -> Open a
    OpenThing CheckpointId
    cp Map CheckpointId Substitution
    env ModuleNameHash
    m (b -> Open b) -> m b -> m (Open b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> m b
    f a
    x

    instance Pretty a => Pretty (Open a) where
      prettyPrec :: Int -> Open a -> Doc
    prettyPrec Int
    p (OpenThing CheckpointId
    cp Map CheckpointId Substitution
    env ModuleNameHash
    _ a
    x) = Bool -> Doc -> Doc
    mparens (Int
    p Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    9) (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $
        Doc
    "OpenThing" Doc -> Doc -> Doc
    <+> CheckpointId -> Doc
    forall a. Pretty a => a -> Doc
    pretty CheckpointId
    cp Doc -> Doc -> Doc
    <+> [(CheckpointId, Substitution)] -> Doc
    forall a. Pretty a => a -> Doc
    pretty (Map CheckpointId Substitution -> [(CheckpointId, Substitution)]
    forall k a. Map k a -> [(k, a)]
    Map.toList Map CheckpointId Substitution
    env) Doc -> Doc -> Doc
    <?> Int -> a -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    10 a
    x

    ---------------------------------------------------------------------------
    -- * Judgements
    --
    -- Used exclusively for typing of meta variables.
    ---------------------------------------------------------------------------

    -- | Parametrized since it is used without MetaId when creating a new meta.
    data Judgement a
      = HasType
        { forall a. Judgement a -> a
    jMetaId     :: a
        , forall a. Judgement a -> Comparison
    jComparison :: Comparison -- ^ are we checking (@CmpLeq@) or inferring (@CmpEq@) the type?
        , forall a. Judgement a -> Type
    jMetaType   :: Type
        }
      | IsSort
        { jMetaId   :: a
        , jMetaType :: Type -- Andreas, 2011-04-26: type needed for higher-order sort metas
        }
      deriving (forall x. Judgement a -> Rep (Judgement a) x)
    -> (forall x. Rep (Judgement a) x -> Judgement a)
    -> Generic (Judgement a)
    forall x. Rep (Judgement a) x -> Judgement a
    forall x. Judgement a -> Rep (Judgement a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Judgement a) x -> Judgement a
    forall a x. Judgement a -> Rep (Judgement a) x
    $cto :: forall a x. Rep (Judgement a) x -> Judgement a
    $cfrom :: forall a x. Judgement a -> Rep (Judgement a) x
    Generic

    instance Pretty a => Pretty (Judgement a) where
        pretty :: Judgement a -> Doc
    pretty (HasType a
    a Comparison
    cmp Type
    t) = [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    hsep [ a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    a, Doc
    ":"    , Type -> Doc
    forall a. Pretty a => a -> Doc
    pretty Type
    t ]
        pretty (IsSort  a
    a Type
    t)     = [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    hsep [ a -> Doc
    forall a. Pretty a => a -> Doc
    pretty a
    a, Doc
    ":sort", Type -> Doc
    forall a. Pretty a => a -> Doc
    pretty Type
    t ]

    -----------------------------------------------------------------------------
    -- ** Generalizable variables
    -----------------------------------------------------------------------------

    data DoGeneralize
      = YesGeneralizeVar  -- ^ Generalize because it is a generalizable variable.
      | YesGeneralizeMeta -- ^ Generalize because it is a metavariable and
                          --   we're currently checking the type of a generalizable variable
                          --   (this should get the default modality).
      | NoGeneralize      -- ^ Don't generalize.
      deriving (DoGeneralize -> DoGeneralize -> Bool
    (DoGeneralize -> DoGeneralize -> Bool)
    -> (DoGeneralize -> DoGeneralize -> Bool) -> Eq DoGeneralize
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DoGeneralize -> DoGeneralize -> Bool
    $c/= :: DoGeneralize -> DoGeneralize -> Bool
    == :: DoGeneralize -> DoGeneralize -> Bool
    $c== :: DoGeneralize -> DoGeneralize -> Bool
    Eq, Eq DoGeneralize
    Eq DoGeneralize
    -> (DoGeneralize -> DoGeneralize -> Ordering)
    -> (DoGeneralize -> DoGeneralize -> Bool)
    -> (DoGeneralize -> DoGeneralize -> Bool)
    -> (DoGeneralize -> DoGeneralize -> Bool)
    -> (DoGeneralize -> DoGeneralize -> Bool)
    -> (DoGeneralize -> DoGeneralize -> DoGeneralize)
    -> (DoGeneralize -> DoGeneralize -> DoGeneralize)
    -> Ord DoGeneralize
    DoGeneralize -> DoGeneralize -> Bool
    DoGeneralize -> DoGeneralize -> Ordering
    DoGeneralize -> DoGeneralize -> DoGeneralize
    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 :: DoGeneralize -> DoGeneralize -> DoGeneralize
    $cmin :: DoGeneralize -> DoGeneralize -> DoGeneralize
    max :: DoGeneralize -> DoGeneralize -> DoGeneralize
    $cmax :: DoGeneralize -> DoGeneralize -> DoGeneralize
    >= :: DoGeneralize -> DoGeneralize -> Bool
    $c>= :: DoGeneralize -> DoGeneralize -> Bool
    > :: DoGeneralize -> DoGeneralize -> Bool
    $c> :: DoGeneralize -> DoGeneralize -> Bool
    <= :: DoGeneralize -> DoGeneralize -> Bool
    $c<= :: DoGeneralize -> DoGeneralize -> Bool
    < :: DoGeneralize -> DoGeneralize -> Bool
    $c< :: DoGeneralize -> DoGeneralize -> Bool
    compare :: DoGeneralize -> DoGeneralize -> Ordering
    $ccompare :: DoGeneralize -> DoGeneralize -> Ordering
    Ord, Int -> DoGeneralize -> ShowS
    [DoGeneralize] -> ShowS
    DoGeneralize -> String
    (Int -> DoGeneralize -> ShowS)
    -> (DoGeneralize -> String)
    -> ([DoGeneralize] -> ShowS)
    -> Show DoGeneralize
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [DoGeneralize] -> ShowS
    $cshowList :: [DoGeneralize] -> ShowS
    show :: DoGeneralize -> String
    $cshow :: DoGeneralize -> String
    showsPrec :: Int -> DoGeneralize -> ShowS
    $cshowsPrec :: Int -> DoGeneralize -> ShowS
    Show, Typeable DoGeneralize
    Typeable DoGeneralize
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> DoGeneralize -> c DoGeneralize)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DoGeneralize)
    -> (DoGeneralize -> Constr)
    -> (DoGeneralize -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DoGeneralize))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DoGeneralize))
    -> ((forall b. Data b => b -> b) -> DoGeneralize -> DoGeneralize)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DoGeneralize -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DoGeneralize -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize)
    -> Data DoGeneralize
    DoGeneralize -> DataType
    DoGeneralize -> Constr
    (forall b. Data b => b -> b) -> DoGeneralize -> DoGeneralize
    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) -> DoGeneralize -> u
    forall u. (forall d. Data d => d -> u) -> DoGeneralize -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DoGeneralize
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DoGeneralize -> c DoGeneralize
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DoGeneralize)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DoGeneralize)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DoGeneralize -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DoGeneralize -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DoGeneralize -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DoGeneralize -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r
    gmapT :: (forall b. Data b => b -> b) -> DoGeneralize -> DoGeneralize
    $cgmapT :: (forall b. Data b => b -> b) -> DoGeneralize -> DoGeneralize
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DoGeneralize)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DoGeneralize)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DoGeneralize)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DoGeneralize)
    dataTypeOf :: DoGeneralize -> DataType
    $cdataTypeOf :: DoGeneralize -> DataType
    toConstr :: DoGeneralize -> Constr
    $ctoConstr :: DoGeneralize -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DoGeneralize
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DoGeneralize
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DoGeneralize -> c DoGeneralize
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DoGeneralize -> c DoGeneralize
    Data, (forall x. DoGeneralize -> Rep DoGeneralize x)
    -> (forall x. Rep DoGeneralize x -> DoGeneralize)
    -> Generic DoGeneralize
    forall x. Rep DoGeneralize x -> DoGeneralize
    forall x. DoGeneralize -> Rep DoGeneralize x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DoGeneralize x -> DoGeneralize
    $cfrom :: forall x. DoGeneralize -> Rep DoGeneralize x
    Generic)

    -- | The value of a generalizable variable. This is created to be a
    --   generalizable meta before checking the type to be generalized.
    data GeneralizedValue = GeneralizedValue
      { GeneralizedValue -> CheckpointId
    genvalCheckpoint :: CheckpointId
      , GeneralizedValue -> Term
    genvalTerm       :: Term
      , GeneralizedValue -> Type
    genvalType       :: Type
      } deriving (Int -> GeneralizedValue -> ShowS
    [GeneralizedValue] -> ShowS
    GeneralizedValue -> String
    (Int -> GeneralizedValue -> ShowS)
    -> (GeneralizedValue -> String)
    -> ([GeneralizedValue] -> ShowS)
    -> Show GeneralizedValue
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [GeneralizedValue] -> ShowS
    $cshowList :: [GeneralizedValue] -> ShowS
    show :: GeneralizedValue -> String
    $cshow :: GeneralizedValue -> String
    showsPrec :: Int -> GeneralizedValue -> ShowS
    $cshowsPrec :: Int -> GeneralizedValue -> ShowS
    Show, Typeable GeneralizedValue
    Typeable GeneralizedValue
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> GeneralizedValue -> c GeneralizedValue)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c GeneralizedValue)
    -> (GeneralizedValue -> Constr)
    -> (GeneralizedValue -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c GeneralizedValue))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c GeneralizedValue))
    -> ((forall b. Data b => b -> b)
        -> GeneralizedValue -> GeneralizedValue)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> GeneralizedValue -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> GeneralizedValue -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> GeneralizedValue -> m GeneralizedValue)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> GeneralizedValue -> m GeneralizedValue)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> GeneralizedValue -> m GeneralizedValue)
    -> Data GeneralizedValue
    GeneralizedValue -> DataType
    GeneralizedValue -> Constr
    (forall b. Data b => b -> b)
    -> GeneralizedValue -> GeneralizedValue
    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) -> GeneralizedValue -> u
    forall u. (forall d. Data d => d -> u) -> GeneralizedValue -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GeneralizedValue -> m GeneralizedValue
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GeneralizedValue -> m GeneralizedValue
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GeneralizedValue
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GeneralizedValue -> c GeneralizedValue
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GeneralizedValue)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GeneralizedValue)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GeneralizedValue -> m GeneralizedValue
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GeneralizedValue -> m GeneralizedValue
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GeneralizedValue -> m GeneralizedValue
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GeneralizedValue -> m GeneralizedValue
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GeneralizedValue -> m GeneralizedValue
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GeneralizedValue -> m GeneralizedValue
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> GeneralizedValue -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> GeneralizedValue -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> GeneralizedValue -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> GeneralizedValue -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r
    gmapT :: (forall b. Data b => b -> b)
    -> GeneralizedValue -> GeneralizedValue
    $cgmapT :: (forall b. Data b => b -> b)
    -> GeneralizedValue -> GeneralizedValue
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GeneralizedValue)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GeneralizedValue)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GeneralizedValue)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GeneralizedValue)
    dataTypeOf :: GeneralizedValue -> DataType
    $cdataTypeOf :: GeneralizedValue -> DataType
    toConstr :: GeneralizedValue -> Constr
    $ctoConstr :: GeneralizedValue -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GeneralizedValue
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GeneralizedValue
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GeneralizedValue -> c GeneralizedValue
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GeneralizedValue -> c GeneralizedValue
    Data, (forall x. GeneralizedValue -> Rep GeneralizedValue x)
    -> (forall x. Rep GeneralizedValue x -> GeneralizedValue)
    -> Generic GeneralizedValue
    forall x. Rep GeneralizedValue x -> GeneralizedValue
    forall x. GeneralizedValue -> Rep GeneralizedValue x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep GeneralizedValue x -> GeneralizedValue
    $cfrom :: forall x. GeneralizedValue -> Rep GeneralizedValue x
    Generic)

    ---------------------------------------------------------------------------
    -- ** Meta variables
    ---------------------------------------------------------------------------

    data MetaVariable =
            MetaVar { MetaVariable -> MetaInfo
    mvInfo          :: MetaInfo
                    , MetaVariable -> MetaPriority
    mvPriority      :: MetaPriority -- ^ some metavariables are more eager to be instantiated
                    , MetaVariable -> Permutation
    mvPermutation   :: Permutation
                      -- ^ a metavariable doesn't have to depend on all variables
                      --   in the context, this "permutation" will throw away the
                      --   ones it does not depend on
                    , MetaVariable -> Judgement MetaId
    mvJudgement     :: Judgement MetaId
                    , MetaVariable -> MetaInstantiation
    mvInstantiation :: MetaInstantiation
                    , MetaVariable -> Set Listener
    mvListeners     :: Set Listener -- ^ meta variables scheduled for eta-expansion but blocked by this one
                    , MetaVariable -> Frozen
    mvFrozen        :: Frozen -- ^ are we past the point where we can instantiate this meta variable?
                    , MetaVariable -> Maybe MetaId
    mvTwin          :: Maybe MetaId
                      -- ^ @Just m@ means that this meta-variable will be
                      -- equated to @m@ when the latter is unblocked. See
                      -- 'Agda.TypeChecking.MetaVars.blockTermOnProblem'.
                    }
      deriving (forall x. MetaVariable -> Rep MetaVariable x)
    -> (forall x. Rep MetaVariable x -> MetaVariable)
    -> Generic MetaVariable
    forall x. Rep MetaVariable x -> MetaVariable
    forall x. MetaVariable -> Rep MetaVariable x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep MetaVariable x -> MetaVariable
    $cfrom :: forall x. MetaVariable -> Rep MetaVariable x
    Generic

    data Listener = EtaExpand MetaId
                  | CheckConstraint Nat ProblemConstraint
      deriving (forall x. Listener -> Rep Listener x)
    -> (forall x. Rep Listener x -> Listener) -> Generic Listener
    forall x. Rep Listener x -> Listener
    forall x. Listener -> Rep Listener x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Listener x -> Listener
    $cfrom :: forall x. Listener -> Rep Listener x
    Generic

    instance Eq Listener where
      EtaExpand       MetaId
    x   == :: Listener -> Listener -> Bool
    == EtaExpand       MetaId
    y   = MetaId
    x MetaId -> MetaId -> Bool
    forall a. Eq a => a -> a -> Bool
    == MetaId
    y
      CheckConstraint Int
    x ProblemConstraint
    _ == CheckConstraint Int
    y ProblemConstraint
    _ = Int
    x Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    y
      Listener
    _ == Listener
    _ = Bool
    False

    instance Ord Listener where
      EtaExpand       MetaId
    x   compare :: Listener -> Listener -> Ordering
    `compare` EtaExpand       MetaId
    y   = MetaId
    x MetaId -> MetaId -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` MetaId
    y
      CheckConstraint Int
    x ProblemConstraint
    _ `compare` CheckConstraint Int
    y ProblemConstraint
    _ = Int
    x Int -> Int -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` Int
    y
      EtaExpand{} `compare` CheckConstraint{} = Ordering
    LT
      CheckConstraint{} `compare` EtaExpand{} = Ordering
    GT

    -- | Frozen meta variable cannot be instantiated by unification.
    --   This serves to prevent the completion of a definition by its use
    --   outside of the current block.
    --   (See issues 118, 288, 399).
    data Frozen
      = Frozen        -- ^ Do not instantiate.
      | Instantiable
        deriving (Frozen -> Frozen -> Bool
    (Frozen -> Frozen -> Bool)
    -> (Frozen -> Frozen -> Bool) -> Eq Frozen
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Frozen -> Frozen -> Bool
    $c/= :: Frozen -> Frozen -> Bool
    == :: Frozen -> Frozen -> Bool
    $c== :: Frozen -> Frozen -> Bool
    Eq, Int -> Frozen -> ShowS
    [Frozen] -> ShowS
    Frozen -> String
    (Int -> Frozen -> ShowS)
    -> (Frozen -> String) -> ([Frozen] -> ShowS) -> Show Frozen
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Frozen] -> ShowS
    $cshowList :: [Frozen] -> ShowS
    show :: Frozen -> String
    $cshow :: Frozen -> String
    showsPrec :: Int -> Frozen -> ShowS
    $cshowsPrec :: Int -> Frozen -> ShowS
    Show, (forall x. Frozen -> Rep Frozen x)
    -> (forall x. Rep Frozen x -> Frozen) -> Generic Frozen
    forall x. Rep Frozen x -> Frozen
    forall x. Frozen -> Rep Frozen x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Frozen x -> Frozen
    $cfrom :: forall x. Frozen -> Rep Frozen x
    Generic)

    data MetaInstantiation
            = InstV [Arg String] Term -- ^ solved by term (abstracted over some free variables)
            | Open               -- ^ unsolved
            | OpenInstance       -- ^ open, to be instantiated by instance search
            | BlockedConst Term  -- ^ solution blocked by unsolved constraints
            | PostponedTypeCheckingProblem (Closure TypeCheckingProblem)
      deriving (forall x. MetaInstantiation -> Rep MetaInstantiation x)
    -> (forall x. Rep MetaInstantiation x -> MetaInstantiation)
    -> Generic MetaInstantiation
    forall x. Rep MetaInstantiation x -> MetaInstantiation
    forall x. MetaInstantiation -> Rep MetaInstantiation x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep MetaInstantiation x -> MetaInstantiation
    $cfrom :: forall x. MetaInstantiation -> Rep MetaInstantiation x
    Generic

    -- | Solving a 'CheckArgs' constraint may or may not check the target type. If
    --   it did, it returns a handle to any unsolved constraints.
    data CheckedTarget = CheckedTarget (Maybe ProblemId)
                       | NotCheckedTarget

    data PrincipalArgTypeMetas = PrincipalArgTypeMetas
      { PrincipalArgTypeMetas -> [Arg Term]
    patmMetas     :: Args -- ^ metas created for hidden and instance arguments
                              --   in the principal argument's type
      , PrincipalArgTypeMetas -> Type
    patmRemainder :: Type -- ^ principal argument's type, stripped of hidden and
                              --   instance arguments
      }
      deriving (forall x. PrincipalArgTypeMetas -> Rep PrincipalArgTypeMetas x)
    -> (forall x. Rep PrincipalArgTypeMetas x -> PrincipalArgTypeMetas)
    -> Generic PrincipalArgTypeMetas
    forall x. Rep PrincipalArgTypeMetas x -> PrincipalArgTypeMetas
    forall x. PrincipalArgTypeMetas -> Rep PrincipalArgTypeMetas x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PrincipalArgTypeMetas x -> PrincipalArgTypeMetas
    $cfrom :: forall x. PrincipalArgTypeMetas -> Rep PrincipalArgTypeMetas x
    Generic

    data TypeCheckingProblem
      = CheckExpr Comparison A.Expr Type
      | CheckArgs Comparison ExpandHidden Range [NamedArg A.Expr] Type Type (ArgsCheckState CheckedTarget -> TCM Term)
      | CheckProjAppToKnownPrincipalArg Comparison A.Expr ProjOrigin (List1 QName) A.Args Type Int Term Type PrincipalArgTypeMetas
      | CheckLambda Comparison (Arg (List1 (WithHiding Name), Maybe Type)) A.Expr Type
        -- ^ @(λ (xs : t₀) → e) : t@
        --   This is not an instance of 'CheckExpr' as the domain type
        --   has already been checked.
        --   For example, when checking
        --     @(λ (x y : Fin _) → e) : (x : Fin n) → ?@
        --   we want to postpone @(λ (y : Fin n) → e) : ?@ where @Fin n@
        --   is a 'Type' rather than an 'A.Expr'.
      | DoQuoteTerm Comparison Term Type -- ^ Quote the given term and check type against `Term`
      deriving (forall x. TypeCheckingProblem -> Rep TypeCheckingProblem x)
    -> (forall x. Rep TypeCheckingProblem x -> TypeCheckingProblem)
    -> Generic TypeCheckingProblem
    forall x. Rep TypeCheckingProblem x -> TypeCheckingProblem
    forall x. TypeCheckingProblem -> Rep TypeCheckingProblem x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TypeCheckingProblem x -> TypeCheckingProblem
    $cfrom :: forall x. TypeCheckingProblem -> Rep TypeCheckingProblem x
    Generic

    instance Show MetaInstantiation where
      show :: MetaInstantiation -> String
    show (InstV [Arg String]
    tel Term
    t) = String
    "InstV " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ [Arg String] -> String
    forall a. Show a => a -> String
    show [Arg String]
    tel String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " (" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Term -> String
    forall a. Show a => a -> String
    show Term
    t String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
      show MetaInstantiation
    Open      = String
    "Open"
      show MetaInstantiation
    OpenInstance = String
    "OpenInstance"
      show (BlockedConst Term
    t) = String
    "BlockedConst (" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Term -> String
    forall a. Show a => a -> String
    show Term
    t String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
      show (PostponedTypeCheckingProblem{}) = String
    "PostponedTypeCheckingProblem (...)"

    -- | Meta variable priority:
    --   When we have an equation between meta-variables, which one
    --   should be instantiated?
    --
    --   Higher value means higher priority to be instantiated.
    newtype MetaPriority = MetaPriority Int
        deriving (MetaPriority -> MetaPriority -> Bool
    (MetaPriority -> MetaPriority -> Bool)
    -> (MetaPriority -> MetaPriority -> Bool) -> Eq MetaPriority
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: MetaPriority -> MetaPriority -> Bool
    $c/= :: MetaPriority -> MetaPriority -> Bool
    == :: MetaPriority -> MetaPriority -> Bool
    $c== :: MetaPriority -> MetaPriority -> Bool
    Eq, Eq MetaPriority
    Eq MetaPriority
    -> (MetaPriority -> MetaPriority -> Ordering)
    -> (MetaPriority -> MetaPriority -> Bool)
    -> (MetaPriority -> MetaPriority -> Bool)
    -> (MetaPriority -> MetaPriority -> Bool)
    -> (MetaPriority -> MetaPriority -> Bool)
    -> (MetaPriority -> MetaPriority -> MetaPriority)
    -> (MetaPriority -> MetaPriority -> MetaPriority)
    -> Ord MetaPriority
    MetaPriority -> MetaPriority -> Bool
    MetaPriority -> MetaPriority -> Ordering
    MetaPriority -> MetaPriority -> MetaPriority
    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 :: MetaPriority -> MetaPriority -> MetaPriority
    $cmin :: MetaPriority -> MetaPriority -> MetaPriority
    max :: MetaPriority -> MetaPriority -> MetaPriority
    $cmax :: MetaPriority -> MetaPriority -> MetaPriority
    >= :: MetaPriority -> MetaPriority -> Bool
    $c>= :: MetaPriority -> MetaPriority -> Bool
    > :: MetaPriority -> MetaPriority -> Bool
    $c> :: MetaPriority -> MetaPriority -> Bool
    <= :: MetaPriority -> MetaPriority -> Bool
    $c<= :: MetaPriority -> MetaPriority -> Bool
    < :: MetaPriority -> MetaPriority -> Bool
    $c< :: MetaPriority -> MetaPriority -> Bool
    compare :: MetaPriority -> MetaPriority -> Ordering
    $ccompare :: MetaPriority -> MetaPriority -> Ordering
    Ord, Int -> MetaPriority -> ShowS
    [MetaPriority] -> ShowS
    MetaPriority -> String
    (Int -> MetaPriority -> ShowS)
    -> (MetaPriority -> String)
    -> ([MetaPriority] -> ShowS)
    -> Show MetaPriority
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [MetaPriority] -> ShowS
    $cshowList :: [MetaPriority] -> ShowS
    show :: MetaPriority -> String
    $cshow :: MetaPriority -> String
    showsPrec :: Int -> MetaPriority -> ShowS
    $cshowsPrec :: Int -> MetaPriority -> ShowS
    Show, MetaPriority -> ()
    (MetaPriority -> ()) -> NFData MetaPriority
    forall a. (a -> ()) -> NFData a
    rnf :: MetaPriority -> ()
    $crnf :: MetaPriority -> ()
    NFData)

    data RunMetaOccursCheck
      = RunMetaOccursCheck
      | DontRunMetaOccursCheck
      deriving (RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    (RunMetaOccursCheck -> RunMetaOccursCheck -> Bool)
    -> (RunMetaOccursCheck -> RunMetaOccursCheck -> Bool)
    -> Eq RunMetaOccursCheck
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    $c/= :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    == :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    $c== :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    Eq, Eq RunMetaOccursCheck
    Eq RunMetaOccursCheck
    -> (RunMetaOccursCheck -> RunMetaOccursCheck -> Ordering)
    -> (RunMetaOccursCheck -> RunMetaOccursCheck -> Bool)
    -> (RunMetaOccursCheck -> RunMetaOccursCheck -> Bool)
    -> (RunMetaOccursCheck -> RunMetaOccursCheck -> Bool)
    -> (RunMetaOccursCheck -> RunMetaOccursCheck -> Bool)
    -> (RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck)
    -> (RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck)
    -> Ord RunMetaOccursCheck
    RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    RunMetaOccursCheck -> RunMetaOccursCheck -> Ordering
    RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck
    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 :: RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck
    $cmin :: RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck
    max :: RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck
    $cmax :: RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck
    >= :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    $c>= :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    > :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    $c> :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    <= :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    $c<= :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    < :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    $c< :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool
    compare :: RunMetaOccursCheck -> RunMetaOccursCheck -> Ordering
    $ccompare :: RunMetaOccursCheck -> RunMetaOccursCheck -> Ordering
    Ord, Int -> RunMetaOccursCheck -> ShowS
    [RunMetaOccursCheck] -> ShowS
    RunMetaOccursCheck -> String
    (Int -> RunMetaOccursCheck -> ShowS)
    -> (RunMetaOccursCheck -> String)
    -> ([RunMetaOccursCheck] -> ShowS)
    -> Show RunMetaOccursCheck
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [RunMetaOccursCheck] -> ShowS
    $cshowList :: [RunMetaOccursCheck] -> ShowS
    show :: RunMetaOccursCheck -> String
    $cshow :: RunMetaOccursCheck -> String
    showsPrec :: Int -> RunMetaOccursCheck -> ShowS
    $cshowsPrec :: Int -> RunMetaOccursCheck -> ShowS
    Show, (forall x. RunMetaOccursCheck -> Rep RunMetaOccursCheck x)
    -> (forall x. Rep RunMetaOccursCheck x -> RunMetaOccursCheck)
    -> Generic RunMetaOccursCheck
    forall x. Rep RunMetaOccursCheck x -> RunMetaOccursCheck
    forall x. RunMetaOccursCheck -> Rep RunMetaOccursCheck x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep RunMetaOccursCheck x -> RunMetaOccursCheck
    $cfrom :: forall x. RunMetaOccursCheck -> Rep RunMetaOccursCheck x
    Generic)

    -- | @MetaInfo@ is cloned from one meta to the next during pruning.
    data MetaInfo = MetaInfo
      { MetaInfo -> Closure Range
    miClosRange       :: Closure Range -- TODO: Not so nice. But we want both to have the environment of the meta (Closure) and its range.
      , MetaInfo -> Modality
    miModality        :: Modality           -- ^ Instantiable with irrelevant/erased solution?
      , MetaInfo -> RunMetaOccursCheck
    miMetaOccursCheck :: RunMetaOccursCheck -- ^ Run the extended occurs check that goes in definitions?
      , MetaInfo -> String
    miNameSuggestion  :: MetaNameSuggestion
        -- ^ Used for printing.
        --   @Just x@ if meta-variable comes from omitted argument with name @x@.
      , MetaInfo -> Arg DoGeneralize
    miGeneralizable   :: Arg DoGeneralize
        -- ^ Should this meta be generalized if unsolved? If so, at what ArgInfo?
      }
      deriving (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

    instance LensModality MetaInfo where
      getModality :: MetaInfo -> Modality
    getModality = MetaInfo -> Modality
    miModality
      setModality :: Modality -> MetaInfo -> MetaInfo
    setModality Modality
    mod MetaInfo
    mi = MetaInfo
    mi { miModality :: Modality
    miModality = Modality
    mod }
      mapModality :: (Modality -> Modality) -> MetaInfo -> MetaInfo
    mapModality Modality -> Modality
    f MetaInfo
    mi = MetaInfo
    mi { miModality :: Modality
    miModality = Modality -> Modality
    f (Modality -> Modality) -> Modality -> Modality
    forall a b. (a -> b) -> a -> b
    $ MetaInfo -> Modality
    miModality MetaInfo
    mi }

    instance LensQuantity MetaInfo where
      getQuantity :: MetaInfo -> Quantity
    getQuantity   = Modality -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity (Modality -> Quantity)
    -> (MetaInfo -> Modality) -> MetaInfo -> Quantity
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . MetaInfo -> Modality
    forall a. LensModality a => a -> Modality
    getModality
      mapQuantity :: (Quantity -> Quantity) -> MetaInfo -> MetaInfo
    mapQuantity Quantity -> Quantity
    f = (Modality -> Modality) -> MetaInfo -> MetaInfo
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Quantity -> Quantity) -> Modality -> Modality
    forall a. LensQuantity a => (Quantity -> Quantity) -> a -> a
    mapQuantity Quantity -> Quantity
    f)

    -- | Name suggestion for meta variable.  Empty string means no suggestion.
    type MetaNameSuggestion = String

    -- | For printing, we couple a meta with its name suggestion.
    data NamedMeta = NamedMeta
      { NamedMeta -> String
    nmSuggestion :: MetaNameSuggestion
      , NamedMeta -> MetaId
    nmid         :: MetaId
      }

    instance Pretty NamedMeta where
      pretty :: NamedMeta -> Doc
    pretty (NamedMeta String
    "" MetaId
    x) = MetaId -> Doc
    forall a. Pretty a => a -> Doc
    pretty MetaId
    x
      pretty (NamedMeta String
    "_" MetaId
    x) = MetaId -> Doc
    forall a. Pretty a => a -> Doc
    pretty MetaId
    x
      pretty (NamedMeta String
    s  MetaId
    x) = String -> Doc
    text (String -> Doc) -> String -> Doc
    forall a b. (a -> b) -> a -> b
    $ String
    "_" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    s String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ MetaId -> String
    forall a. Pretty a => a -> String
    prettyShow MetaId
    x

    type MetaStore = IntMap MetaVariable

    instance HasRange MetaInfo where
      getRange :: MetaInfo -> Range
    getRange = Closure Range -> Range
    forall a. Closure a -> a
    clValue (Closure Range -> Range)
    -> (MetaInfo -> Closure Range) -> MetaInfo -> Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . MetaInfo -> Closure Range
    miClosRange

    instance HasRange MetaVariable where
        getRange :: MetaVariable -> Range
    getRange MetaVariable
    m = Closure Range -> Range
    forall a. HasRange a => a -> Range
    getRange (Closure Range -> Range) -> Closure Range -> Range
    forall a b. (a -> b) -> a -> b
    $ MetaVariable -> Closure Range
    getMetaInfo MetaVariable
    m

    instance SetRange MetaInfo where
      setRange :: Range -> MetaInfo -> MetaInfo
    setRange Range
    r MetaInfo
    m = MetaInfo
    m { miClosRange :: Closure Range
    miClosRange = (MetaInfo -> Closure Range
    miClosRange MetaInfo
    m) { clValue :: Range
    clValue = Range
    r }}

    instance SetRange MetaVariable where
      setRange :: Range -> MetaVariable -> MetaVariable
    setRange Range
    r MetaVariable
    m = MetaVariable
    m { mvInfo :: MetaInfo
    mvInfo = Range -> MetaInfo -> MetaInfo
    forall a. SetRange a => Range -> a -> a
    setRange Range
    r (MetaVariable -> MetaInfo
    mvInfo MetaVariable
    m) }

    instance LensModality MetaVariable where
      getModality :: MetaVariable -> Modality
    getModality = MetaInfo -> Modality
    forall a. LensModality a => a -> Modality
    getModality (MetaInfo -> Modality)
    -> (MetaVariable -> MetaInfo) -> MetaVariable -> Modality
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . MetaVariable -> MetaInfo
    mvInfo
      setModality :: Modality -> MetaVariable -> MetaVariable
    setModality Modality
    mod MetaVariable
    mv = MetaVariable
    mv { mvInfo :: MetaInfo
    mvInfo = Modality -> MetaInfo -> MetaInfo
    forall a. LensModality a => Modality -> a -> a
    setModality Modality
    mod (MetaInfo -> MetaInfo) -> MetaInfo -> MetaInfo
    forall a b. (a -> b) -> a -> b
    $ MetaVariable -> MetaInfo
    mvInfo MetaVariable
    mv }
      mapModality :: (Modality -> Modality) -> MetaVariable -> MetaVariable
    mapModality Modality -> Modality
    f MetaVariable
    mv = MetaVariable
    mv { mvInfo :: MetaInfo
    mvInfo = (Modality -> Modality) -> MetaInfo -> MetaInfo
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality Modality -> Modality
    f (MetaInfo -> MetaInfo) -> MetaInfo -> MetaInfo
    forall a b. (a -> b) -> a -> b
    $ MetaVariable -> MetaInfo
    mvInfo MetaVariable
    mv }

    instance LensQuantity MetaVariable where
      getQuantity :: MetaVariable -> Quantity
    getQuantity   = Modality -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity (Modality -> Quantity)
    -> (MetaVariable -> Modality) -> MetaVariable -> Quantity
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . MetaVariable -> Modality
    forall a. LensModality a => a -> Modality
    getModality
      mapQuantity :: (Quantity -> Quantity) -> MetaVariable -> MetaVariable
    mapQuantity Quantity -> Quantity
    f = (Modality -> Modality) -> MetaVariable -> MetaVariable
    forall a. LensModality a => (Modality -> Modality) -> a -> a
    mapModality ((Quantity -> Quantity) -> Modality -> Modality
    forall a. LensQuantity a => (Quantity -> Quantity) -> a -> a
    mapQuantity Quantity -> Quantity
    f)

    normalMetaPriority :: MetaPriority
    normalMetaPriority :: MetaPriority
    normalMetaPriority = Int -> MetaPriority
    MetaPriority Int
    0

    lowMetaPriority :: MetaPriority
    lowMetaPriority :: MetaPriority
    lowMetaPriority = Int -> MetaPriority
    MetaPriority (-Int
    10)

    highMetaPriority :: MetaPriority
    highMetaPriority :: MetaPriority
    highMetaPriority = Int -> MetaPriority
    MetaPriority Int
    10

    getMetaInfo :: MetaVariable -> Closure Range
    getMetaInfo :: MetaVariable -> Closure Range
    getMetaInfo = MetaInfo -> Closure Range
    miClosRange (MetaInfo -> Closure Range)
    -> (MetaVariable -> MetaInfo) -> MetaVariable -> Closure Range
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . MetaVariable -> MetaInfo
    mvInfo

    getMetaScope :: MetaVariable -> ScopeInfo
    getMetaScope :: MetaVariable -> ScopeInfo
    getMetaScope MetaVariable
    m = Closure Range -> ScopeInfo
    forall a. Closure a -> ScopeInfo
    clScope (Closure Range -> ScopeInfo) -> Closure Range -> ScopeInfo
    forall a b. (a -> b) -> a -> b
    $ MetaVariable -> Closure Range
    getMetaInfo MetaVariable
    m

    getMetaEnv :: MetaVariable -> TCEnv
    getMetaEnv :: MetaVariable -> TCEnv
    getMetaEnv MetaVariable
    m = Closure Range -> TCEnv
    forall a. Closure a -> TCEnv
    clEnv (Closure Range -> TCEnv) -> Closure Range -> TCEnv
    forall a b. (a -> b) -> a -> b
    $ MetaVariable -> Closure Range
    getMetaInfo MetaVariable
    m

    getMetaSig :: MetaVariable -> Signature
    getMetaSig :: MetaVariable -> Signature
    getMetaSig MetaVariable
    m = Closure Range -> Signature
    forall a. Closure a -> Signature
    clSignature (Closure Range -> Signature) -> Closure Range -> Signature
    forall a b. (a -> b) -> a -> b
    $ MetaVariable -> Closure Range
    getMetaInfo MetaVariable
    m

    getMetaRelevance :: MetaVariable -> Relevance
    getMetaRelevance :: MetaVariable -> Relevance
    getMetaRelevance = Modality -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance (Modality -> Relevance)
    -> (MetaVariable -> Modality) -> MetaVariable -> Relevance
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . MetaVariable -> Modality
    forall a. LensModality a => a -> Modality
    getModality

    getMetaModality :: MetaVariable -> Modality
    getMetaModality :: MetaVariable -> Modality
    getMetaModality = MetaVariable -> Modality
    forall a. LensModality a => a -> Modality
    getModality

    -- Lenses

    metaFrozen :: Lens' Frozen MetaVariable
    metaFrozen :: Lens' Frozen MetaVariable
    metaFrozen Frozen -> f Frozen
    f MetaVariable
    mv = Frozen -> f Frozen
    f (MetaVariable -> Frozen
    mvFrozen MetaVariable
    mv) f Frozen -> (Frozen -> MetaVariable) -> f MetaVariable
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Frozen
    x -> MetaVariable
    mv { mvFrozen :: Frozen
    mvFrozen = Frozen
    x }

    _mvInfo :: Lens' MetaInfo MetaVariable
    _mvInfo :: Lens' MetaInfo MetaVariable
    _mvInfo MetaInfo -> f MetaInfo
    f MetaVariable
    mv = (MetaInfo -> f MetaInfo
    f (MetaInfo -> f MetaInfo) -> MetaInfo -> f MetaInfo
    forall a b. (a -> b) -> a -> b
    $! MetaVariable -> MetaInfo
    mvInfo MetaVariable
    mv) f MetaInfo -> (MetaInfo -> MetaVariable) -> f MetaVariable
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ MetaInfo
    mi -> MetaVariable
    mv { mvInfo :: MetaInfo
    mvInfo = MetaInfo
    mi }

    -- Lenses onto Closure Range

    instance LensClosure Range MetaInfo where
      lensClosure :: Lens' (Closure Range) MetaInfo
    lensClosure Closure Range -> f (Closure Range)
    f MetaInfo
    mi = (Closure Range -> f (Closure Range)
    f (Closure Range -> f (Closure Range))
    -> Closure Range -> f (Closure Range)
    forall a b. (a -> b) -> a -> b
    $! MetaInfo -> Closure Range
    miClosRange MetaInfo
    mi) f (Closure Range) -> (Closure Range -> MetaInfo) -> f MetaInfo
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Closure Range
    cl -> MetaInfo
    mi { miClosRange :: Closure Range
    miClosRange = Closure Range
    cl }

    instance LensClosure Range MetaVariable where
      lensClosure :: Lens' (Closure Range) MetaVariable
    lensClosure = (MetaInfo -> f MetaInfo) -> MetaVariable -> f MetaVariable
    Lens' MetaInfo MetaVariable
    _mvInfo ((MetaInfo -> f MetaInfo) -> MetaVariable -> f MetaVariable)
    -> ((Closure Range -> f (Closure Range)) -> MetaInfo -> f MetaInfo)
    -> (Closure Range -> f (Closure Range))
    -> MetaVariable
    -> f MetaVariable
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Closure Range -> f (Closure Range)) -> MetaInfo -> f MetaInfo
    forall a b. LensClosure a b => Lens' (Closure a) b
    lensClosure

    -- Lenses onto IsAbstract

    instance LensIsAbstract TCEnv where
      lensIsAbstract :: Lens' IsAbstract TCEnv
    lensIsAbstract IsAbstract -> f IsAbstract
    f TCEnv
    env =
         -- Andreas, 2019-08-19
         -- Using $! to prevent space leaks like #1829.
         -- This can crash when trying to get IsAbstract from IgnoreAbstractMode.
        (IsAbstract -> f IsAbstract
    f (IsAbstract -> f IsAbstract) -> IsAbstract -> f IsAbstract
    forall a b. (a -> b) -> a -> b
    $! IsAbstract -> Maybe IsAbstract -> IsAbstract
    forall a. a -> Maybe a -> a
    fromMaybe IsAbstract
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (AbstractMode -> Maybe IsAbstract
    aModeToDef (AbstractMode -> Maybe IsAbstract)
    -> AbstractMode -> Maybe IsAbstract
    forall a b. (a -> b) -> a -> b
    $ TCEnv -> AbstractMode
    envAbstractMode TCEnv
    env))
        f IsAbstract -> (IsAbstract -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ IsAbstract
    a -> TCEnv
    env { envAbstractMode :: AbstractMode
    envAbstractMode = IsAbstract -> AbstractMode
    aDefToMode IsAbstract
    a }

    instance LensIsAbstract (Closure a) where
      lensIsAbstract :: Lens' IsAbstract (Closure a)
    lensIsAbstract = (TCEnv -> f TCEnv) -> Closure a -> f (Closure a)
    forall a. LensTCEnv a => Lens' TCEnv a
    lensTCEnv ((TCEnv -> f TCEnv) -> Closure a -> f (Closure a))
    -> ((IsAbstract -> f IsAbstract) -> TCEnv -> f TCEnv)
    -> (IsAbstract -> f IsAbstract)
    -> Closure a
    -> f (Closure a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (IsAbstract -> f IsAbstract) -> TCEnv -> f TCEnv
    forall a. LensIsAbstract a => Lens' IsAbstract a
    lensIsAbstract

    instance LensIsAbstract MetaInfo where
      lensIsAbstract :: Lens' IsAbstract MetaInfo
    lensIsAbstract = (Closure Range -> f (Closure Range)) -> MetaInfo -> f MetaInfo
    forall a b. LensClosure a b => Lens' (Closure a) b
    lensClosure ((Closure Range -> f (Closure Range)) -> MetaInfo -> f MetaInfo)
    -> ((IsAbstract -> f IsAbstract)
        -> Closure Range -> f (Closure Range))
    -> (IsAbstract -> f IsAbstract)
    -> MetaInfo
    -> f MetaInfo
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (IsAbstract -> f IsAbstract) -> Closure Range -> f (Closure Range)
    forall a. LensIsAbstract a => Lens' IsAbstract a
    lensIsAbstract

    ---------------------------------------------------------------------------
    -- ** Interaction meta variables
    ---------------------------------------------------------------------------

    -- | Interaction points are created by the scope checker who sets the range.
    --   The meta variable is created by the type checker and then hooked up to the
    --   interaction point.
    data InteractionPoint = InteractionPoint
      { InteractionPoint -> Range
    ipRange :: Range        -- ^ The position of the interaction point.
      , InteractionPoint -> Maybe MetaId
    ipMeta  :: Maybe MetaId -- ^ The meta variable, if any, holding the type etc.
      , InteractionPoint -> Bool
    ipSolved:: Bool         -- ^ Has this interaction point already been solved?
      , InteractionPoint -> IPClause
    ipClause:: IPClause
          -- ^ The clause of the interaction point (if any).
          --   Used for case splitting.
      }
      deriving (forall x. InteractionPoint -> Rep InteractionPoint x)
    -> (forall x. Rep InteractionPoint x -> InteractionPoint)
    -> Generic InteractionPoint
    forall x. Rep InteractionPoint x -> InteractionPoint
    forall x. InteractionPoint -> Rep InteractionPoint x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep InteractionPoint x -> InteractionPoint
    $cfrom :: forall x. InteractionPoint -> Rep InteractionPoint x
    Generic

    instance Eq InteractionPoint where == :: InteractionPoint -> InteractionPoint -> Bool
    (==) = Maybe MetaId -> Maybe MetaId -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) (Maybe MetaId -> Maybe MetaId -> Bool)
    -> (InteractionPoint -> Maybe MetaId)
    -> InteractionPoint
    -> InteractionPoint
    -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` InteractionPoint -> Maybe MetaId
    ipMeta

    instance HasTag InteractionPoint where
      type Tag InteractionPoint = MetaId
      tag :: InteractionPoint -> Maybe (Tag InteractionPoint)
    tag = InteractionPoint -> Maybe (Tag InteractionPoint)
    InteractionPoint -> Maybe MetaId
    ipMeta

    -- | Data structure managing the interaction points.
    --
    --   We never remove interaction points from this map, only set their
    --   'ipSolved' to @True@.  (Issue #2368)
    type InteractionPoints = BiMap InteractionId InteractionPoint

    -- | Flag to indicate whether the meta is overapplied in the
    --   constraint.  A meta is overapplied if it has more arguments than
    --   the size of the telescope in its creation environment
    --   (as stored in MetaInfo).
    data Overapplied = Overapplied | NotOverapplied
      deriving (Overapplied -> Overapplied -> Bool
    (Overapplied -> Overapplied -> Bool)
    -> (Overapplied -> Overapplied -> Bool) -> Eq Overapplied
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Overapplied -> Overapplied -> Bool
    $c/= :: Overapplied -> Overapplied -> Bool
    == :: Overapplied -> Overapplied -> Bool
    $c== :: Overapplied -> Overapplied -> Bool
    Eq, Int -> Overapplied -> ShowS
    [Overapplied] -> ShowS
    Overapplied -> String
    (Int -> Overapplied -> ShowS)
    -> (Overapplied -> String)
    -> ([Overapplied] -> ShowS)
    -> Show Overapplied
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Overapplied] -> ShowS
    $cshowList :: [Overapplied] -> ShowS
    show :: Overapplied -> String
    $cshow :: Overapplied -> String
    showsPrec :: Int -> Overapplied -> ShowS
    $cshowsPrec :: Int -> Overapplied -> ShowS
    Show, Typeable Overapplied
    Typeable Overapplied
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Overapplied -> c Overapplied)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Overapplied)
    -> (Overapplied -> Constr)
    -> (Overapplied -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Overapplied))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c Overapplied))
    -> ((forall b. Data b => b -> b) -> Overapplied -> Overapplied)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Overapplied -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Overapplied -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Overapplied -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Overapplied -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied)
    -> Data Overapplied
    Overapplied -> DataType
    Overapplied -> Constr
    (forall b. Data b => b -> b) -> Overapplied -> Overapplied
    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) -> Overapplied -> u
    forall u. (forall d. Data d => d -> u) -> Overapplied -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overapplied -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overapplied -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Overapplied
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overapplied -> c Overapplied
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Overapplied)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Overapplied)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Overapplied -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Overapplied -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Overapplied -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Overapplied -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overapplied -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Overapplied -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overapplied -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Overapplied -> r
    gmapT :: (forall b. Data b => b -> b) -> Overapplied -> Overapplied
    $cgmapT :: (forall b. Data b => b -> b) -> Overapplied -> Overapplied
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Overapplied)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Overapplied)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Overapplied)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Overapplied)
    dataTypeOf :: Overapplied -> DataType
    $cdataTypeOf :: Overapplied -> DataType
    toConstr :: Overapplied -> Constr
    $ctoConstr :: Overapplied -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Overapplied
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Overapplied
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overapplied -> c Overapplied
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Overapplied -> c Overapplied
    Data, (forall x. Overapplied -> Rep Overapplied x)
    -> (forall x. Rep Overapplied x -> Overapplied)
    -> Generic Overapplied
    forall x. Rep Overapplied x -> Overapplied
    forall x. Overapplied -> Rep Overapplied x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Overapplied x -> Overapplied
    $cfrom :: forall x. Overapplied -> Rep Overapplied x
    Generic)

    -- | Datatype representing a single boundary condition:
    --   x_0 = u_0, ... ,x_n = u_n ⊢ t = ?n es
    data IPBoundary' t = IPBoundary
      { forall t. IPBoundary' t -> [(t, t)]
    ipbEquations :: [(t,t)] -- ^ [x_0 = u_0, ... ,x_n = u_n]
      , forall t. IPBoundary' t -> t
    ipbValue     :: t          -- ^ @t@
      , forall t. IPBoundary' t -> t
    ipbMetaApp   :: t          -- ^ @?n es@
      , forall t. IPBoundary' t -> Overapplied
    ipbOverapplied :: Overapplied -- ^ Is @?n@ overapplied in @?n es@ ?
      }
      deriving (Int -> IPBoundary' t -> ShowS
    [IPBoundary' t] -> ShowS
    IPBoundary' t -> String
    (Int -> IPBoundary' t -> ShowS)
    -> (IPBoundary' t -> String)
    -> ([IPBoundary' t] -> ShowS)
    -> Show (IPBoundary' t)
    forall t. Show t => Int -> IPBoundary' t -> ShowS
    forall t. Show t => [IPBoundary' t] -> ShowS
    forall t. Show t => IPBoundary' t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [IPBoundary' t] -> ShowS
    $cshowList :: forall t. Show t => [IPBoundary' t] -> ShowS
    show :: IPBoundary' t -> String
    $cshow :: forall t. Show t => IPBoundary' t -> String
    showsPrec :: Int -> IPBoundary' t -> ShowS
    $cshowsPrec :: forall t. Show t => Int -> IPBoundary' t -> ShowS
    Show, Typeable (IPBoundary' t)
    Typeable (IPBoundary' t)
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> IPBoundary' t -> c (IPBoundary' t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (IPBoundary' t))
    -> (IPBoundary' t -> Constr)
    -> (IPBoundary' t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (IPBoundary' t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (IPBoundary' t)))
    -> ((forall b. Data b => b -> b) -> IPBoundary' t -> IPBoundary' t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> IPBoundary' t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> IPBoundary' t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> IPBoundary' t -> m (IPBoundary' t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> IPBoundary' t -> m (IPBoundary' t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> IPBoundary' t -> m (IPBoundary' t))
    -> Data (IPBoundary' t)
    IPBoundary' t -> DataType
    IPBoundary' t -> Constr
    (forall b. Data b => b -> b) -> IPBoundary' t -> IPBoundary' t
    forall {t}. Data t => Typeable (IPBoundary' t)
    forall t. Data t => IPBoundary' t -> DataType
    forall t. Data t => IPBoundary' t -> Constr
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> IPBoundary' t -> IPBoundary' t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> IPBoundary' t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> IPBoundary' t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBoundary' t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPBoundary' t -> c (IPBoundary' t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBoundary' t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (IPBoundary' 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) -> IPBoundary' t -> u
    forall u. (forall d. Data d => d -> u) -> IPBoundary' t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBoundary' t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPBoundary' t -> c (IPBoundary' t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBoundary' t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (IPBoundary' t))
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d)
    -> IPBoundary' t -> m (IPBoundary' t)
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IPBoundary' t -> u
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> IPBoundary' t -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> IPBoundary' t -> [u]
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> IPBoundary' t -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r
    gmapT :: (forall b. Data b => b -> b) -> IPBoundary' t -> IPBoundary' t
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> IPBoundary' t -> IPBoundary' t
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (IPBoundary' t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (IPBoundary' t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBoundary' t))
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (IPBoundary' t))
    dataTypeOf :: IPBoundary' t -> DataType
    $cdataTypeOf :: forall t. Data t => IPBoundary' t -> DataType
    toConstr :: IPBoundary' t -> Constr
    $ctoConstr :: forall t. Data t => IPBoundary' t -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBoundary' t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IPBoundary' t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPBoundary' t -> c (IPBoundary' t)
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IPBoundary' t -> c (IPBoundary' t)
    Data, (forall a b. (a -> b) -> IPBoundary' a -> IPBoundary' b)
    -> (forall a b. a -> IPBoundary' b -> IPBoundary' a)
    -> Functor IPBoundary'
    forall a b. a -> IPBoundary' b -> IPBoundary' a
    forall a b. (a -> b) -> IPBoundary' a -> IPBoundary' b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> IPBoundary' b -> IPBoundary' a
    $c<$ :: forall a b. a -> IPBoundary' b -> IPBoundary' a
    fmap :: forall a b. (a -> b) -> IPBoundary' a -> IPBoundary' b
    $cfmap :: forall a b. (a -> b) -> IPBoundary' a -> IPBoundary' b
    Functor, (forall m. Monoid m => IPBoundary' m -> m)
    -> (forall m a. Monoid m => (a -> m) -> IPBoundary' a -> m)
    -> (forall m a. Monoid m => (a -> m) -> IPBoundary' a -> m)
    -> (forall a b. (a -> b -> b) -> b -> IPBoundary' a -> b)
    -> (forall a b. (a -> b -> b) -> b -> IPBoundary' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> IPBoundary' a -> b)
    -> (forall b a. (b -> a -> b) -> b -> IPBoundary' a -> b)
    -> (forall a. (a -> a -> a) -> IPBoundary' a -> a)
    -> (forall a. (a -> a -> a) -> IPBoundary' a -> a)
    -> (forall a. IPBoundary' a -> [a])
    -> (forall a. IPBoundary' a -> Bool)
    -> (forall a. IPBoundary' a -> Int)
    -> (forall a. Eq a => a -> IPBoundary' a -> Bool)
    -> (forall a. Ord a => IPBoundary' a -> a)
    -> (forall a. Ord a => IPBoundary' a -> a)
    -> (forall a. Num a => IPBoundary' a -> a)
    -> (forall a. Num a => IPBoundary' a -> a)
    -> Foldable IPBoundary'
    forall a. Eq a => a -> IPBoundary' a -> Bool
    forall a. Num a => IPBoundary' a -> a
    forall a. Ord a => IPBoundary' a -> a
    forall m. Monoid m => IPBoundary' m -> m
    forall a. IPBoundary' a -> Bool
    forall a. IPBoundary' a -> Int
    forall a. IPBoundary' a -> [a]
    forall a. (a -> a -> a) -> IPBoundary' a -> a
    forall m a. Monoid m => (a -> m) -> IPBoundary' a -> m
    forall b a. (b -> a -> b) -> b -> IPBoundary' a -> b
    forall a b. (a -> b -> b) -> b -> IPBoundary' a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => IPBoundary' a -> a
    $cproduct :: forall a. Num a => IPBoundary' a -> a
    sum :: forall a. Num a => IPBoundary' a -> a
    $csum :: forall a. Num a => IPBoundary' a -> a
    minimum :: forall a. Ord a => IPBoundary' a -> a
    $cminimum :: forall a. Ord a => IPBoundary' a -> a
    maximum :: forall a. Ord a => IPBoundary' a -> a
    $cmaximum :: forall a. Ord a => IPBoundary' a -> a
    elem :: forall a. Eq a => a -> IPBoundary' a -> Bool
    $celem :: forall a. Eq a => a -> IPBoundary' a -> Bool
    length :: forall a. IPBoundary' a -> Int
    $clength :: forall a. IPBoundary' a -> Int
    null :: forall a. IPBoundary' a -> Bool
    $cnull :: forall a. IPBoundary' a -> Bool
    toList :: forall a. IPBoundary' a -> [a]
    $ctoList :: forall a. IPBoundary' a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> IPBoundary' a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> IPBoundary' a -> a
    foldr1 :: forall a. (a -> a -> a) -> IPBoundary' a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> IPBoundary' a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> IPBoundary' a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> IPBoundary' a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> IPBoundary' a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> IPBoundary' a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> IPBoundary' a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> IPBoundary' a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> IPBoundary' a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> IPBoundary' a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> IPBoundary' a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> IPBoundary' a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> IPBoundary' a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> IPBoundary' a -> m
    fold :: forall m. Monoid m => IPBoundary' m -> m
    $cfold :: forall m. Monoid m => IPBoundary' m -> m
    Foldable, Functor IPBoundary'
    Foldable IPBoundary'
    Functor IPBoundary'
    -> Foldable IPBoundary'
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> IPBoundary' a -> f (IPBoundary' b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        IPBoundary' (f a) -> f (IPBoundary' a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> IPBoundary' a -> m (IPBoundary' b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        IPBoundary' (m a) -> m (IPBoundary' a))
    -> Traversable IPBoundary'
    forall (t :: * -> *).
    Functor t
    -> Foldable t
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    IPBoundary' (m a) -> m (IPBoundary' a)
    forall (f :: * -> *) a.
    Applicative f =>
    IPBoundary' (f a) -> f (IPBoundary' a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPBoundary' a -> m (IPBoundary' b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPBoundary' a -> f (IPBoundary' b)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    IPBoundary' (m a) -> m (IPBoundary' a)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    IPBoundary' (m a) -> m (IPBoundary' a)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPBoundary' a -> m (IPBoundary' b)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> IPBoundary' a -> m (IPBoundary' b)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    IPBoundary' (f a) -> f (IPBoundary' a)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    IPBoundary' (f a) -> f (IPBoundary' a)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPBoundary' a -> f (IPBoundary' b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> IPBoundary' a -> f (IPBoundary' b)
    Traversable, (forall x. IPBoundary' t -> Rep (IPBoundary' t) x)
    -> (forall x. Rep (IPBoundary' t) x -> IPBoundary' t)
    -> Generic (IPBoundary' t)
    forall x. Rep (IPBoundary' t) x -> IPBoundary' t
    forall x. IPBoundary' t -> Rep (IPBoundary' t) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall t x. Rep (IPBoundary' t) x -> IPBoundary' t
    forall t x. IPBoundary' t -> Rep (IPBoundary' t) x
    $cto :: forall t x. Rep (IPBoundary' t) x -> IPBoundary' t
    $cfrom :: forall t x. IPBoundary' t -> Rep (IPBoundary' t) x
    Generic)

    type IPBoundary = IPBoundary' Term

    -- | Which clause is an interaction point located in?
    data IPClause = IPClause
      { IPClause -> QName
    ipcQName    :: QName              -- ^ The name of the function.
      , IPClause -> Int
    ipcClauseNo :: Int                -- ^ The number of the clause of this function.
      , IPClause -> Type
    ipcType     :: Type               -- ^ The type of the function
      , IPClause -> Maybe Substitution
    ipcWithSub  :: Maybe Substitution -- ^ Module parameter substitution
      , IPClause -> SpineClause
    ipcClause   :: A.SpineClause      -- ^ The original AST clause.
      , IPClause -> Closure ()
    ipcClosure  :: Closure ()         -- ^ Environment for rechecking the clause.
      , IPClause -> [Closure IPBoundary]
    ipcBoundary :: [Closure IPBoundary] -- ^ The boundary imposed by the LHS.
      }
      | IPNoClause -- ^ The interaction point is not in the rhs of a clause.
      deriving ((forall x. IPClause -> Rep IPClause x)
    -> (forall x. Rep IPClause x -> IPClause) -> Generic IPClause
    forall x. Rep IPClause x -> IPClause
    forall x. IPClause -> Rep IPClause x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep IPClause x -> IPClause
    $cfrom :: forall x. IPClause -> Rep IPClause x
    Generic)

    instance Eq IPClause where
      IPClause
    IPNoClause           == :: IPClause -> IPClause -> Bool
    == IPClause
    IPNoClause             = Bool
    True
      IPClause QName
    x Int
    i Type
    _ Maybe Substitution
    _ SpineClause
    _ Closure ()
    _ [Closure IPBoundary]
    _ == IPClause QName
    x' Int
    i' Type
    _ Maybe Substitution
    _ SpineClause
    _ Closure ()
    _ [Closure IPBoundary]
    _ = QName
    x QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    x' Bool -> Bool -> Bool
    && Int
    i Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    i'
      IPClause
    _                    == IPClause
    _                      = Bool
    False

    ---------------------------------------------------------------------------
    -- ** Signature
    ---------------------------------------------------------------------------

    data Signature = Sig
          { Signature -> Sections
    _sigSections    :: Sections
          , Signature -> Definitions
    _sigDefinitions :: Definitions
          , Signature -> RewriteRuleMap
    _sigRewriteRules:: RewriteRuleMap  -- ^ The rewrite rules defined in this file.
          }
      deriving (Int -> Signature -> ShowS
    [Signature] -> ShowS
    Signature -> String
    (Int -> Signature -> ShowS)
    -> (Signature -> String)
    -> ([Signature] -> ShowS)
    -> Show Signature
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Signature] -> ShowS
    $cshowList :: [Signature] -> ShowS
    show :: Signature -> String
    $cshow :: Signature -> String
    showsPrec :: Int -> Signature -> ShowS
    $cshowsPrec :: Int -> Signature -> ShowS
    Show, (forall x. Signature -> Rep Signature x)
    -> (forall x. Rep Signature x -> Signature) -> Generic Signature
    forall x. Rep Signature x -> Signature
    forall x. Signature -> Rep Signature x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Signature x -> Signature
    $cfrom :: forall x. Signature -> Rep Signature x
    Generic)

    sigSections :: Lens' Sections Signature
    sigSections :: Lens' Sections Signature
    sigSections Sections -> f Sections
    f Signature
    s =
      Sections -> f Sections
    f (Signature -> Sections
    _sigSections Signature
    s) f Sections -> (Sections -> Signature) -> f Signature
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Sections
    x -> Signature
    s {_sigSections :: Sections
    _sigSections = Sections
    x}

    sigDefinitions :: Lens' Definitions Signature
    sigDefinitions :: Lens' Definitions Signature
    sigDefinitions Definitions -> f Definitions
    f Signature
    s =
      Definitions -> f Definitions
    f (Signature -> Definitions
    _sigDefinitions Signature
    s) f Definitions -> (Definitions -> Signature) -> f Signature
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Definitions
    x -> Signature
    s {_sigDefinitions :: Definitions
    _sigDefinitions = Definitions
    x}

    sigRewriteRules :: Lens' RewriteRuleMap Signature
    sigRewriteRules :: Lens' RewriteRuleMap Signature
    sigRewriteRules RewriteRuleMap -> f RewriteRuleMap
    f Signature
    s =
      RewriteRuleMap -> f RewriteRuleMap
    f (Signature -> RewriteRuleMap
    _sigRewriteRules Signature
    s) f RewriteRuleMap -> (RewriteRuleMap -> Signature) -> f Signature
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \RewriteRuleMap
    x -> Signature
    s {_sigRewriteRules :: RewriteRuleMap
    _sigRewriteRules = RewriteRuleMap
    x}

    type Sections    = Map ModuleName Section
    type Definitions = HashMap QName Definition
    type RewriteRuleMap = HashMap QName RewriteRules
    type DisplayForms = HashMap QName [LocalDisplayForm]

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

    instance Pretty Section where
      pretty :: Section -> Doc
    pretty = Telescope -> Doc
    forall a. Pretty a => a -> Doc
    pretty (Telescope -> Doc) -> (Section -> Telescope) -> Section -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Section -> Telescope
    _secTelescope

    secTelescope :: Lens' Telescope Section
    secTelescope :: Lens' Telescope Section
    secTelescope Telescope -> f Telescope
    f Section
    s =
      Telescope -> f Telescope
    f (Section -> Telescope
    _secTelescope Section
    s) f Telescope -> (Telescope -> Section) -> f Section
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \Telescope
    x -> Section
    s {_secTelescope :: Telescope
    _secTelescope = Telescope
    x}

    emptySignature :: Signature
    emptySignature :: Signature
    emptySignature = Sections -> Definitions -> RewriteRuleMap -> Signature
    Sig Sections
    forall k a. Map k a
    Map.empty Definitions
    forall k v. HashMap k v
    HMap.empty RewriteRuleMap
    forall k v. HashMap k v
    HMap.empty

    -- | A @DisplayForm@ is in essence a rewrite rule @q ts --> dt@ for a defined symbol (could be a
    --   constructor as well) @q@. The right hand side is a 'DisplayTerm' which is used to 'reify' to a
    --   more readable 'Abstract.Syntax'.
    --
    --   The patterns @ts@ are just terms, but the first @dfPatternVars@ variables are pattern variables
    --   that matches any term.
    data DisplayForm = Display
      { DisplayForm -> Int
    dfPatternVars :: Nat
        -- ^ Number @n@ of pattern variables in 'dfPats'.
      , DisplayForm -> [Elim]
    dfPats :: Elims
        -- ^ Left hand side patterns, the @n@ first free variables are pattern variables,
        --   any variables above @n@ are fixed and only match that particular variable. This
        --   happens when you have display forms inside parameterised modules that match on the module
        --   parameters. The 'ArgInfo' is ignored in these patterns.
      , DisplayForm -> DisplayTerm
    dfRHS :: DisplayTerm
        -- ^ Right hand side.
      }
      deriving (Typeable DisplayForm
    Typeable DisplayForm
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> DisplayForm -> c DisplayForm)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DisplayForm)
    -> (DisplayForm -> Constr)
    -> (DisplayForm -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DisplayForm))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DisplayForm))
    -> ((forall b. Data b => b -> b) -> DisplayForm -> DisplayForm)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DisplayForm -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DisplayForm -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm)
    -> Data DisplayForm
    DisplayForm -> DataType
    DisplayForm -> Constr
    (forall b. Data b => b -> b) -> DisplayForm -> DisplayForm
    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) -> DisplayForm -> u
    forall u. (forall d. Data d => d -> u) -> DisplayForm -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DisplayForm
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DisplayForm -> c DisplayForm
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DisplayForm)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DisplayForm)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DisplayForm -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DisplayForm -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DisplayForm -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DisplayForm -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r
    gmapT :: (forall b. Data b => b -> b) -> DisplayForm -> DisplayForm
    $cgmapT :: (forall b. Data b => b -> b) -> DisplayForm -> DisplayForm
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DisplayForm)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DisplayForm)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DisplayForm)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DisplayForm)
    dataTypeOf :: DisplayForm -> DataType
    $cdataTypeOf :: DisplayForm -> DataType
    toConstr :: DisplayForm -> Constr
    $ctoConstr :: DisplayForm -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DisplayForm
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DisplayForm
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DisplayForm -> c DisplayForm
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DisplayForm -> c DisplayForm
    Data, Int -> DisplayForm -> ShowS
    [DisplayForm] -> ShowS
    DisplayForm -> String
    (Int -> DisplayForm -> ShowS)
    -> (DisplayForm -> String)
    -> ([DisplayForm] -> ShowS)
    -> Show DisplayForm
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [DisplayForm] -> ShowS
    $cshowList :: [DisplayForm] -> ShowS
    show :: DisplayForm -> String
    $cshow :: DisplayForm -> String
    showsPrec :: Int -> DisplayForm -> ShowS
    $cshowsPrec :: Int -> DisplayForm -> ShowS
    Show, (forall x. DisplayForm -> Rep DisplayForm x)
    -> (forall x. Rep DisplayForm x -> DisplayForm)
    -> Generic DisplayForm
    forall x. Rep DisplayForm x -> DisplayForm
    forall x. DisplayForm -> Rep DisplayForm x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DisplayForm x -> DisplayForm
    $cfrom :: forall x. DisplayForm -> Rep DisplayForm x
    Generic)

    type LocalDisplayForm = Open DisplayForm

    -- | A structured presentation of a 'Term' for reification into
    --   'Abstract.Syntax'.
    data DisplayTerm
      = DWithApp DisplayTerm [DisplayTerm] Elims
        -- ^ @(f vs | ws) es@.
        --   The first 'DisplayTerm' is the parent function @f@ with its args @vs@.
        --   The list of 'DisplayTerm's are the with expressions @ws@.
        --   The 'Elims' are additional arguments @es@
        --   (possible in case the with-application is of function type)
        --   or projections (if it is of record type).
      | DCon ConHead ConInfo [Arg DisplayTerm]
        -- ^ @c vs@.
      | DDef QName [Elim' DisplayTerm]
        -- ^ @d vs@.
      | DDot Term
        -- ^ @.v@.
      | DTerm Term
        -- ^ @v@.
      deriving (Typeable DisplayTerm
    Typeable DisplayTerm
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> DisplayTerm -> c DisplayTerm)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DisplayTerm)
    -> (DisplayTerm -> Constr)
    -> (DisplayTerm -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DisplayTerm))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DisplayTerm))
    -> ((forall b. Data b => b -> b) -> DisplayTerm -> DisplayTerm)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DisplayTerm -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DisplayTerm -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm)
    -> Data DisplayTerm
    DisplayTerm -> DataType
    DisplayTerm -> Constr
    (forall b. Data b => b -> b) -> DisplayTerm -> DisplayTerm
    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) -> DisplayTerm -> u
    forall u. (forall d. Data d => d -> u) -> DisplayTerm -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DisplayTerm
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DisplayTerm -> c DisplayTerm
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DisplayTerm)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DisplayTerm)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DisplayTerm -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DisplayTerm -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DisplayTerm -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DisplayTerm -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r
    gmapT :: (forall b. Data b => b -> b) -> DisplayTerm -> DisplayTerm
    $cgmapT :: (forall b. Data b => b -> b) -> DisplayTerm -> DisplayTerm
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DisplayTerm)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DisplayTerm)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DisplayTerm)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DisplayTerm)
    dataTypeOf :: DisplayTerm -> DataType
    $cdataTypeOf :: DisplayTerm -> DataType
    toConstr :: DisplayTerm -> Constr
    $ctoConstr :: DisplayTerm -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DisplayTerm
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DisplayTerm
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DisplayTerm -> c DisplayTerm
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DisplayTerm -> c DisplayTerm
    Data, Int -> DisplayTerm -> ShowS
    [DisplayTerm] -> ShowS
    DisplayTerm -> String
    (Int -> DisplayTerm -> ShowS)
    -> (DisplayTerm -> String)
    -> ([DisplayTerm] -> ShowS)
    -> Show DisplayTerm
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [DisplayTerm] -> ShowS
    $cshowList :: [DisplayTerm] -> ShowS
    show :: DisplayTerm -> String
    $cshow :: DisplayTerm -> String
    showsPrec :: Int -> DisplayTerm -> ShowS
    $cshowsPrec :: Int -> DisplayTerm -> ShowS
    Show, (forall x. DisplayTerm -> Rep DisplayTerm x)
    -> (forall x. Rep DisplayTerm x -> DisplayTerm)
    -> Generic DisplayTerm
    forall x. Rep DisplayTerm x -> DisplayTerm
    forall x. DisplayTerm -> Rep DisplayTerm x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DisplayTerm x -> DisplayTerm
    $cfrom :: forall x. DisplayTerm -> Rep DisplayTerm x
    Generic)

    instance Free DisplayForm where
      freeVars' :: forall a c. IsVarSet a c => DisplayForm -> FreeM a c
    freeVars' (Display Int
    n [Elim]
    ps DisplayTerm
    t) = ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    -> ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    forall a b c (m :: * -> *) z.
    MonadReader (FreeEnv' a b c) m =>
    m z -> m z
    underBinder ([Elim] -> ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' [Elim]
    ps) ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    -> ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    -> ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    forall a. Monoid a => a -> a -> a
    `mappend` Int
    -> ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    -> ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    forall a b c (m :: * -> *) z.
    MonadReader (FreeEnv' a b c) m =>
    Int -> m z -> m z
    underBinder' Int
    n (DisplayTerm -> ReaderT (FreeEnv' a IgnoreSorts c) Identity c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' DisplayTerm
    t)

    instance Free DisplayTerm where
      freeVars' :: forall a c. IsVarSet a c => DisplayTerm -> FreeM a c
    freeVars' (DWithApp DisplayTerm
    t [DisplayTerm]
    ws [Elim]
    es) = (DisplayTerm, ([DisplayTerm], [Elim])) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' (DisplayTerm
    t, ([DisplayTerm]
    ws, [Elim]
    es))
      freeVars' (DCon ConHead
    _ ConInfo
    _ [Arg DisplayTerm]
    vs)      = [Arg DisplayTerm] -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' [Arg DisplayTerm]
    vs
      freeVars' (DDef QName
    _ [Elim' DisplayTerm]
    es)        = [Elim' DisplayTerm] -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' [Elim' DisplayTerm]
    es
      freeVars' (DDot Term
    v)           = Term -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Term
    v
      freeVars' (DTerm Term
    v)          = Term -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' Term
    v

    instance Pretty DisplayTerm where
      prettyPrec :: Int -> DisplayTerm -> Doc
    prettyPrec Int
    p DisplayTerm
    v =
        case DisplayTerm
    v of
          DTerm Term
    v          -> Int -> Term -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    p Term
    v
          DDot Term
    v           -> Doc
    "." Doc -> Doc -> Doc
    forall a. Semigroup a => a -> a -> a
    <> Int -> Term -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    10 Term
    v
          DDef QName
    f [Elim' DisplayTerm]
    es        -> QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty QName
    f Doc -> [Elim' DisplayTerm] -> Doc
    forall el. Pretty el => Doc -> [el] -> Doc
    `pApp` [Elim' DisplayTerm]
    es
          DCon ConHead
    c ConInfo
    _ [Arg DisplayTerm]
    vs      -> QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty (ConHead -> QName
    conName ConHead
    c) Doc -> [Elim' DisplayTerm] -> Doc
    forall el. Pretty el => Doc -> [el] -> Doc
    `pApp` (Arg DisplayTerm -> Elim' DisplayTerm)
    -> [Arg DisplayTerm] -> [Elim' DisplayTerm]
    forall a b. (a -> b) -> [a] -> [b]
    map Arg DisplayTerm -> Elim' DisplayTerm
    forall a. Arg a -> Elim' a
    Apply [Arg DisplayTerm]
    vs
          DWithApp DisplayTerm
    h [DisplayTerm]
    ws [Elim]
    es ->
            Bool -> Doc -> Doc
    mparens (Int
    p Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0)
              ([Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    sep [ DisplayTerm -> Doc
    forall a. Pretty a => a -> Doc
    pretty DisplayTerm
    h
                  , Int -> Doc -> Doc
    nest Int
    2 (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $ [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    fsep [ Doc
    "|" Doc -> Doc -> Doc
    <+> DisplayTerm -> Doc
    forall a. Pretty a => a -> Doc
    pretty DisplayTerm
    w | DisplayTerm
    w <- [DisplayTerm]
    ws ] ])
            Doc -> [Elim] -> Doc
    forall el. Pretty el => Doc -> [el] -> Doc
    `pApp` [Elim]
    es
        where
          pApp :: Pretty el => Doc -> [el] -> Doc
          pApp :: forall el. Pretty el => Doc -> [el] -> Doc
    pApp Doc
    d [el]
    els = Bool -> Doc -> Doc
    mparens (Bool -> Bool
    not ([el] -> Bool
    forall a. Null a => a -> Bool
    null [el]
    els) Bool -> Bool -> Bool
    && Int
    p Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    9) (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $
                       [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    sep [Doc
    d, Int -> Doc -> Doc
    nest Int
    2 (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $ [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    fsep ((el -> Doc) -> [el] -> [Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map (Int -> el -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    10) [el]
    els)]

    instance Pretty DisplayForm where
      prettyPrec :: Int -> DisplayForm -> Doc
    prettyPrec Int
    p (Display Int
    fv [Elim]
    lhs DisplayTerm
    rhs) = Bool -> Doc -> Doc
    mparens (Int
    p Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    9) (Doc -> Doc) -> Doc -> Doc
    forall a b. (a -> b) -> a -> b
    $
        Doc
    "Display" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    fsep [ Int -> Doc
    forall a. Show a => a -> Doc
    pshow Int
    fv, Int -> [Elim] -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    10 [Elim]
    lhs, Int -> DisplayTerm -> Doc
    forall a. Pretty a => Int -> a -> Doc
    prettyPrec Int
    10 DisplayTerm
    rhs ]

    -- | By default, we have no display form.
    defaultDisplayForm :: QName -> [LocalDisplayForm]
    defaultDisplayForm :: QName -> [LocalDisplayForm]
    defaultDisplayForm QName
    c = []

    -- | Non-linear (non-constructor) first-order pattern.
    data NLPat
      = PVar !Int [Arg Int]
        -- ^ Matches anything (modulo non-linearity) that only contains bound
        --   variables that occur in the given arguments.
      | PDef QName PElims
        -- ^ Matches @f es@
      | PLam ArgInfo (Abs NLPat)
        -- ^ Matches @λ x → t@
      | PPi (Dom NLPType) (Abs NLPType)
        -- ^ Matches @(x : A) → B@
      | PSort NLPSort
        -- ^ Matches a sort of the given shape.
      | PBoundVar {-# UNPACK #-} !Int PElims
        -- ^ Matches @x es@ where x is a lambda-bound variable
      | PTerm Term
        -- ^ Matches the term modulo β (ideally βη).
      deriving (Typeable NLPat
    Typeable NLPat
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> NLPat -> c NLPat)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NLPat)
    -> (NLPat -> Constr)
    -> (NLPat -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NLPat))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NLPat))
    -> ((forall b. Data b => b -> b) -> NLPat -> NLPat)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r)
    -> (forall u. (forall d. Data d => d -> u) -> NLPat -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> NLPat -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> NLPat -> m NLPat)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NLPat -> m NLPat)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NLPat -> m NLPat)
    -> Data NLPat
    NLPat -> DataType
    NLPat -> Constr
    (forall b. Data b => b -> b) -> NLPat -> NLPat
    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) -> NLPat -> u
    forall u. (forall d. Data d => d -> u) -> NLPat -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NLPat -> m NLPat
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NLPat -> m NLPat
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NLPat
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NLPat -> c NLPat
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NLPat)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NLPat)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NLPat -> m NLPat
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NLPat -> m NLPat
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NLPat -> m NLPat
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NLPat -> m NLPat
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NLPat -> m NLPat
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NLPat -> m NLPat
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NLPat -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NLPat -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> NLPat -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> NLPat -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r
    gmapT :: (forall b. Data b => b -> b) -> NLPat -> NLPat
    $cgmapT :: (forall b. Data b => b -> b) -> NLPat -> NLPat
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NLPat)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NLPat)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NLPat)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NLPat)
    dataTypeOf :: NLPat -> DataType
    $cdataTypeOf :: NLPat -> DataType
    toConstr :: NLPat -> Constr
    $ctoConstr :: NLPat -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NLPat
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NLPat
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NLPat -> c NLPat
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NLPat -> c NLPat
    Data, Int -> NLPat -> ShowS
    [NLPat] -> ShowS
    NLPat -> String
    (Int -> NLPat -> ShowS)
    -> (NLPat -> String) -> ([NLPat] -> ShowS) -> Show NLPat
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [NLPat] -> ShowS
    $cshowList :: [NLPat] -> ShowS
    show :: NLPat -> String
    $cshow :: NLPat -> String
    showsPrec :: Int -> NLPat -> ShowS
    $cshowsPrec :: Int -> NLPat -> ShowS
    Show, (forall x. NLPat -> Rep NLPat x)
    -> (forall x. Rep NLPat x -> NLPat) -> Generic NLPat
    forall x. Rep NLPat x -> NLPat
    forall x. NLPat -> Rep NLPat x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep NLPat x -> NLPat
    $cfrom :: forall x. NLPat -> Rep NLPat x
    Generic)
    type PElims = [Elim' NLPat]

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

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

    type RewriteRules = [RewriteRule]

    -- | Rewrite rules can be added independently from function clauses.
    data RewriteRule = RewriteRule
      { RewriteRule -> QName
    rewName    :: QName      -- ^ Name of rewrite rule @q : Γ → f ps ≡ rhs@
                                 --   where @≡@ is the rewrite relation.
      , RewriteRule -> Telescope
    rewContext :: Telescope  -- ^ @Γ@.
      , RewriteRule -> QName
    rewHead    :: QName      -- ^ @f@.
      , RewriteRule -> PElims
    rewPats    :: PElims     -- ^ @Γ ⊢ f ps : t@.
      , RewriteRule -> Term
    rewRHS     :: Term       -- ^ @Γ ⊢ rhs : t@.
      , RewriteRule -> Type
    rewType    :: Type       -- ^ @Γ ⊢ t@.
      , RewriteRule -> Bool
    rewFromClause :: Bool    -- ^ Was this rewrite rule created from a clause in the definition of the function?
      }
        deriving (Typeable RewriteRule
    Typeable RewriteRule
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> RewriteRule -> c RewriteRule)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c RewriteRule)
    -> (RewriteRule -> Constr)
    -> (RewriteRule -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c RewriteRule))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c RewriteRule))
    -> ((forall b. Data b => b -> b) -> RewriteRule -> RewriteRule)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r)
    -> (forall u. (forall d. Data d => d -> u) -> RewriteRule -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> RewriteRule -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule)
    -> Data RewriteRule
    RewriteRule -> DataType
    RewriteRule -> Constr
    (forall b. Data b => b -> b) -> RewriteRule -> RewriteRule
    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) -> RewriteRule -> u
    forall u. (forall d. Data d => d -> u) -> RewriteRule -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RewriteRule
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RewriteRule -> c RewriteRule
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RewriteRule)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RewriteRule)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RewriteRule -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RewriteRule -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RewriteRule -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> RewriteRule -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r
    gmapT :: (forall b. Data b => b -> b) -> RewriteRule -> RewriteRule
    $cgmapT :: (forall b. Data b => b -> b) -> RewriteRule -> RewriteRule
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RewriteRule)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RewriteRule)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RewriteRule)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RewriteRule)
    dataTypeOf :: RewriteRule -> DataType
    $cdataTypeOf :: RewriteRule -> DataType
    toConstr :: RewriteRule -> Constr
    $ctoConstr :: RewriteRule -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RewriteRule
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RewriteRule
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RewriteRule -> c RewriteRule
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RewriteRule -> c RewriteRule
    Data, Int -> RewriteRule -> ShowS
    [RewriteRule] -> ShowS
    RewriteRule -> String
    (Int -> RewriteRule -> ShowS)
    -> (RewriteRule -> String)
    -> ([RewriteRule] -> ShowS)
    -> Show RewriteRule
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [RewriteRule] -> ShowS
    $cshowList :: [RewriteRule] -> ShowS
    show :: RewriteRule -> String
    $cshow :: RewriteRule -> String
    showsPrec :: Int -> RewriteRule -> ShowS
    $cshowsPrec :: Int -> RewriteRule -> ShowS
    Show, (forall x. RewriteRule -> Rep RewriteRule x)
    -> (forall x. Rep RewriteRule x -> RewriteRule)
    -> Generic RewriteRule
    forall x. Rep RewriteRule x -> RewriteRule
    forall x. RewriteRule -> Rep RewriteRule x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep RewriteRule x -> RewriteRule
    $cfrom :: forall x. RewriteRule -> Rep RewriteRule x
    Generic)

    data Definition = Defn
      { Definition -> ArgInfo
    defArgInfo        :: ArgInfo -- ^ Hiding should not be used.
      , Definition -> QName
    defName           :: QName   -- ^ The canonical name, used e.g. in compilation.
      , Definition -> Type
    defType           :: Type    -- ^ Type of the lifted definition.
      , Definition -> [Polarity]
    defPolarity       :: [Polarity]
        -- ^ Variance information on arguments of the definition.
        --   Does not include info for dropped parameters to
        --   projection(-like) functions and constructors.
      , Definition -> [Occurrence]
    defArgOccurrences :: [Occurrence]
        -- ^ Positivity information on arguments of the definition.
        --   Does not include info for dropped parameters to
        --   projection(-like) functions and constructors.

        --   Sometimes Agda looks up 'Occurrence's in these lists based on
        --   their position, so one might consider replacing the list
        --   with, say, an 'IntMap'. However, presumably these lists tend
        --   to be short, in which case 'IntMap's could be slower than
        --   lists. For instance, at one point the longest list
        --   encountered for the standard library (in serialised
        --   interfaces) had length 27. Distribution:
        --
        --   Length, number of lists
        --   -----------------------
        --
        --    0, 2444
        --    1,  721
        --    2,  433
        --    3,  668
        --    4,  602
        --    5,  624
        --    6,  626
        --    7,  484
        --    8,  375
        --    9,  264
        --   10,  305
        --   11,  188
        --   12,  171
        --   13,  108
        --   14,   84
        --   15,   80
        --   16,   38
        --   17,   23
        --   18,   16
        --   19,    8
        --   20,    7
        --   21,    5
        --   22,    2
        --   23,    3
        --   27,    1

      , Definition -> NumGeneralizableArgs
    defArgGeneralizable :: NumGeneralizableArgs
        -- ^ How many arguments should be generalised.
      , Definition -> [Maybe Name]
    defGeneralizedParams :: [Maybe Name]
        -- ^ Gives the name of the (bound variable) parameter for named generalized
        --   parameters. This is needed to bring it into scope when type checking
        --   the data/record definition corresponding to a type with generalized
        --   parameters.
      , Definition -> [LocalDisplayForm]
    defDisplay        :: [LocalDisplayForm]
      , Definition -> MutualId
    defMutual         :: MutualId
      , Definition -> CompiledRepresentation
    defCompiledRep    :: CompiledRepresentation
      , Definition -> Maybe QName
    defInstance       :: Maybe QName
        -- ^ @Just q@ when this definition is an instance of class q
      , Definition -> Bool
    defCopy           :: Bool
        -- ^ Has this function been created by a module
                             -- instantiation?
      , Definition -> Set QName
    defMatchable      :: Set QName
        -- ^ The set of symbols with rewrite rules that match against this symbol
      , Definition -> Bool
    defNoCompilation  :: Bool
        -- ^ should compilers skip this? Used for e.g. cubical's comp
      , Definition -> Bool
    defInjective      :: Bool
        -- ^ Should the def be treated as injective by the pattern matching unifier?
      , Definition -> Bool
    defCopatternLHS   :: Bool
        -- ^ Is this a function defined by copatterns?
      , Definition -> Blocked_
    defBlocked        :: Blocked_
        -- ^ What blocking tag to use when we cannot reduce this def?
        --   Used when checking a function definition is blocked on a meta
        --   in the type.
      , Definition -> Language
    defLanguage       :: !Language
        -- ^ The language used for the definition.
      , Definition -> Defn
    theDef            :: Defn
      }
        deriving (Int -> Definition -> ShowS
    [Definition] -> ShowS
    Definition -> String
    (Int -> Definition -> ShowS)
    -> (Definition -> String)
    -> ([Definition] -> ShowS)
    -> Show Definition
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Definition] -> ShowS
    $cshowList :: [Definition] -> ShowS
    show :: Definition -> String
    $cshow :: Definition -> String
    showsPrec :: Int -> Definition -> ShowS
    $cshowsPrec :: Int -> Definition -> ShowS
    Show, (forall x. Definition -> Rep Definition x)
    -> (forall x. Rep Definition x -> Definition) -> Generic Definition
    forall x. Rep Definition x -> Definition
    forall x. Definition -> Rep Definition x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Definition x -> Definition
    $cfrom :: forall x. Definition -> Rep Definition x
    Generic)

    instance LensArgInfo Definition where
      getArgInfo :: Definition -> ArgInfo
    getArgInfo = Definition -> ArgInfo
    defArgInfo
      mapArgInfo :: (ArgInfo -> ArgInfo) -> Definition -> Definition
    mapArgInfo ArgInfo -> ArgInfo
    f Definition
    def = Definition
    def { defArgInfo :: ArgInfo
    defArgInfo = ArgInfo -> ArgInfo
    f (ArgInfo -> ArgInfo) -> ArgInfo -> ArgInfo
    forall a b. (a -> b) -> a -> b
    $ Definition -> ArgInfo
    defArgInfo Definition
    def }

    instance LensModality  Definition where
    instance LensQuantity  Definition where
    instance LensRelevance Definition where

    data NumGeneralizableArgs
      = NoGeneralizableArgs
      | SomeGeneralizableArgs !Int
        -- ^ When lambda-lifting new args are generalizable if
        --   'SomeGeneralizableArgs', also when the number is zero.
      deriving (Typeable NumGeneralizableArgs
    Typeable NumGeneralizableArgs
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g)
        -> NumGeneralizableArgs
        -> c NumGeneralizableArgs)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NumGeneralizableArgs)
    -> (NumGeneralizableArgs -> Constr)
    -> (NumGeneralizableArgs -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NumGeneralizableArgs))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c NumGeneralizableArgs))
    -> ((forall b. Data b => b -> b)
        -> NumGeneralizableArgs -> NumGeneralizableArgs)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> NumGeneralizableArgs -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> NumGeneralizableArgs -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> NumGeneralizableArgs -> m NumGeneralizableArgs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> NumGeneralizableArgs -> m NumGeneralizableArgs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> NumGeneralizableArgs -> m NumGeneralizableArgs)
    -> Data NumGeneralizableArgs
    NumGeneralizableArgs -> DataType
    NumGeneralizableArgs -> Constr
    (forall b. Data b => b -> b)
    -> NumGeneralizableArgs -> NumGeneralizableArgs
    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) -> NumGeneralizableArgs -> u
    forall u.
    (forall d. Data d => d -> u) -> NumGeneralizableArgs -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NumGeneralizableArgs -> m NumGeneralizableArgs
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NumGeneralizableArgs -> m NumGeneralizableArgs
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NumGeneralizableArgs
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> NumGeneralizableArgs
    -> c NumGeneralizableArgs
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NumGeneralizableArgs)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NumGeneralizableArgs)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NumGeneralizableArgs -> m NumGeneralizableArgs
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NumGeneralizableArgs -> m NumGeneralizableArgs
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NumGeneralizableArgs -> m NumGeneralizableArgs
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NumGeneralizableArgs -> m NumGeneralizableArgs
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NumGeneralizableArgs -> m NumGeneralizableArgs
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NumGeneralizableArgs -> m NumGeneralizableArgs
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> NumGeneralizableArgs -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> NumGeneralizableArgs -> u
    gmapQ :: forall u.
    (forall d. Data d => d -> u) -> NumGeneralizableArgs -> [u]
    $cgmapQ :: forall u.
    (forall d. Data d => d -> u) -> NumGeneralizableArgs -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r
    gmapT :: (forall b. Data b => b -> b)
    -> NumGeneralizableArgs -> NumGeneralizableArgs
    $cgmapT :: (forall b. Data b => b -> b)
    -> NumGeneralizableArgs -> NumGeneralizableArgs
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NumGeneralizableArgs)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NumGeneralizableArgs)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NumGeneralizableArgs)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NumGeneralizableArgs)
    dataTypeOf :: NumGeneralizableArgs -> DataType
    $cdataTypeOf :: NumGeneralizableArgs -> DataType
    toConstr :: NumGeneralizableArgs -> Constr
    $ctoConstr :: NumGeneralizableArgs -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NumGeneralizableArgs
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NumGeneralizableArgs
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> NumGeneralizableArgs
    -> c NumGeneralizableArgs
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> NumGeneralizableArgs
    -> c NumGeneralizableArgs
    Data, Int -> NumGeneralizableArgs -> ShowS
    [NumGeneralizableArgs] -> ShowS
    NumGeneralizableArgs -> String
    (Int -> NumGeneralizableArgs -> ShowS)
    -> (NumGeneralizableArgs -> String)
    -> ([NumGeneralizableArgs] -> ShowS)
    -> Show NumGeneralizableArgs
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [NumGeneralizableArgs] -> ShowS
    $cshowList :: [NumGeneralizableArgs] -> ShowS
    show :: NumGeneralizableArgs -> String
    $cshow :: NumGeneralizableArgs -> String
    showsPrec :: Int -> NumGeneralizableArgs -> ShowS
    $cshowsPrec :: Int -> NumGeneralizableArgs -> ShowS
    Show)

    theDefLens :: Lens' Defn Definition
    theDefLens :: Lens' Defn Definition
    theDefLens Defn -> f Defn
    f Definition
    d = Defn -> f Defn
    f (Definition -> Defn
    theDef Definition
    d) f Defn -> (Defn -> Definition) -> f Definition
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Defn
    df -> Definition
    d { theDef :: Defn
    theDef = Defn
    df }

    -- | Create a definition with sensible defaults.
    defaultDefn ::
      ArgInfo -> QName -> Type -> Language -> Defn -> Definition
    defaultDefn :: ArgInfo -> QName -> Type -> Language -> Defn -> Definition
    defaultDefn ArgInfo
    info QName
    x Type
    t Language
    lang Defn
    def = Defn :: ArgInfo
    -> QName
    -> Type
    -> [Polarity]
    -> [Occurrence]
    -> NumGeneralizableArgs
    -> [Maybe Name]
    -> [LocalDisplayForm]
    -> MutualId
    -> CompiledRepresentation
    -> Maybe QName
    -> Bool
    -> Set QName
    -> Bool
    -> Bool
    -> Bool
    -> Blocked_
    -> Language
    -> Defn
    -> Definition
    Defn
      { defArgInfo :: ArgInfo
    defArgInfo        = ArgInfo
    info
      , defName :: QName
    defName           = QName
    x
      , defType :: Type
    defType           = Type
    t
      , defPolarity :: [Polarity]
    defPolarity       = []
      , defArgOccurrences :: [Occurrence]
    defArgOccurrences = []
      , defArgGeneralizable :: NumGeneralizableArgs
    defArgGeneralizable = NumGeneralizableArgs
    NoGeneralizableArgs
      , defGeneralizedParams :: [Maybe Name]
    defGeneralizedParams = []
      , defDisplay :: [LocalDisplayForm]
    defDisplay        = QName -> [LocalDisplayForm]
    defaultDisplayForm QName
    x
      , defMutual :: MutualId
    defMutual         = MutualId
    0
      , defCompiledRep :: CompiledRepresentation
    defCompiledRep    = CompiledRepresentation
    noCompiledRep
      , defInstance :: Maybe QName
    defInstance       = Maybe QName
    forall a. Maybe a
    Nothing
      , defCopy :: Bool
    defCopy           = Bool
    False
      , defMatchable :: Set QName
    defMatchable      = Set QName
    forall a. Set a
    Set.empty
      , defNoCompilation :: Bool
    defNoCompilation  = Bool
    False
      , defInjective :: Bool
    defInjective      = Bool
    False
      , defCopatternLHS :: Bool
    defCopatternLHS   = Bool
    False
      , defBlocked :: Blocked_
    defBlocked        = NotBlocked' Term -> () -> Blocked_
    forall t a. NotBlocked' t -> a -> Blocked' t a
    NotBlocked NotBlocked' Term
    forall t. NotBlocked' t
    ReallyNotBlocked ()
      , defLanguage :: Language
    defLanguage       = Language
    lang
      , theDef :: Defn
    theDef            = Defn
    def
      }

    -- | Polarity for equality and subtype checking.
    data Polarity
      = Covariant      -- ^ monotone
      | Contravariant  -- ^ antitone
      | Invariant      -- ^ no information (mixed variance)
      | Nonvariant     -- ^ constant
      deriving (Typeable Polarity
    Typeable Polarity
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Polarity -> c Polarity)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Polarity)
    -> (Polarity -> Constr)
    -> (Polarity -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Polarity))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Polarity))
    -> ((forall b. Data b => b -> b) -> Polarity -> Polarity)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Polarity -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Polarity -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Polarity -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Polarity -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Polarity -> m Polarity)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Polarity -> m Polarity)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Polarity -> m Polarity)
    -> Data Polarity
    Polarity -> DataType
    Polarity -> Constr
    (forall b. Data b => b -> b) -> Polarity -> Polarity
    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) -> Polarity -> u
    forall u. (forall d. Data d => d -> u) -> Polarity -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Polarity -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Polarity -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Polarity -> m Polarity
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Polarity -> m Polarity
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Polarity
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Polarity -> c Polarity
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Polarity)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Polarity)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Polarity -> m Polarity
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Polarity -> m Polarity
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Polarity -> m Polarity
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Polarity -> m Polarity
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Polarity -> m Polarity
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Polarity -> m Polarity
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Polarity -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Polarity -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Polarity -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Polarity -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Polarity -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Polarity -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Polarity -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Polarity -> r
    gmapT :: (forall b. Data b => b -> b) -> Polarity -> Polarity
    $cgmapT :: (forall b. Data b => b -> b) -> Polarity -> Polarity
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Polarity)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Polarity)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Polarity)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Polarity)
    dataTypeOf :: Polarity -> DataType
    $cdataTypeOf :: Polarity -> DataType
    toConstr :: Polarity -> Constr
    $ctoConstr :: Polarity -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Polarity
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Polarity
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Polarity -> c Polarity
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Polarity -> c Polarity
    Data, Int -> Polarity -> ShowS
    [Polarity] -> ShowS
    Polarity -> String
    (Int -> Polarity -> ShowS)
    -> (Polarity -> String) -> ([Polarity] -> ShowS) -> Show Polarity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Polarity] -> ShowS
    $cshowList :: [Polarity] -> ShowS
    show :: Polarity -> String
    $cshow :: Polarity -> String
    showsPrec :: Int -> Polarity -> ShowS
    $cshowsPrec :: Int -> Polarity -> ShowS
    Show, Polarity -> Polarity -> Bool
    (Polarity -> Polarity -> Bool)
    -> (Polarity -> Polarity -> Bool) -> Eq Polarity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Polarity -> Polarity -> Bool
    $c/= :: Polarity -> Polarity -> Bool
    == :: Polarity -> Polarity -> Bool
    $c== :: Polarity -> Polarity -> Bool
    Eq, (forall x. Polarity -> Rep Polarity x)
    -> (forall x. Rep Polarity x -> Polarity) -> Generic Polarity
    forall x. Rep Polarity x -> Polarity
    forall x. Polarity -> Rep Polarity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Polarity x -> Polarity
    $cfrom :: forall x. Polarity -> Rep Polarity x
    Generic)

    instance Pretty Polarity where
      pretty :: Polarity -> Doc
    pretty = String -> Doc
    text (String -> Doc) -> (Polarity -> String) -> Polarity -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . \case
        Polarity
    Covariant     -> String
    "+"
        Polarity
    Contravariant -> String
    "-"
        Polarity
    Invariant     -> String
    "*"
        Polarity
    Nonvariant    -> String
    "_"

    -- | Information about whether an argument is forced by the type of a function.
    data IsForced
      = Forced
      | NotForced
      deriving (Typeable IsForced
    Typeable IsForced
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> IsForced -> c IsForced)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c IsForced)
    -> (IsForced -> Constr)
    -> (IsForced -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c IsForced))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IsForced))
    -> ((forall b. Data b => b -> b) -> IsForced -> IsForced)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> IsForced -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> IsForced -> r)
    -> (forall u. (forall d. Data d => d -> u) -> IsForced -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> IsForced -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> IsForced -> m IsForced)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> IsForced -> m IsForced)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> IsForced -> m IsForced)
    -> Data IsForced
    IsForced -> DataType
    IsForced -> Constr
    (forall b. Data b => b -> b) -> IsForced -> IsForced
    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) -> IsForced -> u
    forall u. (forall d. Data d => d -> u) -> IsForced -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IsForced -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IsForced -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IsForced -> m IsForced
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IsForced -> m IsForced
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IsForced
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IsForced -> c IsForced
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IsForced)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IsForced)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IsForced -> m IsForced
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IsForced -> m IsForced
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IsForced -> m IsForced
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IsForced -> m IsForced
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IsForced -> m IsForced
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IsForced -> m IsForced
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IsForced -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IsForced -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> IsForced -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> IsForced -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IsForced -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IsForced -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IsForced -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IsForced -> r
    gmapT :: (forall b. Data b => b -> b) -> IsForced -> IsForced
    $cgmapT :: (forall b. Data b => b -> b) -> IsForced -> IsForced
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IsForced)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IsForced)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IsForced)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IsForced)
    dataTypeOf :: IsForced -> DataType
    $cdataTypeOf :: IsForced -> DataType
    toConstr :: IsForced -> Constr
    $ctoConstr :: IsForced -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IsForced
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IsForced
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IsForced -> c IsForced
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IsForced -> c IsForced
    Data, Int -> IsForced -> ShowS
    [IsForced] -> ShowS
    IsForced -> String
    (Int -> IsForced -> ShowS)
    -> (IsForced -> String) -> ([IsForced] -> ShowS) -> Show IsForced
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [IsForced] -> ShowS
    $cshowList :: [IsForced] -> ShowS
    show :: IsForced -> String
    $cshow :: IsForced -> String
    showsPrec :: Int -> IsForced -> ShowS
    $cshowsPrec :: Int -> IsForced -> ShowS
    Show, IsForced -> IsForced -> Bool
    (IsForced -> IsForced -> Bool)
    -> (IsForced -> IsForced -> Bool) -> Eq IsForced
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: IsForced -> IsForced -> Bool
    $c/= :: IsForced -> IsForced -> Bool
    == :: IsForced -> IsForced -> Bool
    $c== :: IsForced -> IsForced -> Bool
    Eq, (forall x. IsForced -> Rep IsForced x)
    -> (forall x. Rep IsForced x -> IsForced) -> Generic IsForced
    forall x. Rep IsForced x -> IsForced
    forall x. IsForced -> Rep IsForced x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep IsForced x -> IsForced
    $cfrom :: forall x. IsForced -> Rep IsForced x
    Generic)

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

    instance HasRange CompilerPragma where
      getRange :: CompilerPragma -> Range
    getRange (CompilerPragma Range
    r String
    _) = Range
    r

    type BackendName    = String

    jsBackendName, ghcBackendName :: BackendName
    jsBackendName :: String
    jsBackendName  = String
    "JS"
    ghcBackendName :: String
    ghcBackendName = String
    "GHC"

    type CompiledRepresentation = Map BackendName [CompilerPragma]

    noCompiledRep :: CompiledRepresentation
    noCompiledRep :: CompiledRepresentation
    noCompiledRep = CompiledRepresentation
    forall k a. Map k a
    Map.empty

    -- A face represented as a list of equality constraints.
    -- (r,False) ↦ (r = i0)
    -- (r,True ) ↦ (r = i1)
    type Face = [(Term,Bool)]

    -- | An alternative representation of partial elements in a telescope:
    --   Γ ⊢ λ Δ. [φ₁ u₁, ... , φₙ uₙ] : Δ → PartialP (∨_ᵢ φᵢ) T
    --   see cubicaltt paper (however we do not store the type T).
    data System = System
      { System -> Telescope
    systemTel :: Telescope
        -- ^ the telescope Δ, binding vars for the clauses, Γ ⊢ Δ
      , System -> [(Face, Term)]
    systemClauses :: [(Face,Term)]
        -- ^ a system [φ₁ u₁, ... , φₙ uₙ] where Γ, Δ ⊢ φᵢ and Γ, Δ, φᵢ ⊢ uᵢ
      } deriving (Typeable System
    Typeable System
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> System -> c System)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c System)
    -> (System -> Constr)
    -> (System -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c System))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System))
    -> ((forall b. Data b => b -> b) -> System -> System)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> System -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> System -> r)
    -> (forall u. (forall d. Data d => d -> u) -> System -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> System -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> System -> m System)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> System -> m System)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> System -> m System)
    -> Data System
    System -> DataType
    System -> Constr
    (forall b. Data b => b -> b) -> System -> System
    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) -> System -> u
    forall u. (forall d. Data d => d -> u) -> System -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> System -> m System
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> System -> m System
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c System
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> System -> c System
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c System)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> System -> m System
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> System -> m System
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> System -> m System
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> System -> m System
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> System -> m System
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> System -> m System
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> System -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> System -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> System -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> System -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> System -> r
    gmapT :: (forall b. Data b => b -> b) -> System -> System
    $cgmapT :: (forall b. Data b => b -> b) -> System -> System
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c System)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c System)
    dataTypeOf :: System -> DataType
    $cdataTypeOf :: System -> DataType
    toConstr :: System -> Constr
    $ctoConstr :: System -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c System
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c System
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> System -> c System
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> System -> c System
    Data, Int -> System -> ShowS
    [System] -> ShowS
    System -> String
    (Int -> System -> ShowS)
    -> (System -> String) -> ([System] -> ShowS) -> Show System
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [System] -> ShowS
    $cshowList :: [System] -> ShowS
    show :: System -> String
    $cshow :: System -> String
    showsPrec :: Int -> System -> ShowS
    $cshowsPrec :: Int -> System -> ShowS
    Show, (forall x. System -> Rep System x)
    -> (forall x. Rep System x -> System) -> Generic System
    forall x. Rep System x -> System
    forall x. System -> Rep System x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep System x -> System
    $cfrom :: forall x. System -> Rep System x
    Generic)

    -- | Additional information for extended lambdas.
    data ExtLamInfo = ExtLamInfo
      { ExtLamInfo -> ModuleName
    extLamModule    :: ModuleName
        -- ^ For complicated reasons the scope checker decides the QName of a
        --   pattern lambda, and thus its module. We really need to decide the
        --   module during type checking though, since if the lambda appears in a
        --   refined context the module picked by the scope checker has very much
        --   the wrong parameters.
      , ExtLamInfo -> Bool
    extLamAbsurd :: Bool
        -- ^ Was this definition created from an absurd lambda @λ ()@?
      , ExtLamInfo -> Maybe System
    extLamSys :: !(Strict.Maybe System)
      } deriving (Typeable ExtLamInfo
    Typeable ExtLamInfo
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ExtLamInfo -> c ExtLamInfo)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ExtLamInfo)
    -> (ExtLamInfo -> Constr)
    -> (ExtLamInfo -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ExtLamInfo))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ExtLamInfo))
    -> ((forall b. Data b => b -> b) -> ExtLamInfo -> ExtLamInfo)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ExtLamInfo -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ExtLamInfo -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo)
    -> Data ExtLamInfo
    ExtLamInfo -> DataType
    ExtLamInfo -> Constr
    (forall b. Data b => b -> b) -> ExtLamInfo -> ExtLamInfo
    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) -> ExtLamInfo -> u
    forall u. (forall d. Data d => d -> u) -> ExtLamInfo -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExtLamInfo
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExtLamInfo -> c ExtLamInfo
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExtLamInfo)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtLamInfo)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExtLamInfo -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExtLamInfo -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ExtLamInfo -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExtLamInfo -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r
    gmapT :: (forall b. Data b => b -> b) -> ExtLamInfo -> ExtLamInfo
    $cgmapT :: (forall b. Data b => b -> b) -> ExtLamInfo -> ExtLamInfo
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtLamInfo)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtLamInfo)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExtLamInfo)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExtLamInfo)
    dataTypeOf :: ExtLamInfo -> DataType
    $cdataTypeOf :: ExtLamInfo -> DataType
    toConstr :: ExtLamInfo -> Constr
    $ctoConstr :: ExtLamInfo -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExtLamInfo
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExtLamInfo
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExtLamInfo -> c ExtLamInfo
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExtLamInfo -> c ExtLamInfo
    Data, Int -> ExtLamInfo -> ShowS
    [ExtLamInfo] -> ShowS
    ExtLamInfo -> String
    (Int -> ExtLamInfo -> ShowS)
    -> (ExtLamInfo -> String)
    -> ([ExtLamInfo] -> ShowS)
    -> Show ExtLamInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ExtLamInfo] -> ShowS
    $cshowList :: [ExtLamInfo] -> ShowS
    show :: ExtLamInfo -> String
    $cshow :: ExtLamInfo -> String
    showsPrec :: Int -> ExtLamInfo -> ShowS
    $cshowsPrec :: Int -> ExtLamInfo -> ShowS
    Show, (forall x. ExtLamInfo -> Rep ExtLamInfo x)
    -> (forall x. Rep ExtLamInfo x -> ExtLamInfo) -> Generic ExtLamInfo
    forall x. Rep ExtLamInfo x -> ExtLamInfo
    forall x. ExtLamInfo -> Rep ExtLamInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ExtLamInfo x -> ExtLamInfo
    $cfrom :: forall x. ExtLamInfo -> Rep ExtLamInfo x
    Generic)

    modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo
    modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo
    modifySystem System -> System
    f ExtLamInfo
    e = let !e' :: ExtLamInfo
    e' = ExtLamInfo
    e { extLamSys :: Maybe System
    extLamSys = System -> System
    f (System -> System) -> Maybe System -> Maybe System
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ExtLamInfo -> Maybe System
    extLamSys ExtLamInfo
    e } in ExtLamInfo
    e'

    -- | Additional information for projection 'Function's.
    data Projection = Projection
      { Projection -> Maybe QName
    projProper    :: Maybe QName
        -- ^ @Nothing@ if only projection-like, @Just r@ if record projection.
        --   The @r@ is the name of the record type projected from.
        --   This field is updated by module application.
      , Projection -> QName
    projOrig      :: QName
        -- ^ The original projection name
        --   (current name could be from module application).
      , Projection -> Arg QName
    projFromType  :: Arg QName
        -- ^ Type projected from. Original record type if @projProper = Just{}@.
        --   Also stores @ArgInfo@ of the principal argument.
        --   This field is unchanged by module application.
      , Projection -> Int
    projIndex     :: Int
        -- ^ Index of the record argument.
        --   Start counting with 1, because 0 means that
        --   it is already applied to the record value.
        --   This can happen in module instantiation, but
        --   then either the record value is @var 0@, or @funProjection == Nothing@.
      , Projection -> ProjLams
    projLams :: ProjLams
        -- ^ Term @t@ to be be applied to record parameters and record value.
        --   The parameters will be dropped.
        --   In case of a proper projection, a postfix projection application
        --   will be created: @t = \ pars r -> r .p@
        --   (Invariant: the number of abstractions equals 'projIndex'.)
        --   In case of a projection-like function, just the function symbol
        --   is returned as 'Def':  @t = \ pars -> f@.
      } deriving (Typeable Projection
    Typeable Projection
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Projection -> c Projection)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Projection)
    -> (Projection -> Constr)
    -> (Projection -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Projection))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c Projection))
    -> ((forall b. Data b => b -> b) -> Projection -> Projection)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Projection -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Projection -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Projection -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Projection -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Projection -> m Projection)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Projection -> m Projection)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Projection -> m Projection)
    -> Data Projection
    Projection -> DataType
    Projection -> Constr
    (forall b. Data b => b -> b) -> Projection -> Projection
    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) -> Projection -> u
    forall u. (forall d. Data d => d -> u) -> Projection -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Projection -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Projection -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Projection -> m Projection
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Projection -> m Projection
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Projection
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Projection -> c Projection
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Projection)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Projection)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Projection -> m Projection
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Projection -> m Projection
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Projection -> m Projection
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Projection -> m Projection
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Projection -> m Projection
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Projection -> m Projection
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Projection -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Projection -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Projection -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Projection -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Projection -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Projection -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Projection -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Projection -> r
    gmapT :: (forall b. Data b => b -> b) -> Projection -> Projection
    $cgmapT :: (forall b. Data b => b -> b) -> Projection -> Projection
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Projection)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Projection)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Projection)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Projection)
    dataTypeOf :: Projection -> DataType
    $cdataTypeOf :: Projection -> DataType
    toConstr :: Projection -> Constr
    $ctoConstr :: Projection -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Projection
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Projection
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Projection -> c Projection
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Projection -> c Projection
    Data, Int -> Projection -> ShowS
    [Projection] -> ShowS
    Projection -> String
    (Int -> Projection -> ShowS)
    -> (Projection -> String)
    -> ([Projection] -> ShowS)
    -> Show Projection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Projection] -> ShowS
    $cshowList :: [Projection] -> ShowS
    show :: Projection -> String
    $cshow :: Projection -> String
    showsPrec :: Int -> Projection -> ShowS
    $cshowsPrec :: Int -> Projection -> ShowS
    Show, (forall x. Projection -> Rep Projection x)
    -> (forall x. Rep Projection x -> Projection) -> Generic Projection
    forall x. Rep Projection x -> Projection
    forall x. Projection -> Rep Projection x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Projection x -> Projection
    $cfrom :: forall x. Projection -> Rep Projection x
    Generic)

    -- | Abstractions to build projection function (dropping parameters).
    newtype ProjLams = ProjLams { ProjLams -> [Arg String]
    getProjLams :: [Arg ArgName] }
      deriving (Typeable ProjLams
    Typeable ProjLams
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ProjLams -> c ProjLams)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ProjLams)
    -> (ProjLams -> Constr)
    -> (ProjLams -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ProjLams))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProjLams))
    -> ((forall b. Data b => b -> b) -> ProjLams -> ProjLams)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ProjLams -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ProjLams -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ProjLams -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> ProjLams -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams)
    -> Data ProjLams
    ProjLams -> DataType
    ProjLams -> Constr
    (forall b. Data b => b -> b) -> ProjLams -> ProjLams
    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) -> ProjLams -> u
    forall u. (forall d. Data d => d -> u) -> ProjLams -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProjLams -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProjLams -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ProjLams
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProjLams -> c ProjLams
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ProjLams)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProjLams)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProjLams -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ProjLams -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ProjLams -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ProjLams -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProjLams -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ProjLams -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProjLams -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ProjLams -> r
    gmapT :: (forall b. Data b => b -> b) -> ProjLams -> ProjLams
    $cgmapT :: (forall b. Data b => b -> b) -> ProjLams -> ProjLams
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProjLams)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProjLams)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ProjLams)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ProjLams)
    dataTypeOf :: ProjLams -> DataType
    $cdataTypeOf :: ProjLams -> DataType
    toConstr :: ProjLams -> Constr
    $ctoConstr :: ProjLams -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ProjLams
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ProjLams
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProjLams -> c ProjLams
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ProjLams -> c ProjLams
    Data, Int -> ProjLams -> ShowS
    [ProjLams] -> ShowS
    ProjLams -> String
    (Int -> ProjLams -> ShowS)
    -> (ProjLams -> String) -> ([ProjLams] -> ShowS) -> Show ProjLams
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ProjLams] -> ShowS
    $cshowList :: [ProjLams] -> ShowS
    show :: ProjLams -> String
    $cshow :: ProjLams -> String
    showsPrec :: Int -> ProjLams -> ShowS
    $cshowsPrec :: Int -> ProjLams -> ShowS
    Show, ProjLams
    ProjLams -> Bool
    ProjLams -> (ProjLams -> Bool) -> Null ProjLams
    forall a. a -> (a -> Bool) -> Null a
    null :: ProjLams -> Bool
    $cnull :: ProjLams -> Bool
    empty :: ProjLams
    $cempty :: ProjLams
    Null, (forall x. ProjLams -> Rep ProjLams x)
    -> (forall x. Rep ProjLams x -> ProjLams) -> Generic ProjLams
    forall x. Rep ProjLams x -> ProjLams
    forall x. ProjLams -> Rep ProjLams x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ProjLams x -> ProjLams
    $cfrom :: forall x. ProjLams -> Rep ProjLams x
    Generic)

    -- | Building the projection function (which drops the parameters).
    projDropPars :: Projection -> ProjOrigin -> Term
    -- Proper projections:
    projDropPars :: Projection -> ProjOrigin -> Term
    projDropPars (Projection Just{} QName
    d Arg QName
    _ Int
    _ ProjLams
    lams) ProjOrigin
    o =
      case [Arg String] -> Maybe ([Arg String], Arg String)
    forall a. [a] -> Maybe ([a], a)
    initLast ([Arg String] -> Maybe ([Arg String], Arg String))
    -> [Arg String] -> Maybe ([Arg String], Arg String)
    forall a b. (a -> b) -> a -> b
    $ ProjLams -> [Arg String]
    getProjLams ProjLams
    lams of
        Maybe ([Arg String], Arg String)
    Nothing -> QName -> [Elim] -> Term
    Def QName
    d []
        Just ([Arg String]
    pars, Arg ArgInfo
    i String
    y) ->
          let core :: Term
    core = ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    i (Abs Term -> Term) -> Abs Term -> Term
    forall a b. (a -> b) -> a -> b
    $ String -> Term -> Abs Term
    forall a. String -> a -> Abs a
    Abs String
    y (Term -> Abs Term) -> Term -> Abs Term
    forall a b. (a -> b) -> a -> b
    $ Int -> [Elim] -> Term
    Var Int
    0 [ProjOrigin -> QName -> Elim
    forall a. ProjOrigin -> QName -> Elim' a
    Proj ProjOrigin
    o QName
    d] in
          (Arg String -> Term -> Term) -> Term -> [Arg String] -> Term
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    List.foldr (\ (Arg ArgInfo
    ai String
    x) -> ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    ai (Abs Term -> Term) -> (Term -> Abs Term) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Term -> Abs Term
    forall a. String -> a -> Abs a
    NoAbs String
    x) Term
    core [Arg String]
    pars
    -- Projection-like functions:
    projDropPars (Projection Maybe QName
    Nothing QName
    d Arg QName
    _ Int
    _ ProjLams
    lams) ProjOrigin
    o =
      (Arg String -> Term -> Term) -> Term -> [Arg String] -> Term
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    List.foldr (\ (Arg ArgInfo
    ai String
    x) -> ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    ai (Abs Term -> Term) -> (Term -> Abs Term) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Term -> Abs Term
    forall a. String -> a -> Abs a
    NoAbs String
    x) (QName -> [Elim] -> Term
    Def QName
    d []) ([Arg String] -> Term) -> [Arg String] -> Term
    forall a b. (a -> b) -> a -> b
    $
        [Arg String] -> [Arg String] -> [Arg String]
    forall a. [a] -> [a] -> [a]
    initWithDefault [Arg String]
    forall a. HasCallStack => a
    __IMPOSSIBLE__ ([Arg String] -> [Arg String]) -> [Arg String] -> [Arg String]
    forall a b. (a -> b) -> a -> b
    $ ProjLams -> [Arg String]
    getProjLams ProjLams
    lams

    -- | The info of the principal (record) argument.
    projArgInfo :: Projection -> ArgInfo
    projArgInfo :: Projection -> ArgInfo
    projArgInfo (Projection Maybe QName
    _ QName
    _ Arg QName
    _ Int
    _ ProjLams
    lams) =
      ArgInfo -> (Arg String -> ArgInfo) -> Maybe (Arg String) -> ArgInfo
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe ArgInfo
    forall a. HasCallStack => a
    __IMPOSSIBLE__ Arg String -> ArgInfo
    forall a. LensArgInfo a => a -> ArgInfo
    getArgInfo (Maybe (Arg String) -> ArgInfo) -> Maybe (Arg String) -> ArgInfo
    forall a b. (a -> b) -> a -> b
    $ [Arg String] -> Maybe (Arg String)
    forall a. [a] -> Maybe a
    lastMaybe ([Arg String] -> Maybe (Arg String))
    -> [Arg String] -> Maybe (Arg String)
    forall a b. (a -> b) -> a -> b
    $ ProjLams -> [Arg String]
    getProjLams ProjLams
    lams

    -- | Should a record type admit eta-equality?
    data EtaEquality
      = Specified { EtaEquality -> HasEta
    theEtaEquality :: !HasEta }  -- ^ User specifed 'eta-equality' or 'no-eta-equality'.
      | Inferred  { theEtaEquality :: !HasEta }  -- ^ Positivity checker inferred whether eta is safe.
      deriving (Typeable EtaEquality
    Typeable EtaEquality
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> EtaEquality -> c EtaEquality)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c EtaEquality)
    -> (EtaEquality -> Constr)
    -> (EtaEquality -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c EtaEquality))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c EtaEquality))
    -> ((forall b. Data b => b -> b) -> EtaEquality -> EtaEquality)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r)
    -> (forall u. (forall d. Data d => d -> u) -> EtaEquality -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> EtaEquality -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality)
    -> Data EtaEquality
    EtaEquality -> DataType
    EtaEquality -> Constr
    (forall b. Data b => b -> b) -> EtaEquality -> EtaEquality
    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) -> EtaEquality -> u
    forall u. (forall d. Data d => d -> u) -> EtaEquality -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EtaEquality
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EtaEquality -> c EtaEquality
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EtaEquality)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EtaEquality)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EtaEquality -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EtaEquality -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> EtaEquality -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> EtaEquality -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r
    gmapT :: (forall b. Data b => b -> b) -> EtaEquality -> EtaEquality
    $cgmapT :: (forall b. Data b => b -> b) -> EtaEquality -> EtaEquality
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EtaEquality)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EtaEquality)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EtaEquality)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EtaEquality)
    dataTypeOf :: EtaEquality -> DataType
    $cdataTypeOf :: EtaEquality -> DataType
    toConstr :: EtaEquality -> Constr
    $ctoConstr :: EtaEquality -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EtaEquality
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EtaEquality
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EtaEquality -> c EtaEquality
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EtaEquality -> c EtaEquality
    Data, Int -> EtaEquality -> ShowS
    [EtaEquality] -> ShowS
    EtaEquality -> String
    (Int -> EtaEquality -> ShowS)
    -> (EtaEquality -> String)
    -> ([EtaEquality] -> ShowS)
    -> Show EtaEquality
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [EtaEquality] -> ShowS
    $cshowList :: [EtaEquality] -> ShowS
    show :: EtaEquality -> String
    $cshow :: EtaEquality -> String
    showsPrec :: Int -> EtaEquality -> ShowS
    $cshowsPrec :: Int -> EtaEquality -> ShowS
    Show, EtaEquality -> EtaEquality -> Bool
    (EtaEquality -> EtaEquality -> Bool)
    -> (EtaEquality -> EtaEquality -> Bool) -> Eq EtaEquality
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: EtaEquality -> EtaEquality -> Bool
    $c/= :: EtaEquality -> EtaEquality -> Bool
    == :: EtaEquality -> EtaEquality -> Bool
    $c== :: EtaEquality -> EtaEquality -> Bool
    Eq, (forall x. EtaEquality -> Rep EtaEquality x)
    -> (forall x. Rep EtaEquality x -> EtaEquality)
    -> Generic EtaEquality
    forall x. Rep EtaEquality x -> EtaEquality
    forall x. EtaEquality -> Rep EtaEquality x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep EtaEquality x -> EtaEquality
    $cfrom :: forall x. EtaEquality -> Rep EtaEquality x
    Generic)

    instance PatternMatchingAllowed EtaEquality where
      patternMatchingAllowed :: EtaEquality -> Bool
    patternMatchingAllowed = HasEta -> Bool
    forall a. PatternMatchingAllowed a => a -> Bool
    patternMatchingAllowed (HasEta -> Bool) -> (EtaEquality -> HasEta) -> EtaEquality -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EtaEquality -> HasEta
    theEtaEquality

    instance CopatternMatchingAllowed EtaEquality where
      copatternMatchingAllowed :: EtaEquality -> Bool
    copatternMatchingAllowed = HasEta -> Bool
    forall a. CopatternMatchingAllowed a => a -> Bool
    copatternMatchingAllowed (HasEta -> Bool) -> (EtaEquality -> HasEta) -> EtaEquality -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EtaEquality -> HasEta
    theEtaEquality

    -- | Make sure we do not overwrite a user specification.
    setEtaEquality :: EtaEquality -> HasEta -> EtaEquality
    setEtaEquality :: EtaEquality -> HasEta -> EtaEquality
    setEtaEquality e :: EtaEquality
    e@Specified{} HasEta
    _ = EtaEquality
    e
    setEtaEquality EtaEquality
    _ HasEta
    b = HasEta -> EtaEquality
    Inferred HasEta
    b

    data FunctionFlag
      = FunStatic  -- ^ Should calls to this function be normalised at compile-time?
      | FunInline  -- ^ Should calls to this function be inlined by the compiler?
      | FunMacro   -- ^ Is this function a macro?
      deriving (Typeable FunctionFlag
    Typeable FunctionFlag
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> FunctionFlag -> c FunctionFlag)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c FunctionFlag)
    -> (FunctionFlag -> Constr)
    -> (FunctionFlag -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c FunctionFlag))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c FunctionFlag))
    -> ((forall b. Data b => b -> b) -> FunctionFlag -> FunctionFlag)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r)
    -> (forall u. (forall d. Data d => d -> u) -> FunctionFlag -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FunctionFlag -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag)
    -> Data FunctionFlag
    FunctionFlag -> DataType
    FunctionFlag -> Constr
    (forall b. Data b => b -> b) -> FunctionFlag -> FunctionFlag
    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) -> FunctionFlag -> u
    forall u. (forall d. Data d => d -> u) -> FunctionFlag -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunctionFlag
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunctionFlag -> c FunctionFlag
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunctionFlag)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FunctionFlag)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunctionFlag -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunctionFlag -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FunctionFlag -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> FunctionFlag -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r
    gmapT :: (forall b. Data b => b -> b) -> FunctionFlag -> FunctionFlag
    $cgmapT :: (forall b. Data b => b -> b) -> FunctionFlag -> FunctionFlag
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FunctionFlag)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FunctionFlag)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunctionFlag)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FunctionFlag)
    dataTypeOf :: FunctionFlag -> DataType
    $cdataTypeOf :: FunctionFlag -> DataType
    toConstr :: FunctionFlag -> Constr
    $ctoConstr :: FunctionFlag -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunctionFlag
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FunctionFlag
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunctionFlag -> c FunctionFlag
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FunctionFlag -> c FunctionFlag
    Data, FunctionFlag -> FunctionFlag -> Bool
    (FunctionFlag -> FunctionFlag -> Bool)
    -> (FunctionFlag -> FunctionFlag -> Bool) -> Eq FunctionFlag
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: FunctionFlag -> FunctionFlag -> Bool
    $c/= :: FunctionFlag -> FunctionFlag -> Bool
    == :: FunctionFlag -> FunctionFlag -> Bool
    $c== :: FunctionFlag -> FunctionFlag -> Bool
    Eq, Eq FunctionFlag
    Eq FunctionFlag
    -> (FunctionFlag -> FunctionFlag -> Ordering)
    -> (FunctionFlag -> FunctionFlag -> Bool)
    -> (FunctionFlag -> FunctionFlag -> Bool)
    -> (FunctionFlag -> FunctionFlag -> Bool)
    -> (FunctionFlag -> FunctionFlag -> Bool)
    -> (FunctionFlag -> FunctionFlag -> FunctionFlag)
    -> (FunctionFlag -> FunctionFlag -> FunctionFlag)
    -> Ord FunctionFlag
    FunctionFlag -> FunctionFlag -> Bool
    FunctionFlag -> FunctionFlag -> Ordering
    FunctionFlag -> FunctionFlag -> FunctionFlag
    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 :: FunctionFlag -> FunctionFlag -> FunctionFlag
    $cmin :: FunctionFlag -> FunctionFlag -> FunctionFlag
    max :: FunctionFlag -> FunctionFlag -> FunctionFlag
    $cmax :: FunctionFlag -> FunctionFlag -> FunctionFlag
    >= :: FunctionFlag -> FunctionFlag -> Bool
    $c>= :: FunctionFlag -> FunctionFlag -> Bool
    > :: FunctionFlag -> FunctionFlag -> Bool
    $c> :: FunctionFlag -> FunctionFlag -> Bool
    <= :: FunctionFlag -> FunctionFlag -> Bool
    $c<= :: FunctionFlag -> FunctionFlag -> Bool
    < :: FunctionFlag -> FunctionFlag -> Bool
    $c< :: FunctionFlag -> FunctionFlag -> Bool
    compare :: FunctionFlag -> FunctionFlag -> Ordering
    $ccompare :: FunctionFlag -> FunctionFlag -> Ordering
    Ord, Int -> FunctionFlag
    FunctionFlag -> Int
    FunctionFlag -> [FunctionFlag]
    FunctionFlag -> FunctionFlag
    FunctionFlag -> FunctionFlag -> [FunctionFlag]
    FunctionFlag -> FunctionFlag -> FunctionFlag -> [FunctionFlag]
    (FunctionFlag -> FunctionFlag)
    -> (FunctionFlag -> FunctionFlag)
    -> (Int -> FunctionFlag)
    -> (FunctionFlag -> Int)
    -> (FunctionFlag -> [FunctionFlag])
    -> (FunctionFlag -> FunctionFlag -> [FunctionFlag])
    -> (FunctionFlag -> FunctionFlag -> [FunctionFlag])
    -> (FunctionFlag -> FunctionFlag -> FunctionFlag -> [FunctionFlag])
    -> Enum FunctionFlag
    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 :: FunctionFlag -> FunctionFlag -> FunctionFlag -> [FunctionFlag]
    $cenumFromThenTo :: FunctionFlag -> FunctionFlag -> FunctionFlag -> [FunctionFlag]
    enumFromTo :: FunctionFlag -> FunctionFlag -> [FunctionFlag]
    $cenumFromTo :: FunctionFlag -> FunctionFlag -> [FunctionFlag]
    enumFromThen :: FunctionFlag -> FunctionFlag -> [FunctionFlag]
    $cenumFromThen :: FunctionFlag -> FunctionFlag -> [FunctionFlag]
    enumFrom :: FunctionFlag -> [FunctionFlag]
    $cenumFrom :: FunctionFlag -> [FunctionFlag]
    fromEnum :: FunctionFlag -> Int
    $cfromEnum :: FunctionFlag -> Int
    toEnum :: Int -> FunctionFlag
    $ctoEnum :: Int -> FunctionFlag
    pred :: FunctionFlag -> FunctionFlag
    $cpred :: FunctionFlag -> FunctionFlag
    succ :: FunctionFlag -> FunctionFlag
    $csucc :: FunctionFlag -> FunctionFlag
    Enum, Int -> FunctionFlag -> ShowS
    [FunctionFlag] -> ShowS
    FunctionFlag -> String
    (Int -> FunctionFlag -> ShowS)
    -> (FunctionFlag -> String)
    -> ([FunctionFlag] -> ShowS)
    -> Show FunctionFlag
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [FunctionFlag] -> ShowS
    $cshowList :: [FunctionFlag] -> ShowS
    show :: FunctionFlag -> String
    $cshow :: FunctionFlag -> String
    showsPrec :: Int -> FunctionFlag -> ShowS
    $cshowsPrec :: Int -> FunctionFlag -> ShowS
    Show, (forall x. FunctionFlag -> Rep FunctionFlag x)
    -> (forall x. Rep FunctionFlag x -> FunctionFlag)
    -> Generic FunctionFlag
    forall x. Rep FunctionFlag x -> FunctionFlag
    forall x. FunctionFlag -> Rep FunctionFlag x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep FunctionFlag x -> FunctionFlag
    $cfrom :: forall x. FunctionFlag -> Rep FunctionFlag x
    Generic)

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

    emptyCompKit :: CompKit
    emptyCompKit :: CompKit
    emptyCompKit = Maybe QName -> Maybe QName -> CompKit
    CompKit Maybe QName
    forall a. Maybe a
    Nothing Maybe QName
    forall a. Maybe a
    Nothing

    defaultAxiom :: Defn
    defaultAxiom :: Defn
    defaultAxiom = Bool -> Defn
    Axiom Bool
    False

    constTranspAxiom :: Defn
    constTranspAxiom :: Defn
    constTranspAxiom = Bool -> Defn
    Axiom Bool
    True

    data Defn = Axiom -- ^ Postulate
                { Defn -> Bool
    axiomConstTransp :: Bool
                  -- ^ Can transp for this postulate be constant?
                  --   Set to @True@ for bultins like String.
                }
              | DataOrRecSig
                { Defn -> Int
    datarecPars :: Int }
                -- ^ Data or record type signature that doesn't yet have a definition
              | GeneralizableVar -- ^ Generalizable variable (introduced in `generalize` block)
              | AbstractDefn Defn
                -- ^ Returned by 'getConstInfo' if definition is abstract.
              | Function
                { Defn -> [Clause]
    funClauses        :: [Clause]
                , Defn -> Maybe CompiledClauses
    funCompiled       :: Maybe CompiledClauses
                  -- ^ 'Nothing' while function is still type-checked.
                  --   @Just cc@ after type and coverage checking and
                  --   translation to case trees.
                , Defn -> Maybe SplitTree
    funSplitTree      :: Maybe SplitTree
                  -- ^ The split tree constructed by the coverage
                  --   checker. Needed to re-compile the clauses after
                  --   forcing translation.
                , Defn -> Maybe Compiled
    funTreeless       :: Maybe Compiled
                  -- ^ Intermediate representation for compiler backends.
                , Defn -> [Clause]
    funCovering       :: [Clause]
                  -- ^ Covering clauses computed by coverage checking.
                  --   Erased by (IApply) confluence checking(?)
                , Defn -> FunctionInverse
    funInv            :: FunctionInverse
                , Defn -> Maybe [QName]
    funMutual         :: Maybe [QName]
                  -- ^ Mutually recursive functions, @data@s and @record@s.
                  --   Does include this function.
                  --   Empty list if not recursive.
                  --   @Nothing@ if not yet computed (by positivity checker).
                , Defn -> IsAbstract
    funAbstr          :: IsAbstract
                , Defn -> Delayed
    funDelayed        :: Delayed
                  -- ^ Are the clauses of this definition delayed?
                , Defn -> Maybe Projection
    funProjection     :: Maybe Projection
                  -- ^ Is it a record projection?
                  --   If yes, then return the name of the record type and index of
                  --   the record argument.  Start counting with 1, because 0 means that
                  --   it is already applied to the record. (Can happen in module
                  --   instantiation.) This information is used in the termination
                  --   checker.
                , Defn -> Set FunctionFlag
    funFlags          :: Set FunctionFlag
                , Defn -> Maybe Bool
    funTerminates     :: Maybe Bool
                  -- ^ Has this function been termination checked?  Did it pass?
                , Defn -> Maybe ExtLamInfo
    funExtLam         :: Maybe ExtLamInfo
                  -- ^ Is this function generated from an extended lambda?
                  --   If yes, then return the number of hidden and non-hidden lambda-lifted arguments
                , Defn -> Maybe QName
    funWith           :: Maybe QName
                  -- ^ Is this a generated with-function? If yes, then what's the
                  --   name of the parent function.
                }
              | Datatype
                { Defn -> Int
    dataPars           :: Nat            -- ^ Number of parameters.
                , Defn -> Int
    dataIxs            :: Nat            -- ^ Number of indices.
                , Defn -> Maybe Clause
    dataClause         :: (Maybe Clause) -- ^ This might be in an instantiated module.
                , Defn -> [QName]
    dataCons           :: [QName]
                  -- ^ Constructor names , ordered according to the order of their definition.
                , Defn -> Sort
    dataSort           :: Sort
                , Defn -> Maybe [QName]
    dataMutual         :: Maybe [QName]
                  -- ^ Mutually recursive functions, @data@s and @record@s.
                  --   Does include this data type.
                  --   Empty if not recursive.
                  --   @Nothing@ if not yet computed (by positivity checker).
                , Defn -> IsAbstract
    dataAbstr          :: IsAbstract
                , Defn -> [QName]
    dataPathCons       :: [QName]        -- ^ Path constructor names (subset of dataCons)
                }
              | Record
                { Defn -> Int
    recPars           :: Nat
                  -- ^ Number of parameters.
                , Defn -> Maybe Clause
    recClause         :: Maybe Clause
                  -- ^ Was this record type created by a module application?
                  --   If yes, the clause is its definition (linking back to the original record type).
                , Defn -> ConHead
    recConHead        :: ConHead
                  -- ^ Constructor name and fields.
                , Defn -> Bool
    recNamedCon       :: Bool
                  -- ^ Does this record have a @constructor@?
                , Defn -> [Dom QName]
    recFields         :: [Dom QName]
                  -- ^ The record field names.
                , Defn -> Telescope
    recTel            :: Telescope
                  -- ^ The record field telescope. (Includes record parameters.)
                  --   Note: @TelV recTel _ == telView' recConType@.
                  --   Thus, @recTel@ is redundant.
                , Defn -> Maybe [QName]
    recMutual         :: Maybe [QName]
                  -- ^ Mutually recursive functions, @data@s and @record@s.
                  --   Does include this record.
                  --   Empty if not recursive.
                  --   @Nothing@ if not yet computed (by positivity checker).
                , Defn -> EtaEquality
    recEtaEquality'    :: EtaEquality
                  -- ^ Eta-expand at this record type?
                  --   @False@ for unguarded recursive records and coinductive records
                  --   unless the user specifies otherwise.
                , Defn -> PatternOrCopattern
    recPatternMatching :: PatternOrCopattern
                  -- ^ In case eta-equality is off, do we allow pattern matching on the
                  --   constructor or construction by copattern matching?
                  --   Having both loses subject reduction, see issue #4560.
                  --   After positivity checking, this field is obsolete, part of 'EtaEquality'.
                , Defn -> Maybe Induction
    recInduction      :: Maybe Induction
                  -- ^ 'Inductive' or 'CoInductive'?  Matters only for recursive records.
                  --   'Nothing' means that the user did not specify it, which is an error
                  --   for recursive records.
                , Defn -> IsAbstract
    recAbstr          :: IsAbstract
                , Defn -> CompKit
    recComp           :: CompKit
                }
              | Constructor
                { Defn -> Int
    conPars   :: Int         -- ^ Number of parameters.
                , Defn -> Int
    conArity  :: Int         -- ^ Number of arguments (excluding parameters).
                , Defn -> ConHead
    conSrcCon :: ConHead     -- ^ Name of (original) constructor and fields. (This might be in a module instance.)
                , Defn -> QName
    conData   :: QName       -- ^ Name of datatype or record type.
                , Defn -> IsAbstract
    conAbstr  :: IsAbstract
                , Defn -> Induction
    conInd    :: Induction   -- ^ Inductive or coinductive?
                , Defn -> CompKit
    conComp   :: CompKit     -- ^ Cubical composition.
                , Defn -> Maybe [QName]
    conProj   :: Maybe [QName] -- ^ Projections. 'Nothing' if not yet computed.
                , Defn -> [IsForced]
    conForced :: [IsForced]
                  -- ^ Which arguments are forced (i.e. determined by the type of the constructor)?
                  --   Either this list is empty (if the forcing analysis isn't run), or its length is @conArity@.
                , Defn -> Maybe [Bool]
    conErased :: Maybe [Bool]
                  -- ^ Which arguments are erased at runtime (computed during compilation to treeless)?
                  --   'True' means erased, 'False' means retained.
                  --   'Nothing' if no erasure analysis has been performed yet.
                  --   The length of the list is @conArity@.
                }
              | Primitive  -- ^ Primitive or builtin functions.
                { Defn -> IsAbstract
    primAbstr :: IsAbstract
                , Defn -> String
    primName  :: String
                , Defn -> [Clause]
    primClauses :: [Clause]
                  -- ^ 'null' for primitive functions, @not null@ for builtin functions.
                , Defn -> FunctionInverse
    primInv      :: FunctionInverse
                  -- ^ Builtin functions can have inverses. For instance, natural number addition.
                , Defn -> Maybe CompiledClauses
    primCompiled :: Maybe CompiledClauses
                  -- ^ 'Nothing' for primitive functions,
                  --   @'Just' something@ for builtin functions.
                }
              | PrimitiveSort
                { primName :: String
                , Defn -> Sort
    primSort :: Sort
                }
        deriving (Typeable Defn
    Typeable Defn
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Defn -> c Defn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Defn)
    -> (Defn -> Constr)
    -> (Defn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Defn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn))
    -> ((forall b. Data b => b -> b) -> Defn -> Defn)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Defn -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Defn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Defn -> m Defn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Defn -> m Defn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Defn -> m Defn)
    -> Data Defn
    Defn -> DataType
    Defn -> Constr
    (forall b. Data b => b -> b) -> Defn -> Defn
    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) -> Defn -> u
    forall u. (forall d. Data d => d -> u) -> Defn -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Defn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Defn -> c Defn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Defn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Defn -> m Defn
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Defn -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Defn -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Defn -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Defn -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r
    gmapT :: (forall b. Data b => b -> b) -> Defn -> Defn
    $cgmapT :: (forall b. Data b => b -> b) -> Defn -> Defn
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Defn)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Defn)
    dataTypeOf :: Defn -> DataType
    $cdataTypeOf :: Defn -> DataType
    toConstr :: Defn -> Constr
    $ctoConstr :: Defn -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Defn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Defn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Defn -> c Defn
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Defn -> c Defn
    Data, Int -> Defn -> ShowS
    [Defn] -> ShowS
    Defn -> String
    (Int -> Defn -> ShowS)
    -> (Defn -> String) -> ([Defn] -> ShowS) -> Show Defn
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Defn] -> ShowS
    $cshowList :: [Defn] -> ShowS
    show :: Defn -> String
    $cshow :: Defn -> String
    showsPrec :: Int -> Defn -> ShowS
    $cshowsPrec :: Int -> Defn -> ShowS
    Show, (forall x. Defn -> Rep Defn x)
    -> (forall x. Rep Defn x -> Defn) -> Generic Defn
    forall x. Rep Defn x -> Defn
    forall x. Defn -> Rep Defn x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Defn x -> Defn
    $cfrom :: forall x. Defn -> Rep Defn x
    Generic)

    instance Pretty Definition where
      pretty :: Definition -> Doc
    pretty Defn{Bool
    [Maybe Name]
    [Polarity]
    [Occurrence]
    [LocalDisplayForm]
    Maybe QName
    CompiledRepresentation
    Set QName
    ArgInfo
    Language
    QName
    Blocked_
    Type
    MutualId
    Defn
    NumGeneralizableArgs
    theDef :: Defn
    defLanguage :: Language
    defBlocked :: Blocked_
    defCopatternLHS :: Bool
    defInjective :: Bool
    defNoCompilation :: Bool
    defMatchable :: Set QName
    defCopy :: Bool
    defInstance :: Maybe QName
    defCompiledRep :: CompiledRepresentation
    defMutual :: MutualId
    defDisplay :: [LocalDisplayForm]
    defGeneralizedParams :: [Maybe Name]
    defArgGeneralizable :: NumGeneralizableArgs
    defArgOccurrences :: [Occurrence]
    defPolarity :: [Polarity]
    defType :: Type
    defName :: QName
    defArgInfo :: ArgInfo
    theDef :: Definition -> Defn
    defLanguage :: Definition -> Language
    defBlocked :: Definition -> Blocked_
    defCopatternLHS :: Definition -> Bool
    defInjective :: Definition -> Bool
    defNoCompilation :: Definition -> Bool
    defMatchable :: Definition -> Set QName
    defCopy :: Definition -> Bool
    defInstance :: Definition -> Maybe QName
    defCompiledRep :: Definition -> CompiledRepresentation
    defMutual :: Definition -> MutualId
    defDisplay :: Definition -> [LocalDisplayForm]
    defGeneralizedParams :: Definition -> [Maybe Name]
    defArgGeneralizable :: Definition -> NumGeneralizableArgs
    defArgOccurrences :: Definition -> [Occurrence]
    defPolarity :: Definition -> [Polarity]
    defType :: Definition -> Type
    defName :: Definition -> QName
    defArgInfo :: Definition -> ArgInfo
    ..} =
        Doc
    "Defn {" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "defArgInfo        =" Doc -> Doc -> Doc
    <?> ArgInfo -> Doc
    forall a. Show a => a -> Doc
    pshow ArgInfo
    defArgInfo
          , Doc
    "defName           =" Doc -> Doc -> Doc
    <?> QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty QName
    defName
          , Doc
    "defType           =" Doc -> Doc -> Doc
    <?> Type -> Doc
    forall a. Pretty a => a -> Doc
    pretty Type
    defType
          , Doc
    "defPolarity       =" Doc -> Doc -> Doc
    <?> [Polarity] -> Doc
    forall a. Show a => a -> Doc
    pshow [Polarity]
    defPolarity
          , Doc
    "defArgOccurrences =" Doc -> Doc -> Doc
    <?> [Occurrence] -> Doc
    forall a. Show a => a -> Doc
    pshow [Occurrence]
    defArgOccurrences
          , Doc
    "defGeneralizedParams =" Doc -> Doc -> Doc
    <?> [Maybe Name] -> Doc
    forall a. Show a => a -> Doc
    pshow [Maybe Name]
    defGeneralizedParams
          , Doc
    "defDisplay        =" Doc -> Doc -> Doc
    <?> [LocalDisplayForm] -> Doc
    forall a. Pretty a => a -> Doc
    pretty [LocalDisplayForm]
    defDisplay
          , Doc
    "defMutual         =" Doc -> Doc -> Doc
    <?> MutualId -> Doc
    forall a. Show a => a -> Doc
    pshow MutualId
    defMutual
          , Doc
    "defCompiledRep    =" Doc -> Doc -> Doc
    <?> CompiledRepresentation -> Doc
    forall a. Show a => a -> Doc
    pshow CompiledRepresentation
    defCompiledRep
          , Doc
    "defInstance       =" Doc -> Doc -> Doc
    <?> Maybe QName -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe QName
    defInstance
          , Doc
    "defCopy           =" Doc -> Doc -> Doc
    <?> Bool -> Doc
    forall a. Show a => a -> Doc
    pshow Bool
    defCopy
          , Doc
    "defMatchable      =" Doc -> Doc -> Doc
    <?> [QName] -> Doc
    forall a. Show a => a -> Doc
    pshow (Set QName -> [QName]
    forall a. Set a -> [a]
    Set.toList Set QName
    defMatchable)
          , Doc
    "defInjective      =" Doc -> Doc -> Doc
    <?> Bool -> Doc
    forall a. Show a => a -> Doc
    pshow Bool
    defInjective
          , Doc
    "defCopatternLHS   =" Doc -> Doc -> Doc
    <?> Bool -> Doc
    forall a. Show a => a -> Doc
    pshow Bool
    defCopatternLHS
          , Doc
    "theDef            =" Doc -> Doc -> Doc
    <?> Defn -> Doc
    forall a. Pretty a => a -> Doc
    pretty Defn
    theDef ] Doc -> Doc -> Doc
    <+> Doc
    "}"

    instance Pretty Defn where
      pretty :: Defn -> Doc
    pretty Axiom{} = Doc
    "Axiom"
      pretty (DataOrRecSig Int
    n)   = Doc
    "DataOrRecSig" Doc -> Doc -> Doc
    <+> Int -> Doc
    forall a. Pretty a => a -> Doc
    pretty Int
    n
      pretty GeneralizableVar{} = Doc
    "GeneralizableVar"
      pretty (AbstractDefn Defn
    def) = Doc
    "AbstractDefn" Doc -> Doc -> Doc
    <?> Doc -> Doc
    parens (Defn -> Doc
    forall a. Pretty a => a -> Doc
    pretty Defn
    def)
      pretty Function{[Clause]
    Maybe Bool
    Maybe [QName]
    Maybe QName
    Maybe Compiled
    Maybe SplitTree
    Maybe CompiledClauses
    Maybe Projection
    Maybe ExtLamInfo
    Set FunctionFlag
    IsAbstract
    Delayed
    FunctionInverse
    funWith :: Maybe QName
    funExtLam :: Maybe ExtLamInfo
    funTerminates :: Maybe Bool
    funFlags :: Set FunctionFlag
    funProjection :: Maybe Projection
    funDelayed :: Delayed
    funAbstr :: IsAbstract
    funMutual :: Maybe [QName]
    funInv :: FunctionInverse
    funCovering :: [Clause]
    funTreeless :: Maybe Compiled
    funSplitTree :: Maybe SplitTree
    funCompiled :: Maybe CompiledClauses
    funClauses :: [Clause]
    funWith :: Defn -> Maybe QName
    funExtLam :: Defn -> Maybe ExtLamInfo
    funTerminates :: Defn -> Maybe Bool
    funFlags :: Defn -> Set FunctionFlag
    funProjection :: Defn -> Maybe Projection
    funDelayed :: Defn -> Delayed
    funAbstr :: Defn -> IsAbstract
    funMutual :: Defn -> Maybe [QName]
    funInv :: Defn -> FunctionInverse
    funCovering :: Defn -> [Clause]
    funTreeless :: Defn -> Maybe Compiled
    funSplitTree :: Defn -> Maybe SplitTree
    funCompiled :: Defn -> Maybe CompiledClauses
    funClauses :: Defn -> [Clause]
    ..} =
        Doc
    "Function {" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "funClauses      =" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat ((Clause -> Doc) -> [Clause] -> [Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map Clause -> Doc
    forall a. Pretty a => a -> Doc
    pretty [Clause]
    funClauses)
          , Doc
    "funCompiled     =" Doc -> Doc -> Doc
    <?> Maybe CompiledClauses -> Doc
    forall a. Pretty a => a -> Doc
    pretty Maybe CompiledClauses
    funCompiled
          , Doc
    "funSplitTree    =" Doc -> Doc -> Doc
    <?> Maybe SplitTree -> Doc
    forall a. Pretty a => a -> Doc
    pretty Maybe SplitTree
    funSplitTree
          , Doc
    "funTreeless     =" Doc -> Doc -> Doc
    <?> Maybe Compiled -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe Compiled
    funTreeless
          , Doc
    "funInv          =" Doc -> Doc -> Doc
    <?> FunctionInverse -> Doc
    forall a. Pretty a => a -> Doc
    pretty FunctionInverse
    funInv
          , Doc
    "funMutual       =" Doc -> Doc -> Doc
    <?> Maybe [QName] -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe [QName]
    funMutual
          , Doc
    "funAbstr        =" Doc -> Doc -> Doc
    <?> IsAbstract -> Doc
    forall a. Show a => a -> Doc
    pshow IsAbstract
    funAbstr
          , Doc
    "funDelayed      =" Doc -> Doc -> Doc
    <?> Delayed -> Doc
    forall a. Show a => a -> Doc
    pshow Delayed
    funDelayed
          , Doc
    "funProjection   =" Doc -> Doc -> Doc
    <?> Maybe Projection -> Doc
    forall a. Pretty a => a -> Doc
    pretty Maybe Projection
    funProjection
          , Doc
    "funFlags        =" Doc -> Doc -> Doc
    <?> Set FunctionFlag -> Doc
    forall a. Show a => a -> Doc
    pshow Set FunctionFlag
    funFlags
          , Doc
    "funTerminates   =" Doc -> Doc -> Doc
    <?> Maybe Bool -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe Bool
    funTerminates
          , Doc
    "funWith         =" Doc -> Doc -> Doc
    <?> Maybe QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty Maybe QName
    funWith ] Doc -> Doc -> Doc
    <?> Doc
    "}"
      pretty Datatype{Int
    [QName]
    Maybe [QName]
    Maybe Clause
    IsAbstract
    Sort
    dataPathCons :: [QName]
    dataAbstr :: IsAbstract
    dataMutual :: Maybe [QName]
    dataSort :: Sort
    dataCons :: [QName]
    dataClause :: Maybe Clause
    dataIxs :: Int
    dataPars :: Int
    dataPathCons :: Defn -> [QName]
    dataAbstr :: Defn -> IsAbstract
    dataMutual :: Defn -> Maybe [QName]
    dataSort :: Defn -> Sort
    dataCons :: Defn -> [QName]
    dataClause :: Defn -> Maybe Clause
    dataIxs :: Defn -> Int
    dataPars :: Defn -> Int
    ..} =
        Doc
    "Datatype {" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "dataPars       =" Doc -> Doc -> Doc
    <?> Int -> Doc
    forall a. Show a => a -> Doc
    pshow Int
    dataPars
          , Doc
    "dataIxs        =" Doc -> Doc -> Doc
    <?> Int -> Doc
    forall a. Show a => a -> Doc
    pshow Int
    dataIxs
          , Doc
    "dataClause     =" Doc -> Doc -> Doc
    <?> Maybe Clause -> Doc
    forall a. Pretty a => a -> Doc
    pretty Maybe Clause
    dataClause
          , Doc
    "dataCons       =" Doc -> Doc -> Doc
    <?> [QName] -> Doc
    forall a. Show a => a -> Doc
    pshow [QName]
    dataCons
          , Doc
    "dataSort       =" Doc -> Doc -> Doc
    <?> Sort -> Doc
    forall a. Pretty a => a -> Doc
    pretty Sort
    dataSort
          , Doc
    "dataMutual     =" Doc -> Doc -> Doc
    <?> Maybe [QName] -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe [QName]
    dataMutual
          , Doc
    "dataAbstr      =" Doc -> Doc -> Doc
    <?> IsAbstract -> Doc
    forall a. Show a => a -> Doc
    pshow IsAbstract
    dataAbstr ] Doc -> Doc -> Doc
    <?> Doc
    "}"
      pretty Record{Bool
    Int
    [Dom QName]
    Maybe [QName]
    Maybe Induction
    Maybe Clause
    IsAbstract
    PatternOrCopattern
    Telescope
    ConHead
    CompKit
    EtaEquality
    recComp :: CompKit
    recAbstr :: IsAbstract
    recInduction :: Maybe Induction
    recPatternMatching :: PatternOrCopattern
    recEtaEquality' :: EtaEquality
    recMutual :: Maybe [QName]
    recTel :: Telescope
    recFields :: [Dom QName]
    recNamedCon :: Bool
    recConHead :: ConHead
    recClause :: Maybe Clause
    recPars :: Int
    recComp :: Defn -> CompKit
    recAbstr :: Defn -> IsAbstract
    recInduction :: Defn -> Maybe Induction
    recPatternMatching :: Defn -> PatternOrCopattern
    recEtaEquality' :: Defn -> EtaEquality
    recMutual :: Defn -> Maybe [QName]
    recTel :: Defn -> Telescope
    recFields :: Defn -> [Dom QName]
    recNamedCon :: Defn -> Bool
    recConHead :: Defn -> ConHead
    recClause :: Defn -> Maybe Clause
    recPars :: Defn -> Int
    ..} =
        Doc
    "Record {" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "recPars         =" Doc -> Doc -> Doc
    <?> Int -> Doc
    forall a. Show a => a -> Doc
    pshow Int
    recPars
          , Doc
    "recClause       =" Doc -> Doc -> Doc
    <?> Maybe Clause -> Doc
    forall a. Pretty a => a -> Doc
    pretty Maybe Clause
    recClause
          , Doc
    "recConHead      =" Doc -> Doc -> Doc
    <?> ConHead -> Doc
    forall a. Pretty a => a -> Doc
    pretty ConHead
    recConHead
          , Doc
    "recNamedCon     =" Doc -> Doc -> Doc
    <?> Bool -> Doc
    forall a. Pretty a => a -> Doc
    pretty Bool
    recNamedCon
          , Doc
    "recFields       =" Doc -> Doc -> Doc
    <?> [Dom QName] -> Doc
    forall a. Pretty a => a -> Doc
    pretty [Dom QName]
    recFields
          , Doc
    "recTel          =" Doc -> Doc -> Doc
    <?> Telescope -> Doc
    forall a. Pretty a => a -> Doc
    pretty Telescope
    recTel
          , Doc
    "recMutual       =" Doc -> Doc -> Doc
    <?> Maybe [QName] -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe [QName]
    recMutual
          , Doc
    "recEtaEquality' =" Doc -> Doc -> Doc
    <?> EtaEquality -> Doc
    forall a. Show a => a -> Doc
    pshow EtaEquality
    recEtaEquality'
          , Doc
    "recInduction    =" Doc -> Doc -> Doc
    <?> Maybe Induction -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe Induction
    recInduction
          , Doc
    "recAbstr        =" Doc -> Doc -> Doc
    <?> IsAbstract -> Doc
    forall a. Show a => a -> Doc
    pshow IsAbstract
    recAbstr ] Doc -> Doc -> Doc
    <?> Doc
    "}"
      pretty Constructor{Int
    [IsForced]
    Maybe [Bool]
    Maybe [QName]
    IsAbstract
    Induction
    QName
    ConHead
    CompKit
    conErased :: Maybe [Bool]
    conForced :: [IsForced]
    conProj :: Maybe [QName]
    conComp :: CompKit
    conInd :: Induction
    conAbstr :: IsAbstract
    conData :: QName
    conSrcCon :: ConHead
    conArity :: Int
    conPars :: Int
    conErased :: Defn -> Maybe [Bool]
    conForced :: Defn -> [IsForced]
    conProj :: Defn -> Maybe [QName]
    conComp :: Defn -> CompKit
    conInd :: Defn -> Induction
    conAbstr :: Defn -> IsAbstract
    conData :: Defn -> QName
    conSrcCon :: Defn -> ConHead
    conArity :: Defn -> Int
    conPars :: Defn -> Int
    ..} =
        Doc
    "Constructor {" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "conPars   =" Doc -> Doc -> Doc
    <?> Int -> Doc
    forall a. Show a => a -> Doc
    pshow Int
    conPars
          , Doc
    "conArity  =" Doc -> Doc -> Doc
    <?> Int -> Doc
    forall a. Show a => a -> Doc
    pshow Int
    conArity
          , Doc
    "conSrcCon =" Doc -> Doc -> Doc
    <?> ConHead -> Doc
    forall a. Pretty a => a -> Doc
    pretty ConHead
    conSrcCon
          , Doc
    "conData   =" Doc -> Doc -> Doc
    <?> QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty QName
    conData
          , Doc
    "conAbstr  =" Doc -> Doc -> Doc
    <?> IsAbstract -> Doc
    forall a. Show a => a -> Doc
    pshow IsAbstract
    conAbstr
          , Doc
    "conInd    =" Doc -> Doc -> Doc
    <?> Induction -> Doc
    forall a. Show a => a -> Doc
    pshow Induction
    conInd
          , Doc
    "conErased =" Doc -> Doc -> Doc
    <?> Maybe [Bool] -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe [Bool]
    conErased ] Doc -> Doc -> Doc
    <?> Doc
    "}"
      pretty Primitive{String
    [Clause]
    Maybe CompiledClauses
    IsAbstract
    FunctionInverse
    primCompiled :: Maybe CompiledClauses
    primInv :: FunctionInverse
    primClauses :: [Clause]
    primName :: String
    primAbstr :: IsAbstract
    primCompiled :: Defn -> Maybe CompiledClauses
    primInv :: Defn -> FunctionInverse
    primClauses :: Defn -> [Clause]
    primName :: Defn -> String
    primAbstr :: Defn -> IsAbstract
    ..} =
        Doc
    "Primitive {" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "primAbstr    =" Doc -> Doc -> Doc
    <?> IsAbstract -> Doc
    forall a. Show a => a -> Doc
    pshow IsAbstract
    primAbstr
          , Doc
    "primName     =" Doc -> Doc -> Doc
    <?> String -> Doc
    forall a. Show a => a -> Doc
    pshow String
    primName
          , Doc
    "primClauses  =" Doc -> Doc -> Doc
    <?> [Clause] -> Doc
    forall a. Show a => a -> Doc
    pshow [Clause]
    primClauses
          , Doc
    "primCompiled =" Doc -> Doc -> Doc
    <?> Maybe CompiledClauses -> Doc
    forall a. Show a => a -> Doc
    pshow Maybe CompiledClauses
    primCompiled ] Doc -> Doc -> Doc
    <?> Doc
    "}"
      pretty PrimitiveSort{String
    Sort
    primSort :: Sort
    primName :: String
    primSort :: Defn -> Sort
    primName :: Defn -> String
    ..} =
        Doc
    "PrimitiveSort {" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "primName =" Doc -> Doc -> Doc
    <?> String -> Doc
    forall a. Show a => a -> Doc
    pshow String
    primName
          , Doc
    "primSort =" Doc -> Doc -> Doc
    <?> Sort -> Doc
    forall a. Show a => a -> Doc
    pshow Sort
    primSort
          ] Doc -> Doc -> Doc
    <?> Doc
    "}"

    instance Pretty Projection where
      pretty :: Projection -> Doc
    pretty Projection{Int
    Maybe QName
    Arg QName
    QName
    ProjLams
    projLams :: ProjLams
    projIndex :: Int
    projFromType :: Arg QName
    projOrig :: QName
    projProper :: Maybe QName
    projLams :: Projection -> ProjLams
    projIndex :: Projection -> Int
    projFromType :: Projection -> Arg QName
    projOrig :: Projection -> QName
    projProper :: Projection -> Maybe QName
    ..} =
        Doc
    "Projection {" Doc -> Doc -> Doc
    <?> [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat
          [ Doc
    "projProper   =" Doc -> Doc -> Doc
    <?> Maybe QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty Maybe QName
    projProper
          , Doc
    "projOrig     =" Doc -> Doc -> Doc
    <?> QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty QName
    projOrig
          , Doc
    "projFromType =" Doc -> Doc -> Doc
    <?> Arg QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty Arg QName
    projFromType
          , Doc
    "projIndex    =" Doc -> Doc -> Doc
    <?> Int -> Doc
    forall a. Show a => a -> Doc
    pshow Int
    projIndex
          , Doc
    "projLams     =" Doc -> Doc -> Doc
    <?> ProjLams -> Doc
    forall a. Pretty a => a -> Doc
    pretty ProjLams
    projLams
          ]

    instance Pretty c => Pretty (FunctionInverse' c) where
      pretty :: FunctionInverse' c -> Doc
    pretty FunctionInverse' c
    NotInjective = Doc
    "NotInjective"
      pretty (Inverse InversionMap c
    inv) = Doc
    "Inverse" Doc -> Doc -> Doc
    <?>
        [Doc] -> Doc
    forall (t :: * -> *). Foldable t => t Doc -> Doc
    vcat [ TermHead -> Doc
    forall a. Pretty a => a -> Doc
    pretty TermHead
    h Doc -> Doc -> Doc
    <+> Doc
    "->" Doc -> Doc -> Doc
    <?> [c] -> Doc
    forall a. Pretty a => a -> Doc
    pretty [c]
    cs
             | (TermHead
    h, [c]
    cs) <- InversionMap c -> [(TermHead, [c])]
    forall k a. Map k a -> [(k, a)]
    Map.toList InversionMap c
    inv ]

    instance Pretty ProjLams where
      pretty :: ProjLams -> Doc
    pretty (ProjLams [Arg String]
    args) = [Arg String] -> Doc
    forall a. Pretty a => a -> Doc
    pretty [Arg String]
    args

    -- | Is the record type recursive?
    recRecursive :: Defn -> Bool
    recRecursive :: Defn -> Bool
    recRecursive (Record { recMutual :: Defn -> Maybe [QName]
    recMutual = Just [QName]
    qs }) = Bool -> Bool
    not (Bool -> Bool) -> Bool -> Bool
    forall a b. (a -> b) -> a -> b
    $ [QName] -> Bool
    forall a. Null a => a -> Bool
    null [QName]
    qs
    recRecursive Defn
    _ = Bool
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    recEtaEquality :: Defn -> HasEta
    recEtaEquality :: Defn -> HasEta
    recEtaEquality = EtaEquality -> HasEta
    theEtaEquality (EtaEquality -> HasEta) -> (Defn -> EtaEquality) -> Defn -> HasEta
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Defn -> EtaEquality
    recEtaEquality'

    -- | A template for creating 'Function' definitions, with sensible defaults.
    emptyFunction :: Defn
    emptyFunction :: Defn
    emptyFunction = Function :: [Clause]
    -> Maybe CompiledClauses
    -> Maybe SplitTree
    -> Maybe Compiled
    -> [Clause]
    -> FunctionInverse
    -> Maybe [QName]
    -> IsAbstract
    -> Delayed
    -> Maybe Projection
    -> Set FunctionFlag
    -> Maybe Bool
    -> Maybe ExtLamInfo
    -> Maybe QName
    -> Defn
    Function
      { funClauses :: [Clause]
    funClauses     = []
      , funCompiled :: Maybe CompiledClauses
    funCompiled    = Maybe CompiledClauses
    forall a. Maybe a
    Nothing
      , funSplitTree :: Maybe SplitTree
    funSplitTree   = Maybe SplitTree
    forall a. Maybe a
    Nothing
      , funTreeless :: Maybe Compiled
    funTreeless    = Maybe Compiled
    forall a. Maybe a
    Nothing
      , funInv :: FunctionInverse
    funInv         = FunctionInverse
    forall c. FunctionInverse' c
    NotInjective
      , funMutual :: Maybe [QName]
    funMutual      = Maybe [QName]
    forall a. Maybe a
    Nothing
      , funAbstr :: IsAbstract
    funAbstr       = IsAbstract
    ConcreteDef
      , funDelayed :: Delayed
    funDelayed     = Delayed
    NotDelayed
      , funProjection :: Maybe Projection
    funProjection  = Maybe Projection
    forall a. Maybe a
    Nothing
      , funFlags :: Set FunctionFlag
    funFlags       = Set FunctionFlag
    forall a. Set a
    Set.empty
      , funTerminates :: Maybe Bool
    funTerminates  = Maybe Bool
    forall a. Maybe a
    Nothing
      , funExtLam :: Maybe ExtLamInfo
    funExtLam      = Maybe ExtLamInfo
    forall a. Maybe a
    Nothing
      , funWith :: Maybe QName
    funWith        = Maybe QName
    forall a. Maybe a
    Nothing
      , funCovering :: [Clause]
    funCovering    = []
      }

    funFlag :: FunctionFlag -> Lens' Bool Defn
    funFlag :: FunctionFlag -> Lens' Bool Defn
    funFlag FunctionFlag
    flag Bool -> f Bool
    f def :: Defn
    def@Function{ funFlags :: Defn -> Set FunctionFlag
    funFlags = Set FunctionFlag
    flags } =
      Bool -> f Bool
    f (FunctionFlag -> Set FunctionFlag -> Bool
    forall a. Ord a => a -> Set a -> Bool
    Set.member FunctionFlag
    flag Set FunctionFlag
    flags) f Bool -> (Bool -> Defn) -> f Defn
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&>
      \ Bool
    b -> Defn
    def{ funFlags :: Set FunctionFlag
    funFlags = (if Bool
    b then FunctionFlag -> Set FunctionFlag -> Set FunctionFlag
    forall a. Ord a => a -> Set a -> Set a
    Set.insert else FunctionFlag -> Set FunctionFlag -> Set FunctionFlag
    forall a. Ord a => a -> Set a -> Set a
    Set.delete) FunctionFlag
    flag Set FunctionFlag
    flags }
    funFlag FunctionFlag
    _ Bool -> f Bool
    f Defn
    def = Bool -> f Bool
    f Bool
    False f Bool -> Defn -> f Defn
    forall (f :: * -> *) a b. Functor f => f a -> b -> f b
    $> Defn
    def

    funStatic, funInline, funMacro :: Lens' Bool Defn
    funStatic :: Lens' Bool Defn
    funStatic       = FunctionFlag -> Lens' Bool Defn
    funFlag FunctionFlag
    FunStatic
    funInline :: Lens' Bool Defn
    funInline       = FunctionFlag -> Lens' Bool Defn
    funFlag FunctionFlag
    FunInline
    funMacro :: Lens' Bool Defn
    funMacro        = FunctionFlag -> Lens' Bool Defn
    funFlag FunctionFlag
    FunMacro

    isMacro :: Defn -> Bool
    isMacro :: Defn -> Bool
    isMacro = (Defn -> Lens' Bool Defn -> Bool
    forall o i. o -> Lens' i o -> i
    ^. Lens' Bool Defn
    funMacro)

    -- | Checking whether we are dealing with a function yet to be defined.
    isEmptyFunction :: Defn -> Bool
    isEmptyFunction :: Defn -> Bool
    isEmptyFunction Defn
    def =
      case Defn
    def of
        Function { funClauses :: Defn -> [Clause]
    funClauses = [] } -> Bool
    True
        Defn
    _ -> Bool
    False

    isCopatternLHS :: [Clause] -> Bool
    isCopatternLHS :: [Clause] -> Bool
    isCopatternLHS = (Clause -> Bool) -> [Clause] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    List.any ((NamedArg DeBruijnPattern -> Bool)
    -> [NamedArg DeBruijnPattern] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    List.any (Maybe (ProjOrigin, AmbiguousQName) -> Bool
    forall a. Maybe a -> Bool
    isJust (Maybe (ProjOrigin, AmbiguousQName) -> Bool)
    -> (NamedArg DeBruijnPattern -> Maybe (ProjOrigin, AmbiguousQName))
    -> NamedArg DeBruijnPattern
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedArg DeBruijnPattern -> Maybe (ProjOrigin, AmbiguousQName)
    forall a. IsProjP a => a -> Maybe (ProjOrigin, AmbiguousQName)
    A.isProjP) ([NamedArg DeBruijnPattern] -> Bool)
    -> (Clause -> [NamedArg DeBruijnPattern]) -> Clause -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Clause -> [NamedArg DeBruijnPattern]
    namedClausePats)

    recCon :: Defn -> QName
    recCon :: Defn -> QName
    recCon Record{ ConHead
    recConHead :: ConHead
    recConHead :: Defn -> ConHead
    recConHead } = ConHead -> QName
    conName ConHead
    recConHead
    recCon Defn
    _ = QName
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    defIsRecord :: Defn -> Bool
    defIsRecord :: Defn -> Bool
    defIsRecord Record{} = Bool
    True
    defIsRecord Defn
    _        = Bool
    False

    defIsDataOrRecord :: Defn -> Bool
    defIsDataOrRecord :: Defn -> Bool
    defIsDataOrRecord Record{}   = Bool
    True
    defIsDataOrRecord Datatype{} = Bool
    True
    defIsDataOrRecord Defn
    _          = Bool
    False

    defConstructors :: Defn -> [QName]
    defConstructors :: Defn -> [QName]
    defConstructors Datatype{dataCons :: Defn -> [QName]
    dataCons = [QName]
    cs} = [QName]
    cs
    defConstructors Record{recConHead :: Defn -> ConHead
    recConHead = ConHead
    c} = [ConHead -> QName
    conName ConHead
    c]
    defConstructors Defn
    _ = [QName]
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    newtype Fields = Fields [(C.Name, Type)]
      deriving Fields
    Fields -> Bool
    Fields -> (Fields -> Bool) -> Null Fields
    forall a. a -> (a -> Bool) -> Null a
    null :: Fields -> Bool
    $cnull :: Fields -> Bool
    empty :: Fields
    $cempty :: Fields
    Null

    -- | Did we encounter a simplifying reduction?
    --   In terms of CIC, that would be a iota-reduction.
    --   In terms of Agda, this is a constructor or literal
    --   pattern that matched.
    --   Just beta-reduction (substitution) or delta-reduction
    --   (unfolding of definitions) does not count as simplifying?

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

    instance Null Simplification where
      empty :: Simplification
    empty = Simplification
    NoSimplification
      null :: Simplification -> Bool
    null  = (Simplification -> Simplification -> Bool
    forall a. Eq a => a -> a -> Bool
    == Simplification
    NoSimplification)

    instance Semigroup Simplification where
      Simplification
    YesSimplification <> :: Simplification -> Simplification -> Simplification
    <> Simplification
    _ = Simplification
    YesSimplification
      Simplification
    NoSimplification  <> Simplification
    s = Simplification
    s

    instance Monoid Simplification where
      mempty :: Simplification
    mempty = Simplification
    NoSimplification
      mappend :: Simplification -> Simplification -> Simplification
    mappend = Simplification -> Simplification -> Simplification
    forall a. Semigroup a => a -> a -> a
    (<>)

    data Reduced no yes
      = NoReduction no
      | YesReduction Simplification yes
      deriving (forall a b. (a -> b) -> Reduced no a -> Reduced no b)
    -> (forall a b. a -> Reduced no b -> Reduced no a)
    -> Functor (Reduced no)
    forall a b. a -> Reduced no b -> Reduced no a
    forall a b. (a -> b) -> Reduced no a -> Reduced no b
    forall no a b. a -> Reduced no b -> Reduced no a
    forall no a b. (a -> b) -> Reduced no a -> Reduced no b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> Reduced no b -> Reduced no a
    $c<$ :: forall no a b. a -> Reduced no b -> Reduced no a
    fmap :: forall a b. (a -> b) -> Reduced no a -> Reduced no b
    $cfmap :: forall no a b. (a -> b) -> Reduced no a -> Reduced no b
    Functor

    redReturn :: a -> ReduceM (Reduced a' a)
    redReturn :: forall a a'. a -> ReduceM (Reduced a' a)
    redReturn = Reduced a' a -> ReduceM (Reduced a' a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Reduced a' a -> ReduceM (Reduced a' a))
    -> (a -> Reduced a' a) -> a -> ReduceM (Reduced a' a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Simplification -> a -> Reduced a' a
    forall no yes. Simplification -> yes -> Reduced no yes
    YesReduction Simplification
    YesSimplification

    -- | Conceptually: @redBind m f k = either (return . Left . f) k =<< m@

    redBind :: ReduceM (Reduced a a') -> (a -> b) ->
               (a' -> ReduceM (Reduced b b')) -> ReduceM (Reduced b b')
    redBind :: forall a a' b b'.
    ReduceM (Reduced a a')
    -> (a -> b)
    -> (a' -> ReduceM (Reduced b b'))
    -> ReduceM (Reduced b b')
    redBind ReduceM (Reduced a a')
    ma a -> b
    f a' -> ReduceM (Reduced b b')
    k = do
      Reduced a a'
    r <- ReduceM (Reduced a a')
    ma
      case Reduced a a'
    r of
        NoReduction a
    x    -> Reduced b b' -> ReduceM (Reduced b b')
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Reduced b b' -> ReduceM (Reduced b b'))
    -> Reduced b b' -> ReduceM (Reduced b b')
    forall a b. (a -> b) -> a -> b
    $ b -> Reduced b b'
    forall no yes. no -> Reduced no yes
    NoReduction (b -> Reduced b b') -> b -> Reduced b b'
    forall a b. (a -> b) -> a -> b
    $ a -> b
    f a
    x
        YesReduction Simplification
    _ a'
    y -> a' -> ReduceM (Reduced b b')
    k a'
    y

    -- | Three cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked.
    data IsReduced
      = NotReduced
      | Reduced    (Blocked ())

    data MaybeReduced a = MaybeRed
      { forall a. MaybeReduced a -> IsReduced
    isReduced     :: IsReduced
      , forall a. MaybeReduced a -> a
    ignoreReduced :: a
      }
      deriving ((forall a b. (a -> b) -> MaybeReduced a -> MaybeReduced b)
    -> (forall a b. a -> MaybeReduced b -> MaybeReduced a)
    -> Functor MaybeReduced
    forall a b. a -> MaybeReduced b -> MaybeReduced a
    forall a b. (a -> b) -> MaybeReduced a -> MaybeReduced b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> MaybeReduced b -> MaybeReduced a
    $c<$ :: forall a b. a -> MaybeReduced b -> MaybeReduced a
    fmap :: forall a b. (a -> b) -> MaybeReduced a -> MaybeReduced b
    $cfmap :: forall a b. (a -> b) -> MaybeReduced a -> MaybeReduced b
    Functor)

    instance IsProjElim e => IsProjElim (MaybeReduced e) where
      isProjElim :: MaybeReduced e -> Maybe (ProjOrigin, QName)
    isProjElim = e -> Maybe (ProjOrigin, QName)
    forall e. IsProjElim e => e -> Maybe (ProjOrigin, QName)
    isProjElim (e -> Maybe (ProjOrigin, QName))
    -> (MaybeReduced e -> e)
    -> MaybeReduced e
    -> Maybe (ProjOrigin, QName)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . MaybeReduced e -> e
    forall a. MaybeReduced a -> a
    ignoreReduced

    type MaybeReducedArgs = [MaybeReduced (Arg Term)]
    type MaybeReducedElims = [MaybeReduced Elim]

    notReduced :: a -> MaybeReduced a
    notReduced :: forall a. a -> MaybeReduced a
    notReduced a
    x = IsReduced -> a -> MaybeReduced a
    forall a. IsReduced -> a -> MaybeReduced a
    MaybeRed IsReduced
    NotReduced a
    x

    reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term)
    reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term)
    reduced Blocked (Arg Term)
    b = IsReduced -> Arg Term -> MaybeReduced (Arg Term)
    forall a. IsReduced -> a -> MaybeReduced a
    MaybeRed (Blocked_ -> IsReduced
    Reduced (Blocked_ -> IsReduced) -> Blocked_ -> IsReduced
    forall a b. (a -> b) -> a -> b
    $ () () -> Blocked (Arg Term) -> Blocked_
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Blocked (Arg Term)
    b) (Arg Term -> MaybeReduced (Arg Term))
    -> Arg Term -> MaybeReduced (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ Blocked (Arg Term) -> Arg Term
    forall t a. Blocked' t a -> a
    ignoreBlocking Blocked (Arg Term)
    b

    -- | Controlling 'reduce'.
    data AllowedReduction
      = ProjectionReductions     -- ^ (Projection and) projection-like functions may be reduced.
      | InlineReductions         -- ^ Functions marked INLINE may be reduced.
      | CopatternReductions      -- ^ Copattern definitions may be reduced.
      | FunctionReductions       -- ^ Non-recursive functions and primitives may be reduced.
      | RecursiveReductions      -- ^ Even recursive functions may be reduced.
      | LevelReductions          -- ^ Reduce @'Level'@ terms.
      | TypeLevelReductions      -- ^ Allow @allReductions@ in types, even
                                 --   if not allowed at term level (used
                                 --   by confluence checker)
      | UnconfirmedReductions    -- ^ Functions whose termination has not (yet) been confirmed.
      | NonTerminatingReductions -- ^ Functions that have failed termination checking.
      deriving (Int -> AllowedReduction -> ShowS
    [AllowedReduction] -> ShowS
    AllowedReduction -> String
    (Int -> AllowedReduction -> ShowS)
    -> (AllowedReduction -> String)
    -> ([AllowedReduction] -> ShowS)
    -> Show AllowedReduction
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [AllowedReduction] -> ShowS
    $cshowList :: [AllowedReduction] -> ShowS
    show :: AllowedReduction -> String
    $cshow :: AllowedReduction -> String
    showsPrec :: Int -> AllowedReduction -> ShowS
    $cshowsPrec :: Int -> AllowedReduction -> ShowS
    Show, AllowedReduction -> AllowedReduction -> Bool
    (AllowedReduction -> AllowedReduction -> Bool)
    -> (AllowedReduction -> AllowedReduction -> Bool)
    -> Eq AllowedReduction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AllowedReduction -> AllowedReduction -> Bool
    $c/= :: AllowedReduction -> AllowedReduction -> Bool
    == :: AllowedReduction -> AllowedReduction -> Bool
    $c== :: AllowedReduction -> AllowedReduction -> Bool
    Eq, Eq AllowedReduction
    Eq AllowedReduction
    -> (AllowedReduction -> AllowedReduction -> Ordering)
    -> (AllowedReduction -> AllowedReduction -> Bool)
    -> (AllowedReduction -> AllowedReduction -> Bool)
    -> (AllowedReduction -> AllowedReduction -> Bool)
    -> (AllowedReduction -> AllowedReduction -> Bool)
    -> (AllowedReduction -> AllowedReduction -> AllowedReduction)
    -> (AllowedReduction -> AllowedReduction -> AllowedReduction)
    -> Ord AllowedReduction
    AllowedReduction -> AllowedReduction -> Bool
    AllowedReduction -> AllowedReduction -> Ordering
    AllowedReduction -> AllowedReduction -> AllowedReduction
    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 :: AllowedReduction -> AllowedReduction -> AllowedReduction
    $cmin :: AllowedReduction -> AllowedReduction -> AllowedReduction
    max :: AllowedReduction -> AllowedReduction -> AllowedReduction
    $cmax :: AllowedReduction -> AllowedReduction -> AllowedReduction
    >= :: AllowedReduction -> AllowedReduction -> Bool
    $c>= :: AllowedReduction -> AllowedReduction -> Bool
    > :: AllowedReduction -> AllowedReduction -> Bool
    $c> :: AllowedReduction -> AllowedReduction -> Bool
    <= :: AllowedReduction -> AllowedReduction -> Bool
    $c<= :: AllowedReduction -> AllowedReduction -> Bool
    < :: AllowedReduction -> AllowedReduction -> Bool
    $c< :: AllowedReduction -> AllowedReduction -> Bool
    compare :: AllowedReduction -> AllowedReduction -> Ordering
    $ccompare :: AllowedReduction -> AllowedReduction -> Ordering
    Ord, Int -> AllowedReduction
    AllowedReduction -> Int
    AllowedReduction -> [AllowedReduction]
    AllowedReduction -> AllowedReduction
    AllowedReduction -> AllowedReduction -> [AllowedReduction]
    AllowedReduction
    -> AllowedReduction -> AllowedReduction -> [AllowedReduction]
    (AllowedReduction -> AllowedReduction)
    -> (AllowedReduction -> AllowedReduction)
    -> (Int -> AllowedReduction)
    -> (AllowedReduction -> Int)
    -> (AllowedReduction -> [AllowedReduction])
    -> (AllowedReduction -> AllowedReduction -> [AllowedReduction])
    -> (AllowedReduction -> AllowedReduction -> [AllowedReduction])
    -> (AllowedReduction
        -> AllowedReduction -> AllowedReduction -> [AllowedReduction])
    -> Enum AllowedReduction
    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 :: AllowedReduction
    -> AllowedReduction -> AllowedReduction -> [AllowedReduction]
    $cenumFromThenTo :: AllowedReduction
    -> AllowedReduction -> AllowedReduction -> [AllowedReduction]
    enumFromTo :: AllowedReduction -> AllowedReduction -> [AllowedReduction]
    $cenumFromTo :: AllowedReduction -> AllowedReduction -> [AllowedReduction]
    enumFromThen :: AllowedReduction -> AllowedReduction -> [AllowedReduction]
    $cenumFromThen :: AllowedReduction -> AllowedReduction -> [AllowedReduction]
    enumFrom :: AllowedReduction -> [AllowedReduction]
    $cenumFrom :: AllowedReduction -> [AllowedReduction]
    fromEnum :: AllowedReduction -> Int
    $cfromEnum :: AllowedReduction -> Int
    toEnum :: Int -> AllowedReduction
    $ctoEnum :: Int -> AllowedReduction
    pred :: AllowedReduction -> AllowedReduction
    $cpred :: AllowedReduction -> AllowedReduction
    succ :: AllowedReduction -> AllowedReduction
    $csucc :: AllowedReduction -> AllowedReduction
    Enum, AllowedReduction
    AllowedReduction -> AllowedReduction -> Bounded AllowedReduction
    forall a. a -> a -> Bounded a
    maxBound :: AllowedReduction
    $cmaxBound :: AllowedReduction
    minBound :: AllowedReduction
    $cminBound :: AllowedReduction
    Bounded, Ord AllowedReduction
    Ord AllowedReduction
    -> ((AllowedReduction, AllowedReduction) -> [AllowedReduction])
    -> ((AllowedReduction, AllowedReduction)
        -> AllowedReduction -> Int)
    -> ((AllowedReduction, AllowedReduction)
        -> AllowedReduction -> Int)
    -> ((AllowedReduction, AllowedReduction)
        -> AllowedReduction -> Bool)
    -> ((AllowedReduction, AllowedReduction) -> Int)
    -> ((AllowedReduction, AllowedReduction) -> Int)
    -> Ix AllowedReduction
    (AllowedReduction, AllowedReduction) -> Int
    (AllowedReduction, AllowedReduction) -> [AllowedReduction]
    (AllowedReduction, AllowedReduction) -> AllowedReduction -> Bool
    (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int
    forall a.
    Ord a
    -> ((a, a) -> [a])
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Bool)
    -> ((a, a) -> Int)
    -> ((a, a) -> Int)
    -> Ix a
    unsafeRangeSize :: (AllowedReduction, AllowedReduction) -> Int
    $cunsafeRangeSize :: (AllowedReduction, AllowedReduction) -> Int
    rangeSize :: (AllowedReduction, AllowedReduction) -> Int
    $crangeSize :: (AllowedReduction, AllowedReduction) -> Int
    inRange :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Bool
    $cinRange :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Bool
    unsafeIndex :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int
    $cunsafeIndex :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int
    index :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int
    $cindex :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int
    range :: (AllowedReduction, AllowedReduction) -> [AllowedReduction]
    $crange :: (AllowedReduction, AllowedReduction) -> [AllowedReduction]
    Ix, Typeable AllowedReduction
    Typeable AllowedReduction
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> AllowedReduction -> c AllowedReduction)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AllowedReduction)
    -> (AllowedReduction -> Constr)
    -> (AllowedReduction -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AllowedReduction))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AllowedReduction))
    -> ((forall b. Data b => b -> b)
        -> AllowedReduction -> AllowedReduction)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> AllowedReduction -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AllowedReduction -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> AllowedReduction -> m AllowedReduction)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AllowedReduction -> m AllowedReduction)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AllowedReduction -> m AllowedReduction)
    -> Data AllowedReduction
    AllowedReduction -> DataType
    AllowedReduction -> Constr
    (forall b. Data b => b -> b)
    -> AllowedReduction -> AllowedReduction
    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) -> AllowedReduction -> u
    forall u. (forall d. Data d => d -> u) -> AllowedReduction -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AllowedReduction -> m AllowedReduction
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AllowedReduction -> m AllowedReduction
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AllowedReduction
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AllowedReduction -> c AllowedReduction
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AllowedReduction)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AllowedReduction)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AllowedReduction -> m AllowedReduction
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AllowedReduction -> m AllowedReduction
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AllowedReduction -> m AllowedReduction
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AllowedReduction -> m AllowedReduction
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AllowedReduction -> m AllowedReduction
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AllowedReduction -> m AllowedReduction
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AllowedReduction -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AllowedReduction -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AllowedReduction -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AllowedReduction -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r
    gmapT :: (forall b. Data b => b -> b)
    -> AllowedReduction -> AllowedReduction
    $cgmapT :: (forall b. Data b => b -> b)
    -> AllowedReduction -> AllowedReduction
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AllowedReduction)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AllowedReduction)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AllowedReduction)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AllowedReduction)
    dataTypeOf :: AllowedReduction -> DataType
    $cdataTypeOf :: AllowedReduction -> DataType
    toConstr :: AllowedReduction -> Constr
    $ctoConstr :: AllowedReduction -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AllowedReduction
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AllowedReduction
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AllowedReduction -> c AllowedReduction
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AllowedReduction -> c AllowedReduction
    Data, (forall x. AllowedReduction -> Rep AllowedReduction x)
    -> (forall x. Rep AllowedReduction x -> AllowedReduction)
    -> Generic AllowedReduction
    forall x. Rep AllowedReduction x -> AllowedReduction
    forall x. AllowedReduction -> Rep AllowedReduction x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AllowedReduction x -> AllowedReduction
    $cfrom :: forall x. AllowedReduction -> Rep AllowedReduction x
    Generic)

    type AllowedReductions = SmallSet AllowedReduction

    -- | Not quite all reductions (skip non-terminating reductions)
    allReductions :: AllowedReductions
    allReductions :: AllowedReductions
    allReductions = AllowedReduction -> AllowedReductions -> AllowedReductions
    forall a. SmallSetElement a => a -> SmallSet a -> SmallSet a
    SmallSet.delete AllowedReduction
    NonTerminatingReductions AllowedReductions
    reallyAllReductions

    reallyAllReductions :: AllowedReductions
    reallyAllReductions :: AllowedReductions
    reallyAllReductions = AllowedReductions
    forall a. SmallSetElement a => SmallSet a
    SmallSet.total

    data ReduceDefs
      = OnlyReduceDefs (Set QName)
      | DontReduceDefs (Set QName)
      deriving (Typeable ReduceDefs
    Typeable ReduceDefs
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ReduceDefs -> c ReduceDefs)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ReduceDefs)
    -> (ReduceDefs -> Constr)
    -> (ReduceDefs -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ReduceDefs))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ReduceDefs))
    -> ((forall b. Data b => b -> b) -> ReduceDefs -> ReduceDefs)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ReduceDefs -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ReduceDefs -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs)
    -> Data ReduceDefs
    ReduceDefs -> DataType
    ReduceDefs -> Constr
    (forall b. Data b => b -> b) -> ReduceDefs -> ReduceDefs
    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) -> ReduceDefs -> u
    forall u. (forall d. Data d => d -> u) -> ReduceDefs -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ReduceDefs
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ReduceDefs -> c ReduceDefs
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ReduceDefs)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ReduceDefs)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ReduceDefs -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ReduceDefs -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ReduceDefs -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ReduceDefs -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r
    gmapT :: (forall b. Data b => b -> b) -> ReduceDefs -> ReduceDefs
    $cgmapT :: (forall b. Data b => b -> b) -> ReduceDefs -> ReduceDefs
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ReduceDefs)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ReduceDefs)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ReduceDefs)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ReduceDefs)
    dataTypeOf :: ReduceDefs -> DataType
    $cdataTypeOf :: ReduceDefs -> DataType
    toConstr :: ReduceDefs -> Constr
    $ctoConstr :: ReduceDefs -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ReduceDefs
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ReduceDefs
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ReduceDefs -> c ReduceDefs
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ReduceDefs -> c ReduceDefs
    Data, (forall x. ReduceDefs -> Rep ReduceDefs x)
    -> (forall x. Rep ReduceDefs x -> ReduceDefs) -> Generic ReduceDefs
    forall x. Rep ReduceDefs x -> ReduceDefs
    forall x. ReduceDefs -> Rep ReduceDefs x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ReduceDefs x -> ReduceDefs
    $cfrom :: forall x. ReduceDefs -> Rep ReduceDefs x
    Generic)

    reduceAllDefs :: ReduceDefs
    reduceAllDefs :: ReduceDefs
    reduceAllDefs = Set QName -> ReduceDefs
    DontReduceDefs Set QName
    forall a. Null a => a
    empty

    locallyReduceDefs :: MonadTCEnv m => ReduceDefs -> m a -> m a
    locallyReduceDefs :: forall (m :: * -> *) a. MonadTCEnv m => ReduceDefs -> m a -> m a
    locallyReduceDefs = Lens' ReduceDefs TCEnv -> (ReduceDefs -> ReduceDefs) -> m a -> m a
    forall (m :: * -> *) a b.
    MonadTCEnv m =>
    Lens' a TCEnv -> (a -> a) -> m b -> m b
    locallyTC Lens' ReduceDefs TCEnv
    eReduceDefs ((ReduceDefs -> ReduceDefs) -> m a -> m a)
    -> (ReduceDefs -> ReduceDefs -> ReduceDefs)
    -> ReduceDefs
    -> m a
    -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReduceDefs -> ReduceDefs -> ReduceDefs
    forall a b. a -> b -> a
    const

    locallyReduceAllDefs :: MonadTCEnv m => m a -> m a
    locallyReduceAllDefs :: forall (m :: * -> *) a. MonadTCEnv m => m a -> m a
    locallyReduceAllDefs = ReduceDefs -> m a -> m a
    forall (m :: * -> *) a. MonadTCEnv m => ReduceDefs -> m a -> m a
    locallyReduceDefs ReduceDefs
    reduceAllDefs

    shouldReduceDef :: (MonadTCEnv m) => QName -> m Bool
    shouldReduceDef :: forall (m :: * -> *). MonadTCEnv m => QName -> m Bool
    shouldReduceDef QName
    f = (TCEnv -> ReduceDefs) -> m ReduceDefs
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> ReduceDefs
    envReduceDefs m ReduceDefs -> (ReduceDefs -> Bool) -> m Bool
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \case
      OnlyReduceDefs Set QName
    defs -> QName
    f QName -> Set QName -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` Set QName
    defs
      DontReduceDefs Set QName
    defs -> Bool -> Bool
    not (Bool -> Bool) -> Bool -> Bool
    forall a b. (a -> b) -> a -> b
    $ QName
    f QName -> Set QName -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` Set QName
    defs

    instance Semigroup ReduceDefs where
      OnlyReduceDefs Set QName
    qs1 <> :: ReduceDefs -> ReduceDefs -> ReduceDefs
    <> OnlyReduceDefs Set QName
    qs2 = Set QName -> ReduceDefs
    OnlyReduceDefs (Set QName -> ReduceDefs) -> Set QName -> ReduceDefs
    forall a b. (a -> b) -> a -> b
    $ Set QName -> Set QName -> Set QName
    forall a. Ord a => Set a -> Set a -> Set a
    Set.intersection Set QName
    qs1 Set QName
    qs2
      OnlyReduceDefs Set QName
    qs1 <> DontReduceDefs Set QName
    qs2 = Set QName -> ReduceDefs
    OnlyReduceDefs (Set QName -> ReduceDefs) -> Set QName -> ReduceDefs
    forall a b. (a -> b) -> a -> b
    $ Set QName -> Set QName -> Set QName
    forall a. Ord a => Set a -> Set a -> Set a
    Set.difference   Set QName
    qs1 Set QName
    qs2
      DontReduceDefs Set QName
    qs1 <> OnlyReduceDefs Set QName
    qs2 = Set QName -> ReduceDefs
    OnlyReduceDefs (Set QName -> ReduceDefs) -> Set QName -> ReduceDefs
    forall a b. (a -> b) -> a -> b
    $ Set QName -> Set QName -> Set QName
    forall a. Ord a => Set a -> Set a -> Set a
    Set.difference   Set QName
    qs2 Set QName
    qs1
      DontReduceDefs Set QName
    qs1 <> DontReduceDefs Set QName
    qs2 = Set QName -> ReduceDefs
    DontReduceDefs (Set QName -> ReduceDefs) -> Set QName -> ReduceDefs
    forall a b. (a -> b) -> a -> b
    $ Set QName -> Set QName -> Set QName
    forall a. Ord a => Set a -> Set a -> Set a
    Set.union        Set QName
    qs1 Set QName
    qs2

    instance Monoid ReduceDefs where
      mempty :: ReduceDefs
    mempty  = ReduceDefs
    reduceAllDefs
      mappend :: ReduceDefs -> ReduceDefs -> ReduceDefs
    mappend = ReduceDefs -> ReduceDefs -> ReduceDefs
    forall a. Semigroup a => a -> a -> a
    (<>)

    locallyReconstructed :: MonadTCEnv m => m a -> m a
    locallyReconstructed :: forall (m :: * -> *) a. MonadTCEnv m => m a -> m a
    locallyReconstructed = Lens' Bool TCEnv -> (Bool -> Bool) -> m a -> m a
    forall (m :: * -> *) a b.
    MonadTCEnv m =>
    Lens' a TCEnv -> (a -> a) -> m b -> m b
    locallyTC Lens' Bool TCEnv
    eReconstructed ((Bool -> Bool) -> m a -> m a)
    -> (Bool -> Bool -> Bool) -> Bool -> m a -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Bool -> Bool
    forall a b. a -> b -> a
    const (Bool -> m a -> m a) -> Bool -> m a -> m a
    forall a b. (a -> b) -> a -> b
    $ Bool
    True

    isReconstructed :: (MonadTCEnv m) => m Bool
    isReconstructed :: forall (m :: * -> *). MonadTCEnv m => m Bool
    isReconstructed = (TCEnv -> Bool) -> m Bool
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> Bool
    envReconstructed

    -- | Primitives

    data PrimitiveImpl = PrimImpl Type PrimFun

    data PrimFun = PrimFun
      { PrimFun -> QName
    primFunName           :: QName
      , PrimFun -> Int
    primFunArity          :: Arity
      , PrimFun
    -> [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term)
    primFunImplementation :: [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term)
      }
      deriving (forall x. PrimFun -> Rep PrimFun x)
    -> (forall x. Rep PrimFun x -> PrimFun) -> Generic PrimFun
    forall x. Rep PrimFun x -> PrimFun
    forall x. PrimFun -> Rep PrimFun x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PrimFun x -> PrimFun
    $cfrom :: forall x. PrimFun -> Rep PrimFun x
    Generic

    primFun :: QName -> Arity -> ([Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun
    primFun :: QName
    -> Int
    -> ([Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term))
    -> PrimFun
    primFun QName
    q Int
    ar [Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)
    imp = QName
    -> Int
    -> ([Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term))
    -> PrimFun
    PrimFun QName
    q Int
    ar (\ [Arg Term]
    args Int
    _ -> [Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)
    imp [Arg Term]
    args)

    defClauses :: Definition -> [Clause]
    defClauses :: Definition -> [Clause]
    defClauses Defn{theDef :: Definition -> Defn
    theDef = Function{funClauses :: Defn -> [Clause]
    funClauses = [Clause]
    cs}}        = [Clause]
    cs
    defClauses Defn{theDef :: Definition -> Defn
    theDef = Primitive{primClauses :: Defn -> [Clause]
    primClauses = [Clause]
    cs}}      = [Clause]
    cs
    defClauses Defn{theDef :: Definition -> Defn
    theDef = Datatype{dataClause :: Defn -> Maybe Clause
    dataClause = Just Clause
    c}}    = [Clause
    c]
    defClauses Defn{theDef :: Definition -> Defn
    theDef = Record{recClause :: Defn -> Maybe Clause
    recClause = Just Clause
    c}}       = [Clause
    c]
    defClauses Definition
    _                                               = []

    defCompiled :: Definition -> Maybe CompiledClauses
    defCompiled :: Definition -> Maybe CompiledClauses
    defCompiled Defn{theDef :: Definition -> Defn
    theDef = Function {funCompiled :: Defn -> Maybe CompiledClauses
    funCompiled  = Maybe CompiledClauses
    mcc}} = Maybe CompiledClauses
    mcc
    defCompiled Defn{theDef :: Definition -> Defn
    theDef = Primitive{primCompiled :: Defn -> Maybe CompiledClauses
    primCompiled = Maybe CompiledClauses
    mcc}} = Maybe CompiledClauses
    mcc
    defCompiled Definition
    _ = Maybe CompiledClauses
    forall a. Maybe a
    Nothing

    defParameters :: Definition -> Maybe Nat
    defParameters :: Definition -> Maybe Int
    defParameters Defn{theDef :: Definition -> Defn
    theDef = Datatype{dataPars :: Defn -> Int
    dataPars = Int
    n}} = Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    n
    defParameters Defn{theDef :: Definition -> Defn
    theDef = Record  {recPars :: Defn -> Int
    recPars  = Int
    n}} = Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    n
    defParameters Definition
    _                                     = Maybe Int
    forall a. Maybe a
    Nothing

    defInverse :: Definition -> FunctionInverse
    defInverse :: Definition -> FunctionInverse
    defInverse Defn{theDef :: Definition -> Defn
    theDef = Function { funInv :: Defn -> FunctionInverse
    funInv  = FunctionInverse
    inv }} = FunctionInverse
    inv
    defInverse Defn{theDef :: Definition -> Defn
    theDef = Primitive{ primInv :: Defn -> FunctionInverse
    primInv = FunctionInverse
    inv }} = FunctionInverse
    inv
    defInverse Definition
    _                                         = FunctionInverse
    forall c. FunctionInverse' c
    NotInjective

    defCompilerPragmas :: BackendName -> Definition -> [CompilerPragma]
    defCompilerPragmas :: String -> Definition -> [CompilerPragma]
    defCompilerPragmas String
    b = [CompilerPragma] -> [CompilerPragma]
    forall a. [a] -> [a]
    reverse ([CompilerPragma] -> [CompilerPragma])
    -> (Definition -> [CompilerPragma])
    -> Definition
    -> [CompilerPragma]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [CompilerPragma] -> Maybe [CompilerPragma] -> [CompilerPragma]
    forall a. a -> Maybe a -> a
    fromMaybe [] (Maybe [CompilerPragma] -> [CompilerPragma])
    -> (Definition -> Maybe [CompilerPragma])
    -> Definition
    -> [CompilerPragma]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> CompiledRepresentation -> Maybe [CompilerPragma]
    forall k a. Ord k => k -> Map k a -> Maybe a
    Map.lookup String
    b (CompiledRepresentation -> Maybe [CompilerPragma])
    -> (Definition -> CompiledRepresentation)
    -> Definition
    -> Maybe [CompilerPragma]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Definition -> CompiledRepresentation
    defCompiledRep
      -- reversed because we add new pragmas to the front of the list

    -- | Are the clauses of this definition delayed?
    defDelayed :: Definition -> Delayed
    defDelayed :: Definition -> Delayed
    defDelayed Defn{theDef :: Definition -> Defn
    theDef = Function{funDelayed :: Defn -> Delayed
    funDelayed = Delayed
    d}} = Delayed
    d
    defDelayed Definition
    _                                       = Delayed
    NotDelayed

    -- | Has the definition failed the termination checker?
    defNonterminating :: Definition -> Bool
    defNonterminating :: Definition -> Bool
    defNonterminating Defn{theDef :: Definition -> Defn
    theDef = Function{funTerminates :: Defn -> Maybe Bool
    funTerminates = Just Bool
    False}} = Bool
    True
    defNonterminating Definition
    _                                                   = Bool
    False

    -- | Has the definition not termination checked or did the check fail?
    defTerminationUnconfirmed :: Definition -> Bool
    defTerminationUnconfirmed :: Definition -> Bool
    defTerminationUnconfirmed Defn{theDef :: Definition -> Defn
    theDef = Function{funTerminates :: Defn -> Maybe Bool
    funTerminates = Just Bool
    True}} = Bool
    False
    defTerminationUnconfirmed Defn{theDef :: Definition -> Defn
    theDef = Function{funTerminates :: Defn -> Maybe Bool
    funTerminates = Maybe Bool
    _        }} = Bool
    True
    defTerminationUnconfirmed Definition
    _ = Bool
    False

    defAbstract :: Definition -> IsAbstract
    defAbstract :: Definition -> IsAbstract
    defAbstract Definition
    d = case Definition -> Defn
    theDef Definition
    d of
        Axiom{}                   -> IsAbstract
    ConcreteDef
        DataOrRecSig{}            -> IsAbstract
    ConcreteDef
        GeneralizableVar{}        -> IsAbstract
    ConcreteDef
        AbstractDefn{}            -> IsAbstract
    AbstractDef
        Function{funAbstr :: Defn -> IsAbstract
    funAbstr = IsAbstract
    a}    -> IsAbstract
    a
        Datatype{dataAbstr :: Defn -> IsAbstract
    dataAbstr = IsAbstract
    a}   -> IsAbstract
    a
        Record{recAbstr :: Defn -> IsAbstract
    recAbstr = IsAbstract
    a}      -> IsAbstract
    a
        Constructor{conAbstr :: Defn -> IsAbstract
    conAbstr = IsAbstract
    a} -> IsAbstract
    a
        Primitive{primAbstr :: Defn -> IsAbstract
    primAbstr = IsAbstract
    a}  -> IsAbstract
    a
        PrimitiveSort{}           -> IsAbstract
    ConcreteDef

    defForced :: Definition -> [IsForced]
    defForced :: Definition -> [IsForced]
    defForced Definition
    d = case Definition -> Defn
    theDef Definition
    d of
        Constructor{conForced :: Defn -> [IsForced]
    conForced = [IsForced]
    fs} -> [IsForced]
    fs
        Axiom{}                     -> []
        DataOrRecSig{}              -> []
        GeneralizableVar{}          -> []
        AbstractDefn{}              -> []
        Function{}                  -> []
        Datatype{}                  -> []
        Record{}                    -> []
        Primitive{}                 -> []
        PrimitiveSort{}             -> []

    ---------------------------------------------------------------------------
    -- ** Injectivity
    ---------------------------------------------------------------------------

    type FunctionInverse = FunctionInverse' Clause
    type InversionMap c = Map TermHead [c]

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

    data TermHead = SortHead
                  | PiHead
                  | ConsHead QName
                  | VarHead Nat
                  | UnknownHead
      deriving (Typeable TermHead
    Typeable TermHead
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> TermHead -> c TermHead)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TermHead)
    -> (TermHead -> Constr)
    -> (TermHead -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TermHead))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TermHead))
    -> ((forall b. Data b => b -> b) -> TermHead -> TermHead)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TermHead -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TermHead -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TermHead -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> TermHead -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TermHead -> m TermHead)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TermHead -> m TermHead)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TermHead -> m TermHead)
    -> Data TermHead
    TermHead -> DataType
    TermHead -> Constr
    (forall b. Data b => b -> b) -> TermHead -> TermHead
    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) -> TermHead -> u
    forall u. (forall d. Data d => d -> u) -> TermHead -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TermHead -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TermHead -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TermHead -> m TermHead
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TermHead -> m TermHead
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TermHead
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TermHead -> c TermHead
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TermHead)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TermHead)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TermHead -> m TermHead
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TermHead -> m TermHead
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TermHead -> m TermHead
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TermHead -> m TermHead
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TermHead -> m TermHead
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TermHead -> m TermHead
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TermHead -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TermHead -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TermHead -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TermHead -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TermHead -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TermHead -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TermHead -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TermHead -> r
    gmapT :: (forall b. Data b => b -> b) -> TermHead -> TermHead
    $cgmapT :: (forall b. Data b => b -> b) -> TermHead -> TermHead
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TermHead)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TermHead)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TermHead)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TermHead)
    dataTypeOf :: TermHead -> DataType
    $cdataTypeOf :: TermHead -> DataType
    toConstr :: TermHead -> Constr
    $ctoConstr :: TermHead -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TermHead
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TermHead
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TermHead -> c TermHead
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TermHead -> c TermHead
    Data, TermHead -> TermHead -> Bool
    (TermHead -> TermHead -> Bool)
    -> (TermHead -> TermHead -> Bool) -> Eq TermHead
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TermHead -> TermHead -> Bool
    $c/= :: TermHead -> TermHead -> Bool
    == :: TermHead -> TermHead -> Bool
    $c== :: TermHead -> TermHead -> Bool
    Eq, Eq TermHead
    Eq TermHead
    -> (TermHead -> TermHead -> Ordering)
    -> (TermHead -> TermHead -> Bool)
    -> (TermHead -> TermHead -> Bool)
    -> (TermHead -> TermHead -> Bool)
    -> (TermHead -> TermHead -> Bool)
    -> (TermHead -> TermHead -> TermHead)
    -> (TermHead -> TermHead -> TermHead)
    -> Ord TermHead
    TermHead -> TermHead -> Bool
    TermHead -> TermHead -> Ordering
    TermHead -> TermHead -> TermHead
    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 :: TermHead -> TermHead -> TermHead
    $cmin :: TermHead -> TermHead -> TermHead
    max :: TermHead -> TermHead -> TermHead
    $cmax :: TermHead -> TermHead -> TermHead
    >= :: TermHead -> TermHead -> Bool
    $c>= :: TermHead -> TermHead -> Bool
    > :: TermHead -> TermHead -> Bool
    $c> :: TermHead -> TermHead -> Bool
    <= :: TermHead -> TermHead -> Bool
    $c<= :: TermHead -> TermHead -> Bool
    < :: TermHead -> TermHead -> Bool
    $c< :: TermHead -> TermHead -> Bool
    compare :: TermHead -> TermHead -> Ordering
    $ccompare :: TermHead -> TermHead -> Ordering
    Ord, Int -> TermHead -> ShowS
    [TermHead] -> ShowS
    TermHead -> String
    (Int -> TermHead -> ShowS)
    -> (TermHead -> String) -> ([TermHead] -> ShowS) -> Show TermHead
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [TermHead] -> ShowS
    $cshowList :: [TermHead] -> ShowS
    show :: TermHead -> String
    $cshow :: TermHead -> String
    showsPrec :: Int -> TermHead -> ShowS
    $cshowsPrec :: Int -> TermHead -> ShowS
    Show, (forall x. TermHead -> Rep TermHead x)
    -> (forall x. Rep TermHead x -> TermHead) -> Generic TermHead
    forall x. Rep TermHead x -> TermHead
    forall x. TermHead -> Rep TermHead x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TermHead x -> TermHead
    $cfrom :: forall x. TermHead -> Rep TermHead x
    Generic)

    instance Pretty TermHead where
      pretty :: TermHead -> Doc
    pretty = \ case
        TermHead
    SortHead    -> Doc
    "SortHead"
        TermHead
    PiHead      -> Doc
    "PiHead"
        ConsHead QName
    q  -> Doc
    "ConsHead" Doc -> Doc -> Doc
    <+> QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty QName
    q
        VarHead Int
    i   -> String -> Doc
    text (String
    "VarHead " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    i)
        TermHead
    UnknownHead -> Doc
    "UnknownHead"

    ---------------------------------------------------------------------------
    -- ** Mutual blocks
    ---------------------------------------------------------------------------

    newtype MutualId = MutId Int32
      deriving (Typeable MutualId
    Typeable MutualId
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> MutualId -> c MutualId)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c MutualId)
    -> (MutualId -> Constr)
    -> (MutualId -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c MutualId))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualId))
    -> ((forall b. Data b => b -> b) -> MutualId -> MutualId)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> MutualId -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> MutualId -> r)
    -> (forall u. (forall d. Data d => d -> u) -> MutualId -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> MutualId -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> MutualId -> m MutualId)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MutualId -> m MutualId)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MutualId -> m MutualId)
    -> Data MutualId
    MutualId -> DataType
    MutualId -> Constr
    (forall b. Data b => b -> b) -> MutualId -> MutualId
    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) -> MutualId -> u
    forall u. (forall d. Data d => d -> u) -> MutualId -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualId -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualId -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MutualId -> m MutualId
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualId -> m MutualId
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MutualId
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MutualId -> c MutualId
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MutualId)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualId)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualId -> m MutualId
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualId -> m MutualId
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualId -> m MutualId
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MutualId -> m MutualId
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MutualId -> m MutualId
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MutualId -> m MutualId
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MutualId -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MutualId -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> MutualId -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> MutualId -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualId -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualId -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualId -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MutualId -> r
    gmapT :: (forall b. Data b => b -> b) -> MutualId -> MutualId
    $cgmapT :: (forall b. Data b => b -> b) -> MutualId -> MutualId
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualId)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualId)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MutualId)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MutualId)
    dataTypeOf :: MutualId -> DataType
    $cdataTypeOf :: MutualId -> DataType
    toConstr :: MutualId -> Constr
    $ctoConstr :: MutualId -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MutualId
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MutualId
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MutualId -> c MutualId
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MutualId -> c MutualId
    Data, MutualId -> MutualId -> Bool
    (MutualId -> MutualId -> Bool)
    -> (MutualId -> MutualId -> Bool) -> Eq MutualId
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: MutualId -> MutualId -> Bool
    $c/= :: MutualId -> MutualId -> Bool
    == :: MutualId -> MutualId -> Bool
    $c== :: MutualId -> MutualId -> Bool
    Eq, Eq MutualId
    Eq MutualId
    -> (MutualId -> MutualId -> Ordering)
    -> (MutualId -> MutualId -> Bool)
    -> (MutualId -> MutualId -> Bool)
    -> (MutualId -> MutualId -> Bool)
    -> (MutualId -> MutualId -> Bool)
    -> (MutualId -> MutualId -> MutualId)
    -> (MutualId -> MutualId -> MutualId)
    -> Ord MutualId
    MutualId -> MutualId -> Bool
    MutualId -> MutualId -> Ordering
    MutualId -> MutualId -> MutualId
    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 :: MutualId -> MutualId -> MutualId
    $cmin :: MutualId -> MutualId -> MutualId
    max :: MutualId -> MutualId -> MutualId
    $cmax :: MutualId -> MutualId -> MutualId
    >= :: MutualId -> MutualId -> Bool
    $c>= :: MutualId -> MutualId -> Bool
    > :: MutualId -> MutualId -> Bool
    $c> :: MutualId -> MutualId -> Bool
    <= :: MutualId -> MutualId -> Bool
    $c<= :: MutualId -> MutualId -> Bool
    < :: MutualId -> MutualId -> Bool
    $c< :: MutualId -> MutualId -> Bool
    compare :: MutualId -> MutualId -> Ordering
    $ccompare :: MutualId -> MutualId -> Ordering
    Ord, Int -> MutualId -> ShowS
    [MutualId] -> ShowS
    MutualId -> String
    (Int -> MutualId -> ShowS)
    -> (MutualId -> String) -> ([MutualId] -> ShowS) -> Show MutualId
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [MutualId] -> ShowS
    $cshowList :: [MutualId] -> ShowS
    show :: MutualId -> String
    $cshow :: MutualId -> String
    showsPrec :: Int -> MutualId -> ShowS
    $cshowsPrec :: Int -> MutualId -> ShowS
    Show, Integer -> MutualId
    MutualId -> MutualId
    MutualId -> MutualId -> MutualId
    (MutualId -> MutualId -> MutualId)
    -> (MutualId -> MutualId -> MutualId)
    -> (MutualId -> MutualId -> MutualId)
    -> (MutualId -> MutualId)
    -> (MutualId -> MutualId)
    -> (MutualId -> MutualId)
    -> (Integer -> MutualId)
    -> Num MutualId
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    fromInteger :: Integer -> MutualId
    $cfromInteger :: Integer -> MutualId
    signum :: MutualId -> MutualId
    $csignum :: MutualId -> MutualId
    abs :: MutualId -> MutualId
    $cabs :: MutualId -> MutualId
    negate :: MutualId -> MutualId
    $cnegate :: MutualId -> MutualId
    * :: MutualId -> MutualId -> MutualId
    $c* :: MutualId -> MutualId -> MutualId
    - :: MutualId -> MutualId -> MutualId
    $c- :: MutualId -> MutualId -> MutualId
    + :: MutualId -> MutualId -> MutualId
    $c+ :: MutualId -> MutualId -> MutualId
    Num, Int -> MutualId
    MutualId -> Int
    MutualId -> [MutualId]
    MutualId -> MutualId
    MutualId -> MutualId -> [MutualId]
    MutualId -> MutualId -> MutualId -> [MutualId]
    (MutualId -> MutualId)
    -> (MutualId -> MutualId)
    -> (Int -> MutualId)
    -> (MutualId -> Int)
    -> (MutualId -> [MutualId])
    -> (MutualId -> MutualId -> [MutualId])
    -> (MutualId -> MutualId -> [MutualId])
    -> (MutualId -> MutualId -> MutualId -> [MutualId])
    -> Enum MutualId
    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 :: MutualId -> MutualId -> MutualId -> [MutualId]
    $cenumFromThenTo :: MutualId -> MutualId -> MutualId -> [MutualId]
    enumFromTo :: MutualId -> MutualId -> [MutualId]
    $cenumFromTo :: MutualId -> MutualId -> [MutualId]
    enumFromThen :: MutualId -> MutualId -> [MutualId]
    $cenumFromThen :: MutualId -> MutualId -> [MutualId]
    enumFrom :: MutualId -> [MutualId]
    $cenumFrom :: MutualId -> [MutualId]
    fromEnum :: MutualId -> Int
    $cfromEnum :: MutualId -> Int
    toEnum :: Int -> MutualId
    $ctoEnum :: Int -> MutualId
    pred :: MutualId -> MutualId
    $cpred :: MutualId -> MutualId
    succ :: MutualId -> MutualId
    $csucc :: MutualId -> MutualId
    Enum, MutualId -> ()
    (MutualId -> ()) -> NFData MutualId
    forall a. (a -> ()) -> NFData a
    rnf :: MutualId -> ()
    $crnf :: MutualId -> ()
    NFData)

    ---------------------------------------------------------------------------
    -- ** Statistics
    ---------------------------------------------------------------------------

    type Statistics = Map String Integer

    ---------------------------------------------------------------------------
    -- ** Trace
    ---------------------------------------------------------------------------

    data Call
      = CheckClause Type A.SpineClause
      | CheckLHS A.SpineLHS
      | CheckPattern A.Pattern Telescope Type
      | CheckPatternLinearityType C.Name
      | CheckPatternLinearityValue C.Name
      | CheckLetBinding A.LetBinding
      | InferExpr A.Expr
      | CheckExprCall Comparison A.Expr Type
      | CheckDotPattern A.Expr Term
      | CheckProjection Range QName Type
      | IsTypeCall Comparison A.Expr Sort
      | IsType_ A.Expr
      | InferVar Name
      | InferDef QName
      | CheckArguments Range [NamedArg A.Expr] Type (Maybe Type)
      | CheckMetaSolution Range MetaId Type Term
      | CheckTargetType Range Type Type
      | CheckDataDef Range QName [A.LamBinding] [A.Constructor]
      | CheckRecDef Range QName [A.LamBinding] [A.Constructor]
      | CheckConstructor QName Telescope Sort A.Constructor
      | CheckConstructorFitsIn QName Type Sort
      | CheckFunDefCall Range QName [A.Clause] Bool
        -- ^ Highlight (interactively) if and only if the boolean is 'True'.
      | CheckPragma Range A.Pragma
      | CheckPrimitive Range QName A.Expr
      | CheckIsEmpty Range Type
      | CheckConfluence QName QName
      | CheckWithFunctionType Type
      | CheckSectionApplication Range ModuleName A.ModuleApplication
      | CheckNamedWhere ModuleName
      | ScopeCheckExpr C.Expr
      | ScopeCheckDeclaration NiceDeclaration
      | ScopeCheckLHS C.QName C.Pattern
      | NoHighlighting
      | ModuleContents  -- ^ Interaction command: show module contents.
      | SetRange Range  -- ^ used by 'setCurrentRange'
      deriving (Typeable Call
    Typeable Call
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Call -> c Call)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Call)
    -> (Call -> Constr)
    -> (Call -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Call))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Call))
    -> ((forall b. Data b => b -> b) -> Call -> Call)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Call -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Call -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Call -> m Call)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Call -> m Call)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Call -> m Call)
    -> Data Call
    Call -> DataType
    Call -> Constr
    (forall b. Data b => b -> b) -> Call -> Call
    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) -> Call -> u
    forall u. (forall d. Data d => d -> u) -> Call -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Call -> m Call
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Call -> m Call
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Call
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Call -> c Call
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Call)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Call)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Call -> m Call
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Call -> m Call
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Call -> m Call
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Call -> m Call
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Call -> m Call
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Call -> m Call
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Call -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Call -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Call -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Call -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r
    gmapT :: (forall b. Data b => b -> b) -> Call -> Call
    $cgmapT :: (forall b. Data b => b -> b) -> Call -> Call
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Call)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Call)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Call)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Call)
    dataTypeOf :: Call -> DataType
    $cdataTypeOf :: Call -> DataType
    toConstr :: Call -> Constr
    $ctoConstr :: Call -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Call
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Call
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Call -> c Call
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Call -> c Call
    Data, (forall x. Call -> Rep Call x)
    -> (forall x. Rep Call x -> Call) -> Generic Call
    forall x. Rep Call x -> Call
    forall x. Call -> Rep Call x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Call x -> Call
    $cfrom :: forall x. Call -> Rep Call x
    Generic)

    instance Pretty Call where
        pretty :: Call -> Doc
    pretty CheckClause{}             = Doc
    "CheckClause"
        pretty CheckLHS{}                = Doc
    "CheckLHS"
        pretty CheckPattern{}            = Doc
    "CheckPattern"
        pretty CheckPatternLinearityType{}  = Doc
    "CheckPatternLinearityType"
        pretty CheckPatternLinearityValue{} = Doc
    "CheckPatternLinearityValue"
        pretty InferExpr{}               = Doc
    "InferExpr"
        pretty CheckExprCall{}           = Doc
    "CheckExprCall"
        pretty CheckLetBinding{}         = Doc
    "CheckLetBinding"
        pretty CheckProjection{}         = Doc
    "CheckProjection"
        pretty IsTypeCall{}              = Doc
    "IsTypeCall"
        pretty IsType_{}                 = Doc
    "IsType_"
        pretty InferVar{}                = Doc
    "InferVar"
        pretty InferDef{}                = Doc
    "InferDef"
        pretty CheckArguments{}          = Doc
    "CheckArguments"
        pretty CheckMetaSolution{}       = Doc
    "CheckMetaSolution"
        pretty CheckTargetType{}         = Doc
    "CheckTargetType"
        pretty CheckDataDef{}            = Doc
    "CheckDataDef"
        pretty CheckRecDef{}             = Doc
    "CheckRecDef"
        pretty CheckConstructor{}        = Doc
    "CheckConstructor"
        pretty CheckConstructorFitsIn{}  = Doc
    "CheckConstructorFitsIn"
        pretty CheckFunDefCall{}         = Doc
    "CheckFunDefCall"
        pretty CheckPragma{}             = Doc
    "CheckPragma"
        pretty CheckPrimitive{}          = Doc
    "CheckPrimitive"
        pretty CheckWithFunctionType{}   = Doc
    "CheckWithFunctionType"
        pretty CheckNamedWhere{}         = Doc
    "CheckNamedWhere"
        pretty ScopeCheckExpr{}          = Doc
    "ScopeCheckExpr"
        pretty ScopeCheckDeclaration{}   = Doc
    "ScopeCheckDeclaration"
        pretty ScopeCheckLHS{}           = Doc
    "ScopeCheckLHS"
        pretty CheckDotPattern{}         = Doc
    "CheckDotPattern"
        pretty SetRange{}                = Doc
    "SetRange"
        pretty CheckSectionApplication{} = Doc
    "CheckSectionApplication"
        pretty CheckIsEmpty{}            = Doc
    "CheckIsEmpty"
        pretty CheckConfluence{}         = Doc
    "CheckConfluence"
        pretty NoHighlighting{}          = Doc
    "NoHighlighting"
        pretty ModuleContents{}          = Doc
    "ModuleContents"

    instance HasRange Call where
        getRange :: Call -> Range
    getRange (CheckClause Type
    _ SpineClause
    c)               = SpineClause -> Range
    forall a. HasRange a => a -> Range
    getRange SpineClause
    c
        getRange (CheckLHS SpineLHS
    lhs)                  = SpineLHS -> Range
    forall a. HasRange a => a -> Range
    getRange SpineLHS
    lhs
        getRange (CheckPattern Pattern
    p Telescope
    _ Type
    _)            = Pattern -> Range
    forall a. HasRange a => a -> Range
    getRange Pattern
    p
        getRange (CheckPatternLinearityType Name
    x)   = Name -> Range
    forall a. HasRange a => a -> Range
    getRange Name
    x
        getRange (CheckPatternLinearityValue Name
    x)  = Name -> Range
    forall a. HasRange a => a -> Range
    getRange Name
    x
        getRange (InferExpr Expr
    e)                   = Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    e
        getRange (CheckExprCall Comparison
    _ Expr
    e Type
    _)           = Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    e
        getRange (CheckLetBinding LetBinding
    b)             = LetBinding -> Range
    forall a. HasRange a => a -> Range
    getRange LetBinding
    b
        getRange (CheckProjection Range
    r QName
    _ Type
    _)         = Range
    r
        getRange (IsTypeCall Comparison
    cmp Expr
    e Sort
    s)            = Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    e
        getRange (IsType_ Expr
    e)                     = Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    e
        getRange (InferVar Name
    x)                    = Name -> Range
    forall a. HasRange a => a -> Range
    getRange Name
    x
        getRange (InferDef QName
    f)                    = QName -> Range
    forall a. HasRange a => a -> Range
    getRange QName
    f
        getRange (CheckArguments Range
    r [NamedArg Expr]
    _ Type
    _ Maybe Type
    _)        = Range
    r
        getRange (CheckMetaSolution Range
    r MetaId
    _ Type
    _ Term
    _)     = Range
    r
        getRange (CheckTargetType Range
    r Type
    _ Type
    _)         = Range
    r
        getRange (CheckDataDef Range
    i QName
    _ [LamBinding]
    _ [Constructor]
    _)          = Range -> Range
    forall a. HasRange a => a -> Range
    getRange Range
    i
        getRange (CheckRecDef Range
    i QName
    _ [LamBinding]
    _ [Constructor]
    _)           = Range -> Range
    forall a. HasRange a => a -> Range
    getRange Range
    i
        getRange (CheckConstructor QName
    _ Telescope
    _ Sort
    _ Constructor
    c)      = Constructor -> Range
    forall a. HasRange a => a -> Range
    getRange Constructor
    c
        getRange (CheckConstructorFitsIn QName
    c Type
    _ Sort
    _)  = QName -> Range
    forall a. HasRange a => a -> Range
    getRange QName
    c
        getRange (CheckFunDefCall Range
    i QName
    _ [Clause]
    _ Bool
    _)       = Range -> Range
    forall a. HasRange a => a -> Range
    getRange Range
    i
        getRange (CheckPragma Range
    r Pragma
    _)               = Range
    r
        getRange (CheckPrimitive Range
    i QName
    _ Expr
    _)          = Range -> Range
    forall a. HasRange a => a -> Range
    getRange Range
    i
        getRange CheckWithFunctionType{}         = Range
    forall a. Range' a
    noRange
        getRange (CheckNamedWhere ModuleName
    m)             = ModuleName -> Range
    forall a. HasRange a => a -> Range
    getRange ModuleName
    m
        getRange (ScopeCheckExpr Expr
    e)              = Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    e
        getRange (ScopeCheckDeclaration NiceDeclaration
    d)       = NiceDeclaration -> Range
    forall a. HasRange a => a -> Range
    getRange NiceDeclaration
    d
        getRange (ScopeCheckLHS QName
    _ Pattern
    p)             = Pattern -> Range
    forall a. HasRange a => a -> Range
    getRange Pattern
    p
        getRange (CheckDotPattern Expr
    e Term
    _)           = Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    e
        getRange (SetRange Range
    r)                    = Range
    r
        getRange (CheckSectionApplication Range
    r ModuleName
    _ ModuleApplication
    _) = Range
    r
        getRange (CheckIsEmpty Range
    r Type
    _)              = Range
    r
        getRange (CheckConfluence QName
    rule1 QName
    rule2)   = Range -> Range -> Range
    forall a. Ord a => a -> a -> a
    max (QName -> Range
    forall a. HasRange a => a -> Range
    getRange QName
    rule1) (QName -> Range
    forall a. HasRange a => a -> Range
    getRange QName
    rule2)
        getRange Call
    NoHighlighting                  = Range
    forall a. Range' a
    noRange
        getRange Call
    ModuleContents                  = Range
    forall a. Range' a
    noRange

    ---------------------------------------------------------------------------
    -- ** Instance table
    ---------------------------------------------------------------------------

    -- | The instance table is a @Map@ associating to every name of
    --   record/data type/postulate its list of instances
    type InstanceTable = Map QName (Set QName)

    -- | When typechecking something of the following form:
    --
    --     instance
    --       x : _
    --       x = y
    --
    --   it's not yet known where to add @x@, so we add it to a list of
    --   unresolved instances and we'll deal with it later.
    type TempInstanceTable = (InstanceTable , Set QName)

    ---------------------------------------------------------------------------
    -- ** Builtin things
    ---------------------------------------------------------------------------

    data BuiltinDescriptor
      = BuiltinData (TCM Type) [String]
      | BuiltinDataCons (TCM Type)
      | BuiltinPrim String (Term -> TCM ())
      | BuiltinSort String
      | BuiltinPostulate Relevance (TCM Type)
      | BuiltinUnknown (Maybe (TCM Type)) (Term -> Type -> TCM ())
        -- ^ Builtin of any kind.
        --   Type can be checked (@Just t@) or inferred (@Nothing@).
        --   The second argument is the hook for the verification function.

    data BuiltinInfo =
       BuiltinInfo { BuiltinInfo -> String
    builtinName :: String
                   , BuiltinInfo -> BuiltinDescriptor
    builtinDesc :: BuiltinDescriptor }

    type BuiltinThings pf = Map String (Builtin pf)

    data Builtin pf
            = Builtin Term
            | Prim pf
        deriving (Int -> Builtin pf -> ShowS
    [Builtin pf] -> ShowS
    Builtin pf -> String
    (Int -> Builtin pf -> ShowS)
    -> (Builtin pf -> String)
    -> ([Builtin pf] -> ShowS)
    -> Show (Builtin pf)
    forall pf. Show pf => Int -> Builtin pf -> ShowS
    forall pf. Show pf => [Builtin pf] -> ShowS
    forall pf. Show pf => Builtin pf -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Builtin pf] -> ShowS
    $cshowList :: forall pf. Show pf => [Builtin pf] -> ShowS
    show :: Builtin pf -> String
    $cshow :: forall pf. Show pf => Builtin pf -> String
    showsPrec :: Int -> Builtin pf -> ShowS
    $cshowsPrec :: forall pf. Show pf => Int -> Builtin pf -> ShowS
    Show, (forall a b. (a -> b) -> Builtin a -> Builtin b)
    -> (forall a b. a -> Builtin b -> Builtin a) -> Functor Builtin
    forall a b. a -> Builtin b -> Builtin a
    forall a b. (a -> b) -> Builtin a -> Builtin b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> Builtin b -> Builtin a
    $c<$ :: forall a b. a -> Builtin b -> Builtin a
    fmap :: forall a b. (a -> b) -> Builtin a -> Builtin b
    $cfmap :: forall a b. (a -> b) -> Builtin a -> Builtin b
    Functor, (forall m. Monoid m => Builtin m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Builtin a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Builtin a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Builtin a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Builtin a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Builtin a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Builtin a -> b)
    -> (forall a. (a -> a -> a) -> Builtin a -> a)
    -> (forall a. (a -> a -> a) -> Builtin a -> a)
    -> (forall a. Builtin a -> [a])
    -> (forall a. Builtin a -> Bool)
    -> (forall a. Builtin a -> Int)
    -> (forall a. Eq a => a -> Builtin a -> Bool)
    -> (forall a. Ord a => Builtin a -> a)
    -> (forall a. Ord a => Builtin a -> a)
    -> (forall a. Num a => Builtin a -> a)
    -> (forall a. Num a => Builtin a -> a)
    -> Foldable Builtin
    forall a. Eq a => a -> Builtin a -> Bool
    forall a. Num a => Builtin a -> a
    forall a. Ord a => Builtin a -> a
    forall m. Monoid m => Builtin m -> m
    forall a. Builtin a -> Bool
    forall a. Builtin a -> Int
    forall a. Builtin a -> [a]
    forall a. (a -> a -> a) -> Builtin a -> a
    forall m a. Monoid m => (a -> m) -> Builtin a -> m
    forall b a. (b -> a -> b) -> b -> Builtin a -> b
    forall a b. (a -> b -> b) -> b -> Builtin a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: forall a. Num a => Builtin a -> a
    $cproduct :: forall a. Num a => Builtin a -> a
    sum :: forall a. Num a => Builtin a -> a
    $csum :: forall a. Num a => Builtin a -> a
    minimum :: forall a. Ord a => Builtin a -> a
    $cminimum :: forall a. Ord a => Builtin a -> a
    maximum :: forall a. Ord a => Builtin a -> a
    $cmaximum :: forall a. Ord a => Builtin a -> a
    elem :: forall a. Eq a => a -> Builtin a -> Bool
    $celem :: forall a. Eq a => a -> Builtin a -> Bool
    length :: forall a. Builtin a -> Int
    $clength :: forall a. Builtin a -> Int
    null :: forall a. Builtin a -> Bool
    $cnull :: forall a. Builtin a -> Bool
    toList :: forall a. Builtin a -> [a]
    $ctoList :: forall a. Builtin a -> [a]
    foldl1 :: forall a. (a -> a -> a) -> Builtin a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Builtin a -> a
    foldr1 :: forall a. (a -> a -> a) -> Builtin a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> Builtin a -> a
    foldl' :: forall b a. (b -> a -> b) -> b -> Builtin a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Builtin a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Builtin a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Builtin a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Builtin a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Builtin a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Builtin a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Builtin a -> b
    foldMap' :: forall m a. Monoid m => (a -> m) -> Builtin a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Builtin a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Builtin a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Builtin a -> m
    fold :: forall m. Monoid m => Builtin m -> m
    $cfold :: forall m. Monoid m => Builtin m -> m
    Foldable, Functor Builtin
    Foldable Builtin
    Functor Builtin
    -> Foldable Builtin
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> Builtin a -> f (Builtin b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Builtin (f a) -> f (Builtin a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Builtin a -> m (Builtin b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Builtin (m a) -> m (Builtin a))
    -> Traversable Builtin
    forall (t :: * -> *).
    Functor t
    -> Foldable t
    -> (forall (f :: * -> *) a b.
        Applicative f =>
        (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Builtin (m a) -> m (Builtin a)
    forall (f :: * -> *) a.
    Applicative f =>
    Builtin (f a) -> f (Builtin a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Builtin a -> m (Builtin b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Builtin a -> f (Builtin b)
    sequence :: forall (m :: * -> *) a. Monad m => Builtin (m a) -> m (Builtin a)
    $csequence :: forall (m :: * -> *) a. Monad m => Builtin (m a) -> m (Builtin a)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Builtin a -> m (Builtin b)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Builtin a -> m (Builtin b)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Builtin (f a) -> f (Builtin a)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Builtin (f a) -> f (Builtin a)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Builtin a -> f (Builtin b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Builtin a -> f (Builtin b)
    Traversable, (forall x. Builtin pf -> Rep (Builtin pf) x)
    -> (forall x. Rep (Builtin pf) x -> Builtin pf)
    -> Generic (Builtin pf)
    forall x. Rep (Builtin pf) x -> Builtin pf
    forall x. Builtin pf -> Rep (Builtin pf) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall pf x. Rep (Builtin pf) x -> Builtin pf
    forall pf x. Builtin pf -> Rep (Builtin pf) x
    $cto :: forall pf x. Rep (Builtin pf) x -> Builtin pf
    $cfrom :: forall pf x. Builtin pf -> Rep (Builtin pf) x
    Generic)

    ---------------------------------------------------------------------------
    -- * Highlighting levels
    ---------------------------------------------------------------------------

    -- | How much highlighting should be sent to the user interface?

    data HighlightingLevel
      = None
      | NonInteractive
      | Interactive
        -- ^ This includes both non-interactive highlighting and
        -- interactive highlighting of the expression that is currently
        -- being type-checked.
        deriving (HighlightingLevel -> HighlightingLevel -> Bool
    (HighlightingLevel -> HighlightingLevel -> Bool)
    -> (HighlightingLevel -> HighlightingLevel -> Bool)
    -> Eq HighlightingLevel
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: HighlightingLevel -> HighlightingLevel -> Bool
    $c/= :: HighlightingLevel -> HighlightingLevel -> Bool
    == :: HighlightingLevel -> HighlightingLevel -> Bool
    $c== :: HighlightingLevel -> HighlightingLevel -> Bool
    Eq, Eq HighlightingLevel
    Eq HighlightingLevel
    -> (HighlightingLevel -> HighlightingLevel -> Ordering)
    -> (HighlightingLevel -> HighlightingLevel -> Bool)
    -> (HighlightingLevel -> HighlightingLevel -> Bool)
    -> (HighlightingLevel -> HighlightingLevel -> Bool)
    -> (HighlightingLevel -> HighlightingLevel -> Bool)
    -> (HighlightingLevel -> HighlightingLevel -> HighlightingLevel)
    -> (HighlightingLevel -> HighlightingLevel -> HighlightingLevel)
    -> Ord HighlightingLevel
    HighlightingLevel -> HighlightingLevel -> Bool
    HighlightingLevel -> HighlightingLevel -> Ordering
    HighlightingLevel -> HighlightingLevel -> HighlightingLevel
    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 :: HighlightingLevel -> HighlightingLevel -> HighlightingLevel
    $cmin :: HighlightingLevel -> HighlightingLevel -> HighlightingLevel
    max :: HighlightingLevel -> HighlightingLevel -> HighlightingLevel
    $cmax :: HighlightingLevel -> HighlightingLevel -> HighlightingLevel
    >= :: HighlightingLevel -> HighlightingLevel -> Bool
    $c>= :: HighlightingLevel -> HighlightingLevel -> Bool
    > :: HighlightingLevel -> HighlightingLevel -> Bool
    $c> :: HighlightingLevel -> HighlightingLevel -> Bool
    <= :: HighlightingLevel -> HighlightingLevel -> Bool
    $c<= :: HighlightingLevel -> HighlightingLevel -> Bool
    < :: HighlightingLevel -> HighlightingLevel -> Bool
    $c< :: HighlightingLevel -> HighlightingLevel -> Bool
    compare :: HighlightingLevel -> HighlightingLevel -> Ordering
    $ccompare :: HighlightingLevel -> HighlightingLevel -> Ordering
    Ord, Int -> HighlightingLevel -> ShowS
    [HighlightingLevel] -> ShowS
    HighlightingLevel -> String
    (Int -> HighlightingLevel -> ShowS)
    -> (HighlightingLevel -> String)
    -> ([HighlightingLevel] -> ShowS)
    -> Show HighlightingLevel
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [HighlightingLevel] -> ShowS
    $cshowList :: [HighlightingLevel] -> ShowS
    show :: HighlightingLevel -> String
    $cshow :: HighlightingLevel -> String
    showsPrec :: Int -> HighlightingLevel -> ShowS
    $cshowsPrec :: Int -> HighlightingLevel -> ShowS
    Show, ReadPrec [HighlightingLevel]
    ReadPrec HighlightingLevel
    Int -> ReadS HighlightingLevel
    ReadS [HighlightingLevel]
    (Int -> ReadS HighlightingLevel)
    -> ReadS [HighlightingLevel]
    -> ReadPrec HighlightingLevel
    -> ReadPrec [HighlightingLevel]
    -> Read HighlightingLevel
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [HighlightingLevel]
    $creadListPrec :: ReadPrec [HighlightingLevel]
    readPrec :: ReadPrec HighlightingLevel
    $creadPrec :: ReadPrec HighlightingLevel
    readList :: ReadS [HighlightingLevel]
    $creadList :: ReadS [HighlightingLevel]
    readsPrec :: Int -> ReadS HighlightingLevel
    $creadsPrec :: Int -> ReadS HighlightingLevel
    Read, Typeable HighlightingLevel
    Typeable HighlightingLevel
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g)
        -> HighlightingLevel
        -> c HighlightingLevel)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HighlightingLevel)
    -> (HighlightingLevel -> Constr)
    -> (HighlightingLevel -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HighlightingLevel))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HighlightingLevel))
    -> ((forall b. Data b => b -> b)
        -> HighlightingLevel -> HighlightingLevel)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> HighlightingLevel -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HighlightingLevel -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> HighlightingLevel -> m HighlightingLevel)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> HighlightingLevel -> m HighlightingLevel)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> HighlightingLevel -> m HighlightingLevel)
    -> Data HighlightingLevel
    HighlightingLevel -> DataType
    HighlightingLevel -> Constr
    (forall b. Data b => b -> b)
    -> HighlightingLevel -> HighlightingLevel
    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) -> HighlightingLevel -> u
    forall u. (forall d. Data d => d -> u) -> HighlightingLevel -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> HighlightingLevel -> m HighlightingLevel
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingLevel -> m HighlightingLevel
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HighlightingLevel
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HighlightingLevel -> c HighlightingLevel
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HighlightingLevel)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HighlightingLevel)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingLevel -> m HighlightingLevel
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingLevel -> m HighlightingLevel
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingLevel -> m HighlightingLevel
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingLevel -> m HighlightingLevel
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> HighlightingLevel -> m HighlightingLevel
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> HighlightingLevel -> m HighlightingLevel
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> HighlightingLevel -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> HighlightingLevel -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HighlightingLevel -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HighlightingLevel -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r
    gmapT :: (forall b. Data b => b -> b)
    -> HighlightingLevel -> HighlightingLevel
    $cgmapT :: (forall b. Data b => b -> b)
    -> HighlightingLevel -> HighlightingLevel
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HighlightingLevel)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HighlightingLevel)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HighlightingLevel)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HighlightingLevel)
    dataTypeOf :: HighlightingLevel -> DataType
    $cdataTypeOf :: HighlightingLevel -> DataType
    toConstr :: HighlightingLevel -> Constr
    $ctoConstr :: HighlightingLevel -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HighlightingLevel
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HighlightingLevel
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HighlightingLevel -> c HighlightingLevel
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HighlightingLevel -> c HighlightingLevel
    Data, (forall x. HighlightingLevel -> Rep HighlightingLevel x)
    -> (forall x. Rep HighlightingLevel x -> HighlightingLevel)
    -> Generic HighlightingLevel
    forall x. Rep HighlightingLevel x -> HighlightingLevel
    forall x. HighlightingLevel -> Rep HighlightingLevel x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep HighlightingLevel x -> HighlightingLevel
    $cfrom :: forall x. HighlightingLevel -> Rep HighlightingLevel x
    Generic)

    -- | How should highlighting be sent to the user interface?

    data HighlightingMethod
      = Direct
        -- ^ Via stdout.
      | Indirect
        -- ^ Both via files and via stdout.
        deriving (HighlightingMethod -> HighlightingMethod -> Bool
    (HighlightingMethod -> HighlightingMethod -> Bool)
    -> (HighlightingMethod -> HighlightingMethod -> Bool)
    -> Eq HighlightingMethod
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: HighlightingMethod -> HighlightingMethod -> Bool
    $c/= :: HighlightingMethod -> HighlightingMethod -> Bool
    == :: HighlightingMethod -> HighlightingMethod -> Bool
    $c== :: HighlightingMethod -> HighlightingMethod -> Bool
    Eq, Int -> HighlightingMethod -> ShowS
    [HighlightingMethod] -> ShowS
    HighlightingMethod -> String
    (Int -> HighlightingMethod -> ShowS)
    -> (HighlightingMethod -> String)
    -> ([HighlightingMethod] -> ShowS)
    -> Show HighlightingMethod
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [HighlightingMethod] -> ShowS
    $cshowList :: [HighlightingMethod] -> ShowS
    show :: HighlightingMethod -> String
    $cshow :: HighlightingMethod -> String
    showsPrec :: Int -> HighlightingMethod -> ShowS
    $cshowsPrec :: Int -> HighlightingMethod -> ShowS
    Show, ReadPrec [HighlightingMethod]
    ReadPrec HighlightingMethod
    Int -> ReadS HighlightingMethod
    ReadS [HighlightingMethod]
    (Int -> ReadS HighlightingMethod)
    -> ReadS [HighlightingMethod]
    -> ReadPrec HighlightingMethod
    -> ReadPrec [HighlightingMethod]
    -> Read HighlightingMethod
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [HighlightingMethod]
    $creadListPrec :: ReadPrec [HighlightingMethod]
    readPrec :: ReadPrec HighlightingMethod
    $creadPrec :: ReadPrec HighlightingMethod
    readList :: ReadS [HighlightingMethod]
    $creadList :: ReadS [HighlightingMethod]
    readsPrec :: Int -> ReadS HighlightingMethod
    $creadsPrec :: Int -> ReadS HighlightingMethod
    Read, Typeable HighlightingMethod
    Typeable HighlightingMethod
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g)
        -> HighlightingMethod
        -> c HighlightingMethod)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HighlightingMethod)
    -> (HighlightingMethod -> Constr)
    -> (HighlightingMethod -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HighlightingMethod))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HighlightingMethod))
    -> ((forall b. Data b => b -> b)
        -> HighlightingMethod -> HighlightingMethod)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> HighlightingMethod -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HighlightingMethod -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> HighlightingMethod -> m HighlightingMethod)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> HighlightingMethod -> m HighlightingMethod)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> HighlightingMethod -> m HighlightingMethod)
    -> Data HighlightingMethod
    HighlightingMethod -> DataType
    HighlightingMethod -> Constr
    (forall b. Data b => b -> b)
    -> HighlightingMethod -> HighlightingMethod
    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) -> HighlightingMethod -> u
    forall u. (forall d. Data d => d -> u) -> HighlightingMethod -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> HighlightingMethod -> m HighlightingMethod
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingMethod -> m HighlightingMethod
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HighlightingMethod
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> HighlightingMethod
    -> c HighlightingMethod
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HighlightingMethod)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HighlightingMethod)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingMethod -> m HighlightingMethod
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingMethod -> m HighlightingMethod
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingMethod -> m HighlightingMethod
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> HighlightingMethod -> m HighlightingMethod
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> HighlightingMethod -> m HighlightingMethod
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> HighlightingMethod -> m HighlightingMethod
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> HighlightingMethod -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> HighlightingMethod -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HighlightingMethod -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HighlightingMethod -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r
    gmapT :: (forall b. Data b => b -> b)
    -> HighlightingMethod -> HighlightingMethod
    $cgmapT :: (forall b. Data b => b -> b)
    -> HighlightingMethod -> HighlightingMethod
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HighlightingMethod)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HighlightingMethod)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HighlightingMethod)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HighlightingMethod)
    dataTypeOf :: HighlightingMethod -> DataType
    $cdataTypeOf :: HighlightingMethod -> DataType
    toConstr :: HighlightingMethod -> Constr
    $ctoConstr :: HighlightingMethod -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HighlightingMethod
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HighlightingMethod
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> HighlightingMethod
    -> c HighlightingMethod
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> HighlightingMethod
    -> c HighlightingMethod
    Data, (forall x. HighlightingMethod -> Rep HighlightingMethod x)
    -> (forall x. Rep HighlightingMethod x -> HighlightingMethod)
    -> Generic HighlightingMethod
    forall x. Rep HighlightingMethod x -> HighlightingMethod
    forall x. HighlightingMethod -> Rep HighlightingMethod x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep HighlightingMethod x -> HighlightingMethod
    $cfrom :: forall x. HighlightingMethod -> Rep HighlightingMethod x
    Generic)

    -- | @ifTopLevelAndHighlightingLevelIs l b m@ runs @m@ when we're
    -- type-checking the top-level module (or before we've started doing
    -- this) and either the highlighting level is /at least/ @l@ or @b@ is
    -- 'True'.

    ifTopLevelAndHighlightingLevelIsOr ::
      MonadTCEnv tcm => HighlightingLevel -> Bool -> tcm () -> tcm ()
    ifTopLevelAndHighlightingLevelIsOr :: forall (tcm :: * -> *).
    MonadTCEnv tcm =>
    HighlightingLevel -> Bool -> tcm () -> tcm ()
    ifTopLevelAndHighlightingLevelIsOr HighlightingLevel
    l Bool
    b tcm ()
    m = do
      TCEnv
    e <- tcm TCEnv
    forall (m :: * -> *). MonadTCEnv m => m TCEnv
    askTC
      Bool -> tcm () -> tcm ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (TCEnv -> HighlightingLevel
    envHighlightingLevel TCEnv
    e HighlightingLevel -> HighlightingLevel -> Bool
    forall a. Ord a => a -> a -> Bool
    >= HighlightingLevel
    l Bool -> Bool -> Bool
    || Bool
    b) (tcm () -> tcm ()) -> tcm () -> tcm ()
    forall a b. (a -> b) -> a -> b
    $
        case (TCEnv -> [TopLevelModuleName]
    envImportPath TCEnv
    e) of
          -- Below the main module.
          (TopLevelModuleName
    _:TopLevelModuleName
    _:[TopLevelModuleName]
    _) -> () -> tcm ()
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ()
          -- In or before the top-level module.
          [TopLevelModuleName]
    _ -> tcm ()
    m

    -- | @ifTopLevelAndHighlightingLevelIs l m@ runs @m@ when we're
    -- type-checking the top-level module (or before we've started doing
    -- this) and the highlighting level is /at least/ @l@.

    ifTopLevelAndHighlightingLevelIs ::
      MonadTCEnv tcm => HighlightingLevel -> tcm () -> tcm ()
    ifTopLevelAndHighlightingLevelIs :: forall (tcm :: * -> *).
    MonadTCEnv tcm =>
    HighlightingLevel -> tcm () -> tcm ()
    ifTopLevelAndHighlightingLevelIs HighlightingLevel
    l =
      HighlightingLevel -> Bool -> tcm () -> tcm ()
    forall (tcm :: * -> *).
    MonadTCEnv tcm =>
    HighlightingLevel -> Bool -> tcm () -> tcm ()
    ifTopLevelAndHighlightingLevelIsOr HighlightingLevel
    l Bool
    False

    ---------------------------------------------------------------------------
    -- * Type checking environment
    ---------------------------------------------------------------------------

    data TCEnv =
        TCEnv { TCEnv -> Context
    envContext             :: Context
              , TCEnv -> LetBindings
    envLetBindings         :: LetBindings
              , TCEnv -> ModuleName
    envCurrentModule       :: ModuleName
              , TCEnv -> Maybe AbsolutePath
    envCurrentPath         :: Maybe AbsolutePath
                -- ^ The path to the file that is currently being
                -- type-checked.  'Nothing' if we do not have a file
                -- (like in interactive mode see @CommandLine@).
              , TCEnv -> [(ModuleName, Int)]
    envAnonymousModules    :: [(ModuleName, Nat)] -- ^ anonymous modules and their number of free variables
              , TCEnv -> [TopLevelModuleName]
    envImportPath          :: [C.TopLevelModuleName]
                -- ^ The module stack with the entry being the top-level module as
                --   Agda chases modules. It will be empty if there is no main
                --   module, will have a single entry for the top level module, or
                --   more when descending past the main module. This is used to
                --   detect import cycles and in some cases highlighting behavior.
                --   The level of a given module is not necessarily the same as the
                --   length, in the module dependency graph, of the shortest path
                --   from the top-level module; it depends on in which order Agda
                --   chooses to chase dependencies.
              , TCEnv -> Maybe MutualId
    envMutualBlock         :: Maybe MutualId -- ^ the current (if any) mutual block
              , TCEnv -> TerminationCheck ()
    envTerminationCheck    :: TerminationCheck ()  -- ^ are we inside the scope of a termination pragma
              , TCEnv -> CoverageCheck
    envCoverageCheck       :: CoverageCheck        -- ^ are we inside the scope of a coverage pragma
              , TCEnv -> Bool
    envMakeCase            :: Bool                 -- ^ are we inside a make-case (if so, ignore forcing analysis in unifier)
              , TCEnv -> Bool
    envSolvingConstraints  :: Bool
                    -- ^ Are we currently in the process of solving active constraints?
              , TCEnv -> Bool
    envCheckingWhere       :: Bool
                    -- ^ Have we stepped into the where-declarations of a clause?
                    --   Everything under a @where@ will be checked with this flag on.
              , TCEnv -> Bool
    envWorkingOnTypes      :: Bool
                    -- ^ Are we working on types? Turned on by 'workOnTypes'.
              , TCEnv -> Bool
    envAssignMetas         :: Bool
                -- ^ Are we allowed to assign metas?
              , TCEnv -> Set ProblemId
    envActiveProblems      :: Set ProblemId
              , TCEnv -> AbstractMode
    envAbstractMode        :: AbstractMode
                    -- ^ When checking the typesignature of a public definition
                    --   or the body of a non-abstract definition this is true.
                    --   To prevent information about abstract things leaking
                    --   outside the module.
              , TCEnv -> Modality
    envModality            :: Modality
                    -- ^ 'Relevance' component:
                    -- Are we checking an irrelevant argument? (=@Irrelevant@)
                    -- Then top-level irrelevant declarations are enabled.
                    -- Other value: @Relevant@, then only relevant decls. are available.
                    --
                    -- 'Quantity' component:
                    -- Are we checking a runtime-irrelevant thing? (='Quantity0')
                    -- Then runtime-irrelevant things are usable.
                    -- Other value: @Quantity1@, runtime relevant.
                    -- @Quantityω@ is not allowed here, see Bob Atkey, LiCS 2018.
              , TCEnv -> Bool
    envSplitOnStrict       :: Bool
                    -- ^ Are we currently case-splitting on a strict
                    --   datatype (i.e. in SSet)? If yes, the
                    --   pattern-matching unifier will solve reflexive
                    --   equations even --without-K.
              , TCEnv -> Bool
    envDisplayFormsEnabled :: Bool
                    -- ^ Sometimes we want to disable display forms.
              , TCEnv -> Range
    envRange :: Range
              , TCEnv -> Range
    envHighlightingRange :: Range
                    -- ^ Interactive highlighting uses this range rather
                    --   than 'envRange'.
              , TCEnv -> IPClause
    envClause :: IPClause
                    -- ^ What is the current clause we are type-checking?
                    --   Will be recorded in interaction points in this clause.
              , TCEnv -> Maybe (Closure Call)
    envCall  :: Maybe (Closure Call)
                    -- ^ what we're doing at the moment
              , TCEnv -> HighlightingLevel
    envHighlightingLevel  :: HighlightingLevel
                    -- ^ Set to 'None' when imported modules are
                    --   type-checked.
              , TCEnv -> HighlightingMethod
    envHighlightingMethod :: HighlightingMethod
              , TCEnv -> ExpandHidden
    envExpandLast :: ExpandHidden
                    -- ^ When type-checking an alias f=e, we do not want
                    -- to insert hidden arguments in the end, because
                    -- these will become unsolved metas.
              , TCEnv -> Maybe QName
    envAppDef :: Maybe QName
                    -- ^ We are reducing an application of this function.
                    -- (For debugging of incomplete matches only.)
              , TCEnv -> Simplification
    envSimplification :: Simplification
                    -- ^ Did we encounter a simplification (proper match)
                    --   during the current reduction process?
              , TCEnv -> AllowedReductions
    envAllowedReductions :: AllowedReductions
              , TCEnv -> ReduceDefs
    envReduceDefs :: ReduceDefs
              , TCEnv -> Bool
    envReconstructed :: Bool
              , TCEnv -> Int
    envInjectivityDepth :: Int
                    -- ^ Injectivity can cause non-termination for unsolvable contraints
                    --   (#431, #3067). Keep a limit on the nesting depth of injectivity
                    --   uses.
              , TCEnv -> Bool
    envCompareBlocked :: Bool
                    -- ^ When @True@, the conversion checker will consider
                    --   all term constructors as injective, including
                    --   blocked function applications and metas. Warning:
                    --   this should only be used when not assigning any
                    --   metas (e.g. when @envAssignMetas@ is @False@ or
                    --   when running @pureEqualTerms@) or else we get
                    --   non-unique meta solutions.
              , TCEnv -> Bool
    envPrintDomainFreePi :: Bool
                    -- ^ When @True@, types will be omitted from printed pi types if they
                    --   can be inferred.
              , TCEnv -> Bool
    envPrintMetasBare :: Bool
                    -- ^ When @True@, throw away meta numbers and meta elims.
                    --   This is used for reifying terms for feeding into the
                    --   user's source code, e.g., for the interaction tactics @solveAll@.
              , TCEnv -> Bool
    envInsideDotPattern :: Bool
                    -- ^ Used by the scope checker to make sure that certain forms
                    --   of expressions are not used inside dot patterns: extended
                    --   lambdas and let-expressions.
              , TCEnv -> UnquoteFlags
    envUnquoteFlags :: UnquoteFlags
              , TCEnv -> Int
    envInstanceDepth :: !Int
                    -- ^ Until we get a termination checker for instance search (#1743) we
                    --   limit the search depth to ensure termination.
              , TCEnv -> Bool
    envIsDebugPrinting :: Bool
              , TCEnv -> [QName]
    envPrintingPatternLambdas :: [QName]
                    -- ^ #3004: pattern lambdas with copatterns may refer to themselves. We
                    --   don't have a good story for what to do in this case, but at least
                    --   printing shouldn't loop. Here we keep track of which pattern lambdas
                    --   we are currently in the process of printing.
              , TCEnv -> Bool
    envCallByNeed :: Bool
                    -- ^ Use call-by-need evaluation for reductions.
              , TCEnv -> CheckpointId
    envCurrentCheckpoint :: CheckpointId
                    -- ^ Checkpoints track the evolution of the context as we go
                    -- under binders or refine it by pattern matching.
              , TCEnv -> Map CheckpointId Substitution
    envCheckpoints :: Map CheckpointId Substitution
                    -- ^ Keeps the substitution from each previous checkpoint to
                    --   the current context.
              , TCEnv -> DoGeneralize
    envGeneralizeMetas :: DoGeneralize
                    -- ^ Should new metas generalized over.
              , TCEnv -> Map QName GeneralizedValue
    envGeneralizedVars :: Map QName GeneralizedValue
                    -- ^ Values for used generalizable variables.
              , TCEnv -> Maybe String
    envActiveBackendName :: Maybe BackendName
                    -- ^ Is some backend active at the moment, and if yes, which?
                    --   NB: we only store the 'BackendName' here, otherwise
                    --   @instance Data TCEnv@ is not derivable.
                    --   The actual backend can be obtained from the name via 'stBackends'.
              , TCEnv -> Bool
    envConflComputingOverlap :: Bool
                    -- ^ Are we currently computing the overlap between
                    --   two rewrite rules for the purpose of confluence checking?
              , TCEnv -> Bool
    envCurrentlyElaborating :: Bool
                    -- ^ Are we currently in the process of executing an
                    --   elaborate-and-give interactive command?
              }
        deriving ((forall x. TCEnv -> Rep TCEnv x)
    -> (forall x. Rep TCEnv x -> TCEnv) -> Generic TCEnv
    forall x. Rep TCEnv x -> TCEnv
    forall x. TCEnv -> Rep TCEnv x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TCEnv x -> TCEnv
    $cfrom :: forall x. TCEnv -> Rep TCEnv x
    Generic)

    initEnv :: TCEnv
    initEnv :: TCEnv
    initEnv = TCEnv :: Context
    -> LetBindings
    -> ModuleName
    -> Maybe AbsolutePath
    -> [(ModuleName, Int)]
    -> [TopLevelModuleName]
    -> Maybe MutualId
    -> TerminationCheck ()
    -> CoverageCheck
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> Set ProblemId
    -> AbstractMode
    -> Modality
    -> Bool
    -> Bool
    -> Range
    -> Range
    -> IPClause
    -> Maybe (Closure Call)
    -> HighlightingLevel
    -> HighlightingMethod
    -> ExpandHidden
    -> Maybe QName
    -> Simplification
    -> AllowedReductions
    -> ReduceDefs
    -> Bool
    -> Int
    -> Bool
    -> Bool
    -> Bool
    -> Bool
    -> UnquoteFlags
    -> Int
    -> Bool
    -> [QName]
    -> Bool
    -> CheckpointId
    -> Map CheckpointId Substitution
    -> DoGeneralize
    -> Map QName GeneralizedValue
    -> Maybe String
    -> Bool
    -> Bool
    -> TCEnv
    TCEnv { envContext :: Context
    envContext             = []
                    , envLetBindings :: LetBindings
    envLetBindings         = LetBindings
    forall k a. Map k a
    Map.empty
                    , envCurrentModule :: ModuleName
    envCurrentModule       = ModuleName
    noModuleName
                    , envCurrentPath :: Maybe AbsolutePath
    envCurrentPath         = Maybe AbsolutePath
    forall a. Maybe a
    Nothing
                    , envAnonymousModules :: [(ModuleName, Int)]
    envAnonymousModules    = []
                    , envImportPath :: [TopLevelModuleName]
    envImportPath          = []
                    , envMutualBlock :: Maybe MutualId
    envMutualBlock         = Maybe MutualId
    forall a. Maybe a
    Nothing
                    , envTerminationCheck :: TerminationCheck ()
    envTerminationCheck    = TerminationCheck ()
    forall m. TerminationCheck m
    TerminationCheck
                    , envCoverageCheck :: CoverageCheck
    envCoverageCheck       = CoverageCheck
    YesCoverageCheck
                    , envMakeCase :: Bool
    envMakeCase            = Bool
    False
                    , envSolvingConstraints :: Bool
    envSolvingConstraints  = Bool
    False
                    , envCheckingWhere :: Bool
    envCheckingWhere       = Bool
    False
                    , envActiveProblems :: Set ProblemId
    envActiveProblems      = Set ProblemId
    forall a. Set a
    Set.empty
                    , envWorkingOnTypes :: Bool
    envWorkingOnTypes      = Bool
    False
                    , envAssignMetas :: Bool
    envAssignMetas         = Bool
    True
                    , envAbstractMode :: AbstractMode
    envAbstractMode        = AbstractMode
    ConcreteMode
      -- Andreas, 2013-02-21:  This was 'AbstractMode' until now.
      -- However, top-level checks for mutual blocks, such as
      -- constructor-headedness, should not be able to look into
      -- abstract definitions unless abstract themselves.
      -- (See also discussion on issue 796.)
      -- The initial mode should be 'ConcreteMode', ensuring you
      -- can only look into abstract things in an abstract
      -- definition (which sets 'AbstractMode').
                    , envModality :: Modality
    envModality               = Modality
    unitModality
                    , envSplitOnStrict :: Bool
    envSplitOnStrict          = Bool
    False
                    , envDisplayFormsEnabled :: Bool
    envDisplayFormsEnabled    = Bool
    True
                    , envRange :: Range
    envRange                  = Range
    forall a. Range' a
    noRange
                    , envHighlightingRange :: Range
    envHighlightingRange      = Range
    forall a. Range' a
    noRange
                    , envClause :: IPClause
    envClause                 = IPClause
    IPNoClause
                    , envCall :: Maybe (Closure Call)
    envCall                   = Maybe (Closure Call)
    forall a. Maybe a
    Nothing
                    , envHighlightingLevel :: HighlightingLevel
    envHighlightingLevel      = HighlightingLevel
    None
                    , envHighlightingMethod :: HighlightingMethod
    envHighlightingMethod     = HighlightingMethod
    Indirect
                    , envExpandLast :: ExpandHidden
    envExpandLast             = ExpandHidden
    ExpandLast
                    , envAppDef :: Maybe QName
    envAppDef                 = Maybe QName
    forall a. Maybe a
    Nothing
                    , envSimplification :: Simplification
    envSimplification         = Simplification
    NoSimplification
                    , envAllowedReductions :: AllowedReductions
    envAllowedReductions      = AllowedReductions
    allReductions
                    , envReduceDefs :: ReduceDefs
    envReduceDefs             = ReduceDefs
    reduceAllDefs
                    , envReconstructed :: Bool
    envReconstructed          = Bool
    False
                    , envInjectivityDepth :: Int
    envInjectivityDepth       = Int
    0
                    , envCompareBlocked :: Bool
    envCompareBlocked         = Bool
    False
                    , envPrintDomainFreePi :: Bool
    envPrintDomainFreePi      = Bool
    False
                    , envPrintMetasBare :: Bool
    envPrintMetasBare         = Bool
    False
                    , envInsideDotPattern :: Bool
    envInsideDotPattern       = Bool
    False
                    , envUnquoteFlags :: UnquoteFlags
    envUnquoteFlags           = UnquoteFlags
    defaultUnquoteFlags
                    , envInstanceDepth :: Int
    envInstanceDepth          = Int
    0
                    , envIsDebugPrinting :: Bool
    envIsDebugPrinting        = Bool
    False
                    , envPrintingPatternLambdas :: [QName]
    envPrintingPatternLambdas = []
                    , envCallByNeed :: Bool
    envCallByNeed             = Bool
    True
                    , envCurrentCheckpoint :: CheckpointId
    envCurrentCheckpoint      = CheckpointId
    0
                    , envCheckpoints :: Map CheckpointId Substitution
    envCheckpoints            = CheckpointId -> Substitution -> Map CheckpointId Substitution
    forall k a. k -> a -> Map k a
    Map.singleton CheckpointId
    0 Substitution
    forall a. Substitution' a
    IdS
                    , envGeneralizeMetas :: DoGeneralize
    envGeneralizeMetas        = DoGeneralize
    NoGeneralize
                    , envGeneralizedVars :: Map QName GeneralizedValue
    envGeneralizedVars        = Map QName GeneralizedValue
    forall k a. Map k a
    Map.empty
                    , envActiveBackendName :: Maybe String
    envActiveBackendName      = Maybe String
    forall a. Maybe a
    Nothing
                    , envConflComputingOverlap :: Bool
    envConflComputingOverlap  = Bool
    False
                    , envCurrentlyElaborating :: Bool
    envCurrentlyElaborating   = Bool
    False
                    }

    class LensTCEnv a where
      lensTCEnv :: Lens' TCEnv a

    instance LensTCEnv TCEnv where
      lensTCEnv :: Lens' TCEnv TCEnv
    lensTCEnv = (TCEnv -> f TCEnv) -> TCEnv -> f TCEnv
    forall a. a -> a
    id

    instance LensModality TCEnv where
      -- Cohesion shouldn't have an environment component.
      getModality :: TCEnv -> Modality
    getModality = Cohesion -> Modality -> Modality
    forall a. LensCohesion a => Cohesion -> a -> a
    setCohesion Cohesion
    defaultCohesion (Modality -> Modality) -> (TCEnv -> Modality) -> TCEnv -> Modality
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCEnv -> Modality
    envModality
      mapModality :: (Modality -> Modality) -> TCEnv -> TCEnv
    mapModality Modality -> Modality
    f TCEnv
    e = TCEnv
    e { envModality :: Modality
    envModality = Cohesion -> Modality -> Modality
    forall a. LensCohesion a => Cohesion -> a -> a
    setCohesion Cohesion
    defaultCohesion (Modality -> Modality) -> Modality -> Modality
    forall a b. (a -> b) -> a -> b
    $ Modality -> Modality
    f (Modality -> Modality) -> Modality -> Modality
    forall a b. (a -> b) -> a -> b
    $ TCEnv -> Modality
    envModality TCEnv
    e }

    instance LensRelevance TCEnv where
    instance LensQuantity  TCEnv where

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

    defaultUnquoteFlags :: UnquoteFlags
    defaultUnquoteFlags :: UnquoteFlags
    defaultUnquoteFlags = UnquoteFlags :: Bool -> UnquoteFlags
    UnquoteFlags
      { _unquoteNormalise :: Bool
    _unquoteNormalise = Bool
    False }

    unquoteNormalise :: Lens' Bool UnquoteFlags
    unquoteNormalise :: Lens' Bool UnquoteFlags
    unquoteNormalise Bool -> f Bool
    f UnquoteFlags
    e = Bool -> f Bool
    f (UnquoteFlags -> Bool
    _unquoteNormalise UnquoteFlags
    e) f Bool -> (Bool -> UnquoteFlags) -> f UnquoteFlags
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> UnquoteFlags
    e { _unquoteNormalise :: Bool
    _unquoteNormalise = Bool
    x }

    eUnquoteNormalise :: Lens' Bool TCEnv
    eUnquoteNormalise :: Lens' Bool TCEnv
    eUnquoteNormalise = (UnquoteFlags -> f UnquoteFlags) -> TCEnv -> f TCEnv
    Lens' UnquoteFlags TCEnv
    eUnquoteFlags ((UnquoteFlags -> f UnquoteFlags) -> TCEnv -> f TCEnv)
    -> ((Bool -> f Bool) -> UnquoteFlags -> f UnquoteFlags)
    -> (Bool -> f Bool)
    -> TCEnv
    -> f TCEnv
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Bool -> f Bool) -> UnquoteFlags -> f UnquoteFlags
    Lens' Bool UnquoteFlags
    unquoteNormalise

    -- * e-prefixed lenses
    ------------------------------------------------------------------------

    eContext :: Lens' Context TCEnv
    eContext :: Lens' Context TCEnv
    eContext Context -> f Context
    f TCEnv
    e = Context -> f Context
    f (TCEnv -> Context
    envContext TCEnv
    e) f Context -> (Context -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Context
    x -> TCEnv
    e { envContext :: Context
    envContext = Context
    x }

    eLetBindings :: Lens' LetBindings TCEnv
    eLetBindings :: Lens' LetBindings TCEnv
    eLetBindings LetBindings -> f LetBindings
    f TCEnv
    e = LetBindings -> f LetBindings
    f (TCEnv -> LetBindings
    envLetBindings TCEnv
    e) f LetBindings -> (LetBindings -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ LetBindings
    x -> TCEnv
    e { envLetBindings :: LetBindings
    envLetBindings = LetBindings
    x }

    eCurrentModule :: Lens' ModuleName TCEnv
    eCurrentModule :: Lens' ModuleName TCEnv
    eCurrentModule ModuleName -> f ModuleName
    f TCEnv
    e = ModuleName -> f ModuleName
    f (TCEnv -> ModuleName
    envCurrentModule TCEnv
    e) f ModuleName -> (ModuleName -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ ModuleName
    x -> TCEnv
    e { envCurrentModule :: ModuleName
    envCurrentModule = ModuleName
    x }

    eCurrentPath :: Lens' (Maybe AbsolutePath) TCEnv
    eCurrentPath :: Lens' (Maybe AbsolutePath) TCEnv
    eCurrentPath Maybe AbsolutePath -> f (Maybe AbsolutePath)
    f TCEnv
    e = Maybe AbsolutePath -> f (Maybe AbsolutePath)
    f (TCEnv -> Maybe AbsolutePath
    envCurrentPath TCEnv
    e) f (Maybe AbsolutePath) -> (Maybe AbsolutePath -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Maybe AbsolutePath
    x -> TCEnv
    e { envCurrentPath :: Maybe AbsolutePath
    envCurrentPath = Maybe AbsolutePath
    x }

    eAnonymousModules :: Lens' [(ModuleName, Nat)] TCEnv
    eAnonymousModules :: Lens' [(ModuleName, Int)] TCEnv
    eAnonymousModules [(ModuleName, Int)] -> f [(ModuleName, Int)]
    f TCEnv
    e = [(ModuleName, Int)] -> f [(ModuleName, Int)]
    f (TCEnv -> [(ModuleName, Int)]
    envAnonymousModules TCEnv
    e) f [(ModuleName, Int)] -> ([(ModuleName, Int)] -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ [(ModuleName, Int)]
    x -> TCEnv
    e { envAnonymousModules :: [(ModuleName, Int)]
    envAnonymousModules = [(ModuleName, Int)]
    x }

    eImportPath :: Lens' [C.TopLevelModuleName] TCEnv
    eImportPath :: Lens' [TopLevelModuleName] TCEnv
    eImportPath [TopLevelModuleName] -> f [TopLevelModuleName]
    f TCEnv
    e = [TopLevelModuleName] -> f [TopLevelModuleName]
    f (TCEnv -> [TopLevelModuleName]
    envImportPath TCEnv
    e) f [TopLevelModuleName]
    -> ([TopLevelModuleName] -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ [TopLevelModuleName]
    x -> TCEnv
    e { envImportPath :: [TopLevelModuleName]
    envImportPath = [TopLevelModuleName]
    x }

    eMutualBlock :: Lens' (Maybe MutualId) TCEnv
    eMutualBlock :: Lens' (Maybe MutualId) TCEnv
    eMutualBlock Maybe MutualId -> f (Maybe MutualId)
    f TCEnv
    e = Maybe MutualId -> f (Maybe MutualId)
    f (TCEnv -> Maybe MutualId
    envMutualBlock TCEnv
    e) f (Maybe MutualId) -> (Maybe MutualId -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Maybe MutualId
    x -> TCEnv
    e { envMutualBlock :: Maybe MutualId
    envMutualBlock = Maybe MutualId
    x }

    eTerminationCheck :: Lens' (TerminationCheck ()) TCEnv
    eTerminationCheck :: Lens' (TerminationCheck ()) TCEnv
    eTerminationCheck TerminationCheck () -> f (TerminationCheck ())
    f TCEnv
    e = TerminationCheck () -> f (TerminationCheck ())
    f (TCEnv -> TerminationCheck ()
    envTerminationCheck TCEnv
    e) f (TerminationCheck ())
    -> (TerminationCheck () -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ TerminationCheck ()
    x -> TCEnv
    e { envTerminationCheck :: TerminationCheck ()
    envTerminationCheck = TerminationCheck ()
    x }

    eCoverageCheck :: Lens' CoverageCheck TCEnv
    eCoverageCheck :: Lens' CoverageCheck TCEnv
    eCoverageCheck CoverageCheck -> f CoverageCheck
    f TCEnv
    e = CoverageCheck -> f CoverageCheck
    f (TCEnv -> CoverageCheck
    envCoverageCheck TCEnv
    e) f CoverageCheck -> (CoverageCheck -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ CoverageCheck
    x -> TCEnv
    e { envCoverageCheck :: CoverageCheck
    envCoverageCheck = CoverageCheck
    x }

    eMakeCase :: Lens' Bool TCEnv
    eMakeCase :: Lens' Bool TCEnv
    eMakeCase Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envMakeCase TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envMakeCase :: Bool
    envMakeCase = Bool
    x }

    eSolvingConstraints :: Lens' Bool TCEnv
    eSolvingConstraints :: Lens' Bool TCEnv
    eSolvingConstraints Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envSolvingConstraints TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envSolvingConstraints :: Bool
    envSolvingConstraints = Bool
    x }

    eCheckingWhere :: Lens' Bool TCEnv
    eCheckingWhere :: Lens' Bool TCEnv
    eCheckingWhere Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envCheckingWhere TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envCheckingWhere :: Bool
    envCheckingWhere = Bool
    x }

    eWorkingOnTypes :: Lens' Bool TCEnv
    eWorkingOnTypes :: Lens' Bool TCEnv
    eWorkingOnTypes Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envWorkingOnTypes TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envWorkingOnTypes :: Bool
    envWorkingOnTypes = Bool
    x }

    eAssignMetas :: Lens' Bool TCEnv
    eAssignMetas :: Lens' Bool TCEnv
    eAssignMetas Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envAssignMetas TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envAssignMetas :: Bool
    envAssignMetas = Bool
    x }

    eActiveProblems :: Lens' (Set ProblemId) TCEnv
    eActiveProblems :: Lens' (Set ProblemId) TCEnv
    eActiveProblems Set ProblemId -> f (Set ProblemId)
    f TCEnv
    e = Set ProblemId -> f (Set ProblemId)
    f (TCEnv -> Set ProblemId
    envActiveProblems TCEnv
    e) f (Set ProblemId) -> (Set ProblemId -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Set ProblemId
    x -> TCEnv
    e { envActiveProblems :: Set ProblemId
    envActiveProblems = Set ProblemId
    x }

    eAbstractMode :: Lens' AbstractMode TCEnv
    eAbstractMode :: Lens' AbstractMode TCEnv
    eAbstractMode AbstractMode -> f AbstractMode
    f TCEnv
    e = AbstractMode -> f AbstractMode
    f (TCEnv -> AbstractMode
    envAbstractMode TCEnv
    e) f AbstractMode -> (AbstractMode -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ AbstractMode
    x -> TCEnv
    e { envAbstractMode :: AbstractMode
    envAbstractMode = AbstractMode
    x }

    -- Andrea 23/02/2020: use get/setModality to enforce invariants of the
    --                    envModality field.
    eModality :: Lens' Modality TCEnv
    eModality :: Lens' Modality TCEnv
    eModality Modality -> f Modality
    f TCEnv
    e = Modality -> f Modality
    f (TCEnv -> Modality
    forall a. LensModality a => a -> Modality
    getModality TCEnv
    e) f Modality -> (Modality -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Modality
    x -> Modality -> TCEnv -> TCEnv
    forall a. LensModality a => Modality -> a -> a
    setModality Modality
    x TCEnv
    e

    eRelevance :: Lens' Relevance TCEnv
    eRelevance :: Lens' Relevance TCEnv
    eRelevance = (Modality -> f Modality) -> TCEnv -> f TCEnv
    Lens' Modality TCEnv
    eModality ((Modality -> f Modality) -> TCEnv -> f TCEnv)
    -> ((Relevance -> f Relevance) -> Modality -> f Modality)
    -> (Relevance -> f Relevance)
    -> TCEnv
    -> f TCEnv
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Relevance -> f Relevance) -> Modality -> f Modality
    Lens' Relevance Modality
    lModRelevance

    eQuantity :: Lens' Quantity TCEnv
    eQuantity :: Lens' Quantity TCEnv
    eQuantity = (Modality -> f Modality) -> TCEnv -> f TCEnv
    Lens' Modality TCEnv
    eModality ((Modality -> f Modality) -> TCEnv -> f TCEnv)
    -> ((Quantity -> f Quantity) -> Modality -> f Modality)
    -> (Quantity -> f Quantity)
    -> TCEnv
    -> f TCEnv
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Quantity -> f Quantity) -> Modality -> f Modality
    Lens' Quantity Modality
    lModQuantity

    eSplitOnStrict :: Lens' Bool TCEnv
    eSplitOnStrict :: Lens' Bool TCEnv
    eSplitOnStrict Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envSplitOnStrict TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envSplitOnStrict :: Bool
    envSplitOnStrict = Bool
    x }

    eDisplayFormsEnabled :: Lens' Bool TCEnv
    eDisplayFormsEnabled :: Lens' Bool TCEnv
    eDisplayFormsEnabled Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envDisplayFormsEnabled TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envDisplayFormsEnabled :: Bool
    envDisplayFormsEnabled = Bool
    x }

    eRange :: Lens' Range TCEnv
    eRange :: Lens' Range TCEnv
    eRange Range -> f Range
    f TCEnv
    e = Range -> f Range
    f (TCEnv -> Range
    envRange TCEnv
    e) f Range -> (Range -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Range
    x -> TCEnv
    e { envRange :: Range
    envRange = Range
    x }

    eHighlightingRange :: Lens' Range TCEnv
    eHighlightingRange :: Lens' Range TCEnv
    eHighlightingRange Range -> f Range
    f TCEnv
    e = Range -> f Range
    f (TCEnv -> Range
    envHighlightingRange TCEnv
    e) f Range -> (Range -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Range
    x -> TCEnv
    e { envHighlightingRange :: Range
    envHighlightingRange = Range
    x }

    eCall :: Lens' (Maybe (Closure Call)) TCEnv
    eCall :: Lens' (Maybe (Closure Call)) TCEnv
    eCall Maybe (Closure Call) -> f (Maybe (Closure Call))
    f TCEnv
    e = Maybe (Closure Call) -> f (Maybe (Closure Call))
    f (TCEnv -> Maybe (Closure Call)
    envCall TCEnv
    e) f (Maybe (Closure Call))
    -> (Maybe (Closure Call) -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Maybe (Closure Call)
    x -> TCEnv
    e { envCall :: Maybe (Closure Call)
    envCall = Maybe (Closure Call)
    x }

    eHighlightingLevel :: Lens' HighlightingLevel TCEnv
    eHighlightingLevel :: Lens' HighlightingLevel TCEnv
    eHighlightingLevel HighlightingLevel -> f HighlightingLevel
    f TCEnv
    e = HighlightingLevel -> f HighlightingLevel
    f (TCEnv -> HighlightingLevel
    envHighlightingLevel TCEnv
    e) f HighlightingLevel -> (HighlightingLevel -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ HighlightingLevel
    x -> TCEnv
    e { envHighlightingLevel :: HighlightingLevel
    envHighlightingLevel = HighlightingLevel
    x }

    eHighlightingMethod :: Lens' HighlightingMethod TCEnv
    eHighlightingMethod :: Lens' HighlightingMethod TCEnv
    eHighlightingMethod HighlightingMethod -> f HighlightingMethod
    f TCEnv
    e = HighlightingMethod -> f HighlightingMethod
    f (TCEnv -> HighlightingMethod
    envHighlightingMethod TCEnv
    e) f HighlightingMethod -> (HighlightingMethod -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ HighlightingMethod
    x -> TCEnv
    e { envHighlightingMethod :: HighlightingMethod
    envHighlightingMethod = HighlightingMethod
    x }

    eExpandLast :: Lens' ExpandHidden TCEnv
    eExpandLast :: Lens' ExpandHidden TCEnv
    eExpandLast ExpandHidden -> f ExpandHidden
    f TCEnv
    e = ExpandHidden -> f ExpandHidden
    f (TCEnv -> ExpandHidden
    envExpandLast TCEnv
    e) f ExpandHidden -> (ExpandHidden -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ ExpandHidden
    x -> TCEnv
    e { envExpandLast :: ExpandHidden
    envExpandLast = ExpandHidden
    x }

    eAppDef :: Lens' (Maybe QName) TCEnv
    eAppDef :: Lens' (Maybe QName) TCEnv
    eAppDef Maybe QName -> f (Maybe QName)
    f TCEnv
    e = Maybe QName -> f (Maybe QName)
    f (TCEnv -> Maybe QName
    envAppDef TCEnv
    e) f (Maybe QName) -> (Maybe QName -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Maybe QName
    x -> TCEnv
    e { envAppDef :: Maybe QName
    envAppDef = Maybe QName
    x }

    eSimplification :: Lens' Simplification TCEnv
    eSimplification :: Lens' Simplification TCEnv
    eSimplification Simplification -> f Simplification
    f TCEnv
    e = Simplification -> f Simplification
    f (TCEnv -> Simplification
    envSimplification TCEnv
    e) f Simplification -> (Simplification -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Simplification
    x -> TCEnv
    e { envSimplification :: Simplification
    envSimplification = Simplification
    x }

    eAllowedReductions :: Lens' AllowedReductions TCEnv
    eAllowedReductions :: Lens' AllowedReductions TCEnv
    eAllowedReductions AllowedReductions -> f AllowedReductions
    f TCEnv
    e = AllowedReductions -> f AllowedReductions
    f (TCEnv -> AllowedReductions
    envAllowedReductions TCEnv
    e) f AllowedReductions -> (AllowedReductions -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ AllowedReductions
    x -> TCEnv
    e { envAllowedReductions :: AllowedReductions
    envAllowedReductions = AllowedReductions
    x }

    eReduceDefs :: Lens' ReduceDefs TCEnv
    eReduceDefs :: Lens' ReduceDefs TCEnv
    eReduceDefs ReduceDefs -> f ReduceDefs
    f TCEnv
    e = ReduceDefs -> f ReduceDefs
    f (TCEnv -> ReduceDefs
    envReduceDefs TCEnv
    e) f ReduceDefs -> (ReduceDefs -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ ReduceDefs
    x -> TCEnv
    e { envReduceDefs :: ReduceDefs
    envReduceDefs = ReduceDefs
    x }

    eReconstructed :: Lens' Bool TCEnv
    eReconstructed :: Lens' Bool TCEnv
    eReconstructed Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envReconstructed TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envReconstructed :: Bool
    envReconstructed = Bool
    x }

    eInjectivityDepth :: Lens' Int TCEnv
    eInjectivityDepth :: Lens' Int TCEnv
    eInjectivityDepth Int -> f Int
    f TCEnv
    e = Int -> f Int
    f (TCEnv -> Int
    envInjectivityDepth TCEnv
    e) f Int -> (Int -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Int
    x -> TCEnv
    e { envInjectivityDepth :: Int
    envInjectivityDepth = Int
    x }

    eCompareBlocked :: Lens' Bool TCEnv
    eCompareBlocked :: Lens' Bool TCEnv
    eCompareBlocked Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envCompareBlocked TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envCompareBlocked :: Bool
    envCompareBlocked = Bool
    x }

    ePrintDomainFreePi :: Lens' Bool TCEnv
    ePrintDomainFreePi :: Lens' Bool TCEnv
    ePrintDomainFreePi Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envPrintDomainFreePi TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envPrintDomainFreePi :: Bool
    envPrintDomainFreePi = Bool
    x }

    ePrintMetasBare :: Lens' Bool TCEnv
    ePrintMetasBare :: Lens' Bool TCEnv
    ePrintMetasBare Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envPrintMetasBare TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envPrintMetasBare :: Bool
    envPrintMetasBare = Bool
    x }

    eInsideDotPattern :: Lens' Bool TCEnv
    eInsideDotPattern :: Lens' Bool TCEnv
    eInsideDotPattern Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envInsideDotPattern TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envInsideDotPattern :: Bool
    envInsideDotPattern = Bool
    x }

    eUnquoteFlags :: Lens' UnquoteFlags TCEnv
    eUnquoteFlags :: Lens' UnquoteFlags TCEnv
    eUnquoteFlags UnquoteFlags -> f UnquoteFlags
    f TCEnv
    e = UnquoteFlags -> f UnquoteFlags
    f (TCEnv -> UnquoteFlags
    envUnquoteFlags TCEnv
    e) f UnquoteFlags -> (UnquoteFlags -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ UnquoteFlags
    x -> TCEnv
    e { envUnquoteFlags :: UnquoteFlags
    envUnquoteFlags = UnquoteFlags
    x }

    eInstanceDepth :: Lens' Int TCEnv
    eInstanceDepth :: Lens' Int TCEnv
    eInstanceDepth Int -> f Int
    f TCEnv
    e = Int -> f Int
    f (TCEnv -> Int
    envInstanceDepth TCEnv
    e) f Int -> (Int -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Int
    x -> TCEnv
    e { envInstanceDepth :: Int
    envInstanceDepth = Int
    x }

    eIsDebugPrinting :: Lens' Bool TCEnv
    eIsDebugPrinting :: Lens' Bool TCEnv
    eIsDebugPrinting Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envIsDebugPrinting TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envIsDebugPrinting :: Bool
    envIsDebugPrinting = Bool
    x }

    ePrintingPatternLambdas :: Lens' [QName] TCEnv
    ePrintingPatternLambdas :: Lens' [QName] TCEnv
    ePrintingPatternLambdas [QName] -> f [QName]
    f TCEnv
    e = [QName] -> f [QName]
    f (TCEnv -> [QName]
    envPrintingPatternLambdas TCEnv
    e) f [QName] -> ([QName] -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ [QName]
    x -> TCEnv
    e { envPrintingPatternLambdas :: [QName]
    envPrintingPatternLambdas = [QName]
    x }

    eCallByNeed :: Lens' Bool TCEnv
    eCallByNeed :: Lens' Bool TCEnv
    eCallByNeed Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envCallByNeed TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envCallByNeed :: Bool
    envCallByNeed = Bool
    x }

    eCurrentCheckpoint :: Lens' CheckpointId TCEnv
    eCurrentCheckpoint :: Lens' CheckpointId TCEnv
    eCurrentCheckpoint CheckpointId -> f CheckpointId
    f TCEnv
    e = CheckpointId -> f CheckpointId
    f (TCEnv -> CheckpointId
    envCurrentCheckpoint TCEnv
    e) f CheckpointId -> (CheckpointId -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ CheckpointId
    x -> TCEnv
    e { envCurrentCheckpoint :: CheckpointId
    envCurrentCheckpoint = CheckpointId
    x }

    eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv
    eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv
    eCheckpoints Map CheckpointId Substitution -> f (Map CheckpointId Substitution)
    f TCEnv
    e = Map CheckpointId Substitution -> f (Map CheckpointId Substitution)
    f (TCEnv -> Map CheckpointId Substitution
    envCheckpoints TCEnv
    e) f (Map CheckpointId Substitution)
    -> (Map CheckpointId Substitution -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Map CheckpointId Substitution
    x -> TCEnv
    e { envCheckpoints :: Map CheckpointId Substitution
    envCheckpoints = Map CheckpointId Substitution
    x }

    eGeneralizeMetas :: Lens' DoGeneralize TCEnv
    eGeneralizeMetas :: Lens' DoGeneralize TCEnv
    eGeneralizeMetas DoGeneralize -> f DoGeneralize
    f TCEnv
    e = DoGeneralize -> f DoGeneralize
    f (TCEnv -> DoGeneralize
    envGeneralizeMetas TCEnv
    e) f DoGeneralize -> (DoGeneralize -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ DoGeneralize
    x -> TCEnv
    e { envGeneralizeMetas :: DoGeneralize
    envGeneralizeMetas = DoGeneralize
    x }

    eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv
    eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv
    eGeneralizedVars Map QName GeneralizedValue -> f (Map QName GeneralizedValue)
    f TCEnv
    e = Map QName GeneralizedValue -> f (Map QName GeneralizedValue)
    f (TCEnv -> Map QName GeneralizedValue
    envGeneralizedVars TCEnv
    e) f (Map QName GeneralizedValue)
    -> (Map QName GeneralizedValue -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Map QName GeneralizedValue
    x -> TCEnv
    e { envGeneralizedVars :: Map QName GeneralizedValue
    envGeneralizedVars = Map QName GeneralizedValue
    x }

    eActiveBackendName :: Lens' (Maybe BackendName) TCEnv
    eActiveBackendName :: Lens' (Maybe String) TCEnv
    eActiveBackendName Maybe String -> f (Maybe String)
    f TCEnv
    e = Maybe String -> f (Maybe String)
    f (TCEnv -> Maybe String
    envActiveBackendName TCEnv
    e) f (Maybe String) -> (Maybe String -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Maybe String
    x -> TCEnv
    e { envActiveBackendName :: Maybe String
    envActiveBackendName = Maybe String
    x }

    eConflComputingOverlap :: Lens' Bool TCEnv
    eConflComputingOverlap :: Lens' Bool TCEnv
    eConflComputingOverlap Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envConflComputingOverlap TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envConflComputingOverlap :: Bool
    envConflComputingOverlap = Bool
    x }

    eCurrentlyElaborating :: Lens' Bool TCEnv
    eCurrentlyElaborating :: Lens' Bool TCEnv
    eCurrentlyElaborating Bool -> f Bool
    f TCEnv
    e = Bool -> f Bool
    f (TCEnv -> Bool
    envCurrentlyElaborating TCEnv
    e) f Bool -> (Bool -> TCEnv) -> f TCEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ Bool
    x -> TCEnv
    e { envCurrentlyElaborating :: Bool
    envCurrentlyElaborating = Bool
    x }

    ---------------------------------------------------------------------------
    -- ** Context
    ---------------------------------------------------------------------------

    -- | The @Context@ is a stack of 'ContextEntry's.
    type Context      = [ContextEntry]
    type ContextEntry = Dom (Name, Type)

    ---------------------------------------------------------------------------
    -- ** Let bindings
    ---------------------------------------------------------------------------

    type LetBindings = Map Name (Open (Term, Dom Type))

    ---------------------------------------------------------------------------
    -- ** Abstract mode
    ---------------------------------------------------------------------------

    data AbstractMode
      = AbstractMode        -- ^ Abstract things in the current module can be accessed.
      | ConcreteMode        -- ^ No abstract things can be accessed.
      | IgnoreAbstractMode  -- ^ All abstract things can be accessed.
      deriving (Typeable AbstractMode
    Typeable AbstractMode
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> AbstractMode -> c AbstractMode)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AbstractMode)
    -> (AbstractMode -> Constr)
    -> (AbstractMode -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AbstractMode))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AbstractMode))
    -> ((forall b. Data b => b -> b) -> AbstractMode -> AbstractMode)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AbstractMode -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AbstractMode -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode)
    -> Data AbstractMode
    AbstractMode -> DataType
    AbstractMode -> Constr
    (forall b. Data b => b -> b) -> AbstractMode -> AbstractMode
    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) -> AbstractMode -> u
    forall u. (forall d. Data d => d -> u) -> AbstractMode -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AbstractMode
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AbstractMode -> c AbstractMode
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AbstractMode)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AbstractMode)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AbstractMode -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AbstractMode -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AbstractMode -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AbstractMode -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r
    gmapT :: (forall b. Data b => b -> b) -> AbstractMode -> AbstractMode
    $cgmapT :: (forall b. Data b => b -> b) -> AbstractMode -> AbstractMode
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AbstractMode)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AbstractMode)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AbstractMode)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AbstractMode)
    dataTypeOf :: AbstractMode -> DataType
    $cdataTypeOf :: AbstractMode -> DataType
    toConstr :: AbstractMode -> Constr
    $ctoConstr :: AbstractMode -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AbstractMode
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AbstractMode
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AbstractMode -> c AbstractMode
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AbstractMode -> c AbstractMode
    Data, Int -> AbstractMode -> ShowS
    [AbstractMode] -> ShowS
    AbstractMode -> String
    (Int -> AbstractMode -> ShowS)
    -> (AbstractMode -> String)
    -> ([AbstractMode] -> ShowS)
    -> Show AbstractMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [AbstractMode] -> ShowS
    $cshowList :: [AbstractMode] -> ShowS
    show :: AbstractMode -> String
    $cshow :: AbstractMode -> String
    showsPrec :: Int -> AbstractMode -> ShowS
    $cshowsPrec :: Int -> AbstractMode -> ShowS
    Show, AbstractMode -> AbstractMode -> Bool
    (AbstractMode -> AbstractMode -> Bool)
    -> (AbstractMode -> AbstractMode -> Bool) -> Eq AbstractMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AbstractMode -> AbstractMode -> Bool
    $c/= :: AbstractMode -> AbstractMode -> Bool
    == :: AbstractMode -> AbstractMode -> Bool
    $c== :: AbstractMode -> AbstractMode -> Bool
    Eq, (forall x. AbstractMode -> Rep AbstractMode x)
    -> (forall x. Rep AbstractMode x -> AbstractMode)
    -> Generic AbstractMode
    forall x. Rep AbstractMode x -> AbstractMode
    forall x. AbstractMode -> Rep AbstractMode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AbstractMode x -> AbstractMode
    $cfrom :: forall x. AbstractMode -> Rep AbstractMode x
    Generic)

    aDefToMode :: IsAbstract -> AbstractMode
    aDefToMode :: IsAbstract -> AbstractMode
    aDefToMode IsAbstract
    AbstractDef = AbstractMode
    AbstractMode
    aDefToMode IsAbstract
    ConcreteDef = AbstractMode
    ConcreteMode

    aModeToDef :: AbstractMode -> Maybe IsAbstract
    aModeToDef :: AbstractMode -> Maybe IsAbstract
    aModeToDef AbstractMode
    AbstractMode = IsAbstract -> Maybe IsAbstract
    forall a. a -> Maybe a
    Just IsAbstract
    AbstractDef
    aModeToDef AbstractMode
    ConcreteMode = IsAbstract -> Maybe IsAbstract
    forall a. a -> Maybe a
    Just IsAbstract
    ConcreteDef
    aModeToDef AbstractMode
    _ = Maybe IsAbstract
    forall a. Maybe a
    Nothing

    ---------------------------------------------------------------------------
    -- ** Insertion of implicit arguments
    ---------------------------------------------------------------------------

    data ExpandHidden
      = ExpandLast      -- ^ Add implicit arguments in the end until type is no longer hidden 'Pi'.
      | DontExpandLast  -- ^ Do not append implicit arguments.
      | ReallyDontExpandLast -- ^ Makes 'doExpandLast' have no effect. Used to avoid implicit insertion of arguments to metavariables.
      deriving (ExpandHidden -> ExpandHidden -> Bool
    (ExpandHidden -> ExpandHidden -> Bool)
    -> (ExpandHidden -> ExpandHidden -> Bool) -> Eq ExpandHidden
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ExpandHidden -> ExpandHidden -> Bool
    $c/= :: ExpandHidden -> ExpandHidden -> Bool
    == :: ExpandHidden -> ExpandHidden -> Bool
    $c== :: ExpandHidden -> ExpandHidden -> Bool
    Eq, Typeable ExpandHidden
    Typeable ExpandHidden
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ExpandHidden -> c ExpandHidden)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ExpandHidden)
    -> (ExpandHidden -> Constr)
    -> (ExpandHidden -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ExpandHidden))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ExpandHidden))
    -> ((forall b. Data b => b -> b) -> ExpandHidden -> ExpandHidden)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ExpandHidden -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ExpandHidden -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden)
    -> Data ExpandHidden
    ExpandHidden -> DataType
    ExpandHidden -> Constr
    (forall b. Data b => b -> b) -> ExpandHidden -> ExpandHidden
    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) -> ExpandHidden -> u
    forall u. (forall d. Data d => d -> u) -> ExpandHidden -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExpandHidden
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExpandHidden -> c ExpandHidden
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExpandHidden)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ExpandHidden)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExpandHidden -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExpandHidden -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ExpandHidden -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExpandHidden -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r
    gmapT :: (forall b. Data b => b -> b) -> ExpandHidden -> ExpandHidden
    $cgmapT :: (forall b. Data b => b -> b) -> ExpandHidden -> ExpandHidden
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ExpandHidden)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ExpandHidden)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExpandHidden)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExpandHidden)
    dataTypeOf :: ExpandHidden -> DataType
    $cdataTypeOf :: ExpandHidden -> DataType
    toConstr :: ExpandHidden -> Constr
    $ctoConstr :: ExpandHidden -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExpandHidden
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExpandHidden
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExpandHidden -> c ExpandHidden
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExpandHidden -> c ExpandHidden
    Data, (forall x. ExpandHidden -> Rep ExpandHidden x)
    -> (forall x. Rep ExpandHidden x -> ExpandHidden)
    -> Generic ExpandHidden
    forall x. Rep ExpandHidden x -> ExpandHidden
    forall x. ExpandHidden -> Rep ExpandHidden x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep ExpandHidden x -> ExpandHidden
    $cfrom :: forall x. ExpandHidden -> Rep ExpandHidden x
    Generic)

    isDontExpandLast :: ExpandHidden -> Bool
    isDontExpandLast :: ExpandHidden -> Bool
    isDontExpandLast ExpandHidden
    ExpandLast           = Bool
    False
    isDontExpandLast ExpandHidden
    DontExpandLast       = Bool
    True
    isDontExpandLast ExpandHidden
    ReallyDontExpandLast = Bool
    True

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

    -- | A candidate solution for an instance meta is a term with its type.
    --   It may be the case that the candidate is not fully applied yet or
    --   of the wrong type, hence the need for the type.
    data Candidate  = Candidate { Candidate -> CandidateKind
    candidateKind :: CandidateKind
                                , Candidate -> Term
    candidateTerm :: Term
                                , Candidate -> Type
    candidateType :: Type
                                , Candidate -> Bool
    candidateOverlappable :: Bool
                                }
      deriving (Int -> Candidate -> ShowS
    [Candidate] -> ShowS
    Candidate -> String
    (Int -> Candidate -> ShowS)
    -> (Candidate -> String)
    -> ([Candidate] -> ShowS)
    -> Show Candidate
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Candidate] -> ShowS
    $cshowList :: [Candidate] -> ShowS
    show :: Candidate -> String
    $cshow :: Candidate -> String
    showsPrec :: Int -> Candidate -> ShowS
    $cshowsPrec :: Int -> Candidate -> ShowS
    Show, Typeable Candidate
    Typeable Candidate
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Candidate -> c Candidate)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Candidate)
    -> (Candidate -> Constr)
    -> (Candidate -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Candidate))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Candidate))
    -> ((forall b. Data b => b -> b) -> Candidate -> Candidate)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Candidate -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Candidate -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Candidate -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Candidate -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Candidate -> m Candidate)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Candidate -> m Candidate)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Candidate -> m Candidate)
    -> Data Candidate
    Candidate -> DataType
    Candidate -> Constr
    (forall b. Data b => b -> b) -> Candidate -> Candidate
    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) -> Candidate -> u
    forall u. (forall d. Data d => d -> u) -> Candidate -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Candidate -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Candidate -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Candidate -> m Candidate
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Candidate -> m Candidate
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Candidate
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Candidate -> c Candidate
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Candidate)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Candidate)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Candidate -> m Candidate
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Candidate -> m Candidate
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Candidate -> m Candidate
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Candidate -> m Candidate
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Candidate -> m Candidate
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Candidate -> m Candidate
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Candidate -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Candidate -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Candidate -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Candidate -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Candidate -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Candidate -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Candidate -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Candidate -> r
    gmapT :: (forall b. Data b => b -> b) -> Candidate -> Candidate
    $cgmapT :: (forall b. Data b => b -> b) -> Candidate -> Candidate
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Candidate)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Candidate)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Candidate)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Candidate)
    dataTypeOf :: Candidate -> DataType
    $cdataTypeOf :: Candidate -> DataType
    toConstr :: Candidate -> Constr
    $ctoConstr :: Candidate -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Candidate
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Candidate
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Candidate -> c Candidate
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Candidate -> c Candidate
    Data, (forall x. Candidate -> Rep Candidate x)
    -> (forall x. Rep Candidate x -> Candidate) -> Generic Candidate
    forall x. Rep Candidate x -> Candidate
    forall x. Candidate -> Rep Candidate x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Candidate x -> Candidate
    $cfrom :: forall x. Candidate -> Rep Candidate x
    Generic)

    instance Free Candidate where
      freeVars' :: forall a c. IsVarSet a c => Candidate -> FreeM a c
    freeVars' (Candidate CandidateKind
    _ Term
    t Type
    u Bool
    _) = (Term, Type) -> FreeM a c
    forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
    freeVars' (Term
    t, Type
    u)

    ---------------------------------------------------------------------------
    -- ** Checking arguments
    ---------------------------------------------------------------------------

    data ArgsCheckState a = ACState
           { forall a. ArgsCheckState a -> [Maybe Range]
    acRanges :: [Maybe Range]
             -- ^ Ranges of checked arguments, where present.
             -- e.g. inserted implicits have no correponding abstract syntax.
           , forall a. ArgsCheckState a -> [Elim]
    acElims  :: Elims
             -- ^ Checked and inserted arguments so far.
           , forall a. ArgsCheckState a -> [Maybe (Abs Constraint)]
    acConstraints :: [Maybe (Abs Constraint)]
             -- ^ Constraints for the head so far,
             -- i.e. before applying the correponding elim.
           , forall a. ArgsCheckState a -> Type
    acType   :: Type
             -- ^ Type for the rest of the application.
           , forall a. ArgsCheckState a -> a
    acData   :: a
           }
      deriving (Int -> ArgsCheckState a -> ShowS
    [ArgsCheckState a] -> ShowS
    ArgsCheckState a -> String
    (Int -> ArgsCheckState a -> ShowS)
    -> (ArgsCheckState a -> String)
    -> ([ArgsCheckState a] -> ShowS)
    -> Show (ArgsCheckState a)
    forall a. Show a => Int -> ArgsCheckState a -> ShowS
    forall a. Show a => [ArgsCheckState a] -> ShowS
    forall a. Show a => ArgsCheckState a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ArgsCheckState a] -> ShowS
    $cshowList :: forall a. Show a => [ArgsCheckState a] -> ShowS
    show :: ArgsCheckState a -> String
    $cshow :: forall a. Show a => ArgsCheckState a -> String
    showsPrec :: Int -> ArgsCheckState a -> ShowS
    $cshowsPrec :: forall a. Show a => Int -> ArgsCheckState a -> ShowS
    Show)

    ---------------------------------------------------------------------------
    -- * Type checking warnings (aka non-fatal errors)
    ---------------------------------------------------------------------------

    -- | A non-fatal error is an error which does not prevent us from
    -- checking the document further and interacting with the user.

    data Warning
      = NicifierIssue            DeclarationWarning
      | TerminationIssue         [TerminationError]
      | UnreachableClauses       QName [Range]
      -- ^ `UnreachableClauses f rs` means that the clauses in `f` whose ranges are rs
      --   are unreachable
      | CoverageIssue            QName [(Telescope, [NamedArg DeBruijnPattern])]
      -- ^ `CoverageIssue f pss` means that `pss` are not covered in `f`
      | CoverageNoExactSplit     QName [Clause]
      | NotStrictlyPositive      QName (Seq OccursWhere)
      | UnsolvedMetaVariables    [Range]  -- ^ Do not use directly with 'warning'
      | UnsolvedInteractionMetas [Range]  -- ^ Do not use directly with 'warning'
      | UnsolvedConstraints      Constraints
        -- ^ Do not use directly with 'warning'
      | CantGeneralizeOverSorts [MetaId]
      | AbsurdPatternRequiresNoRHS [NamedArg DeBruijnPattern]
      | OldBuiltin               String String
        -- ^ In `OldBuiltin old new`, the BUILTIN old has been replaced by new
      | EmptyRewritePragma
        -- ^ If the user wrote just @{-\# REWRITE \#-}@.
      | EmptyWhere
        -- ^ An empty @where@ block is dead code.
      | IllformedAsClause String
        -- ^ If the user wrote something other than an unqualified name
        --   in the @as@ clause of an @import@ statement.
        --   The 'String' gives optionally extra explanation.
      | ClashesViaRenaming NameOrModule [C.Name]
        -- ^ If a `renaming' import directive introduces a name or module name clash
        --   in the exported names of a module.
        --   (See issue #4154.)
      | UselessPatternDeclarationForRecord String
        -- ^ The 'pattern' declaration is useless in the presence
        --   of either @coinductive@ or @eta-equality@.
        --   Content of 'String' is "coinductive" or "eta", resp.
      | UselessPublic
        -- ^ If the user opens a module public before the module header.
        --   (See issue #2377.)
      | UselessHiding [C.ImportedName]
        -- ^ Names in `hiding` directive that don't hide anything
        --   imported by a `using` directive.
      | UselessInline            QName
      | WrongInstanceDeclaration
      | InstanceWithExplicitArg  QName
      -- ^ An instance was declared with an implicit argument, which means it
      --   will never actually be considered by instance search.
      | InstanceNoOutputTypeName Doc
      -- ^ The type of an instance argument doesn't end in a named or
      -- variable type, so it will never be considered by instance search.
      | InstanceArgWithExplicitArg Doc
      -- ^ As InstanceWithExplicitArg, but for local bindings rather than
      --   top-level instances.
      | InversionDepthReached    QName
      -- ^ The --inversion-max-depth was reached.
      | NoGuardednessFlag        QName
      -- ^ A coinductive record was declared but neither --guardedness nor
      --   --sized-types is enabled.

      -- Generic warnings for one-off things
      | GenericWarning           Doc
        -- ^ Harmless generic warning (not an error)
      | GenericNonFatalError     Doc
        -- ^ Generic error which doesn't abort proceedings (not a warning)
      | GenericUseless  Range    Doc
        -- ^ Generic warning when code is useless and thus ignored.
        --   'Range' is for dead code highlighting.

      -- Safe flag errors
      | SafeFlagPostulate C.Name
      | SafeFlagPragma [String]                -- ^ Unsafe OPTIONS.
      | SafeFlagNonTerminating
      | SafeFlagTerminating
      | SafeFlagWithoutKFlagPrimEraseEquality
      | WithoutKFlagPrimEraseEquality
      | SafeFlagNoPositivityCheck
      | SafeFlagPolarity
      | SafeFlagNoUniverseCheck
      | SafeFlagNoCoverageCheck
      | SafeFlagInjective
      | SafeFlagEta                            -- ^ ETA pragma is unsafe.
      | ParseWarning             ParseWarning
      | LibraryWarning           LibWarning
      | DeprecationWarning String String String
        -- ^ `DeprecationWarning old new version`:
        --   `old` is deprecated, use `new` instead. This will be an error in Agda `version`.
      | UserWarning Text
        -- ^ User-defined warning (e.g. to mention that a name is deprecated)
      | DuplicateUsing (List1 C.ImportedName)
        -- ^ Duplicate mentions of the same name in @using@ directive(s).
      | FixityInRenamingModule (List1 Range)
        -- ^ Fixity of modules cannot be changed via renaming (since modules have no fixity).
      | ModuleDoesntExport C.QName [C.Name] [C.Name] [C.ImportedName]
        -- ^ Some imported names are not actually exported by the source module.
        --   The second argument is the names that could be exported.
        --   The third  argument is the module names that could be exported.
      | InfectiveImport String ModuleName
        -- ^ Importing a file using an infective option into one which doesn't
      | CoInfectiveImport String ModuleName
        -- ^ Importing a file not using a coinfective option from one which does
      | RewriteNonConfluent Term Term Term Doc
        -- ^ Confluence checker found critical pair and equality checking
        --   resulted in a type error
      | RewriteMaybeNonConfluent Term Term [Doc]
        -- ^ Confluence checker got stuck on computing overlap between two
        --   rewrite rules
      | RewriteAmbiguousRules Term Term Term
        -- ^ The global confluence checker found a term @u@ that reduces
        --   to both @v1@ and @v2@ and there is no rule to resolve the
        --   ambiguity.
      | RewriteMissingRule Term Term Term
        -- ^ The global confluence checker found a term @u@ that reduces
        --   to @v@, but @v@ does not reduce to @rho(u)@.
      | PragmaCompileErased BackendName QName
        -- ^ COMPILE directive for an erased symbol
      | NotInScopeW [C.QName]
        -- ^ Out of scope error we can recover from
      | AsPatternShadowsConstructorOrPatternSynonym Bool
        -- ^ The as-name in an as-pattern may not shadow a constructor (@False@)
        --   or pattern synonym name (@True@),
        --   because this can be confusing to read.
      | RecordFieldWarning RecordFieldWarning
      deriving (Int -> Warning -> ShowS
    [Warning] -> ShowS
    Warning -> String
    (Int -> Warning -> ShowS)
    -> (Warning -> String) -> ([Warning] -> ShowS) -> Show Warning
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Warning] -> ShowS
    $cshowList :: [Warning] -> ShowS
    show :: Warning -> String
    $cshow :: Warning -> String
    showsPrec :: Int -> Warning -> ShowS
    $cshowsPrec :: Int -> Warning -> ShowS
    Show, (forall x. Warning -> Rep Warning x)
    -> (forall x. Rep Warning x -> Warning) -> Generic Warning
    forall x. Rep Warning x -> Warning
    forall x. Warning -> Rep Warning x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Warning x -> Warning
    $cfrom :: forall x. Warning -> Rep Warning x
    Generic)

    data RecordFieldWarning
      = DuplicateFieldsWarning [(C.Name, Range)]
          -- ^ Each redundant field comes with a range of associated dead code.
      | TooManyFieldsWarning QName [C.Name] [(C.Name, Range)]
          -- ^ Record type, fields not supplied by user, non-fields but supplied.
          --   The redundant fields come with a range of associated dead code.
      deriving (Int -> RecordFieldWarning -> ShowS
    [RecordFieldWarning] -> ShowS
    RecordFieldWarning -> String
    (Int -> RecordFieldWarning -> ShowS)
    -> (RecordFieldWarning -> String)
    -> ([RecordFieldWarning] -> ShowS)
    -> Show RecordFieldWarning
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [RecordFieldWarning] -> ShowS
    $cshowList :: [RecordFieldWarning] -> ShowS
    show :: RecordFieldWarning -> String
    $cshow :: RecordFieldWarning -> String
    showsPrec :: Int -> RecordFieldWarning -> ShowS
    $cshowsPrec :: Int -> RecordFieldWarning -> ShowS
    Show, Typeable RecordFieldWarning
    Typeable RecordFieldWarning
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g)
        -> RecordFieldWarning
        -> c RecordFieldWarning)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c RecordFieldWarning)
    -> (RecordFieldWarning -> Constr)
    -> (RecordFieldWarning -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c RecordFieldWarning))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c RecordFieldWarning))
    -> ((forall b. Data b => b -> b)
        -> RecordFieldWarning -> RecordFieldWarning)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> RecordFieldWarning -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> RecordFieldWarning -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> RecordFieldWarning -> m RecordFieldWarning)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> RecordFieldWarning -> m RecordFieldWarning)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> RecordFieldWarning -> m RecordFieldWarning)
    -> Data RecordFieldWarning
    RecordFieldWarning -> DataType
    RecordFieldWarning -> Constr
    (forall b. Data b => b -> b)
    -> RecordFieldWarning -> RecordFieldWarning
    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) -> RecordFieldWarning -> u
    forall u. (forall d. Data d => d -> u) -> RecordFieldWarning -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RecordFieldWarning -> m RecordFieldWarning
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RecordFieldWarning -> m RecordFieldWarning
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RecordFieldWarning
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> RecordFieldWarning
    -> c RecordFieldWarning
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RecordFieldWarning)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RecordFieldWarning)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RecordFieldWarning -> m RecordFieldWarning
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RecordFieldWarning -> m RecordFieldWarning
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RecordFieldWarning -> m RecordFieldWarning
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RecordFieldWarning -> m RecordFieldWarning
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RecordFieldWarning -> m RecordFieldWarning
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RecordFieldWarning -> m RecordFieldWarning
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> RecordFieldWarning -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> RecordFieldWarning -> u
    gmapQ :: forall u. (forall d. Data d => d -> u) -> RecordFieldWarning -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> RecordFieldWarning -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r
    gmapT :: (forall b. Data b => b -> b)
    -> RecordFieldWarning -> RecordFieldWarning
    $cgmapT :: (forall b. Data b => b -> b)
    -> RecordFieldWarning -> RecordFieldWarning
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RecordFieldWarning)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RecordFieldWarning)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RecordFieldWarning)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RecordFieldWarning)
    dataTypeOf :: RecordFieldWarning -> DataType
    $cdataTypeOf :: RecordFieldWarning -> DataType
    toConstr :: RecordFieldWarning -> Constr
    $ctoConstr :: RecordFieldWarning -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RecordFieldWarning
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RecordFieldWarning
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> RecordFieldWarning
    -> c RecordFieldWarning
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> RecordFieldWarning
    -> c RecordFieldWarning
    Data, (forall x. RecordFieldWarning -> Rep RecordFieldWarning x)
    -> (forall x. Rep RecordFieldWarning x -> RecordFieldWarning)
    -> Generic RecordFieldWarning
    forall x. Rep RecordFieldWarning x -> RecordFieldWarning
    forall x. RecordFieldWarning -> Rep RecordFieldWarning x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep RecordFieldWarning x -> RecordFieldWarning
    $cfrom :: forall x. RecordFieldWarning -> Rep RecordFieldWarning x
    Generic)

    recordFieldWarningToError :: RecordFieldWarning -> TypeError
    recordFieldWarningToError :: RecordFieldWarning -> TypeError
    recordFieldWarningToError = \case
      DuplicateFieldsWarning    [(Name, Range)]
    xrs -> [Name] -> TypeError
    DuplicateFields    ([Name] -> TypeError) -> [Name] -> TypeError
    forall a b. (a -> b) -> a -> b
    $ ((Name, Range) -> Name) -> [(Name, Range)] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map (Name, Range) -> Name
    forall a b. (a, b) -> a
    fst [(Name, Range)]
    xrs
      TooManyFieldsWarning QName
    q [Name]
    ys [(Name, Range)]
    xrs -> QName -> [Name] -> [Name] -> TypeError
    TooManyFields QName
    q [Name]
    ys ([Name] -> TypeError) -> [Name] -> TypeError
    forall a b. (a -> b) -> a -> b
    $ ((Name, Range) -> Name) -> [(Name, Range)] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map (Name, Range) -> Name
    forall a b. (a, b) -> a
    fst [(Name, Range)]
    xrs

    warningName :: Warning -> WarningName
    warningName :: Warning -> WarningName
    warningName = \case
      -- special cases
      NicifierIssue DeclarationWarning
    dw             -> DeclarationWarning -> WarningName
    declarationWarningName DeclarationWarning
    dw
      ParseWarning ParseWarning
    pw              -> ParseWarning -> WarningName
    parseWarningName ParseWarning
    pw
      LibraryWarning LibWarning
    lw            -> LibWarning -> WarningName
    libraryWarningName LibWarning
    lw
      AsPatternShadowsConstructorOrPatternSynonym{} -> WarningName
    AsPatternShadowsConstructorOrPatternSynonym_
      -- scope- and type-checking errors
      AbsurdPatternRequiresNoRHS{} -> WarningName
    AbsurdPatternRequiresNoRHS_
      CantGeneralizeOverSorts{}    -> WarningName
    CantGeneralizeOverSorts_
      CoverageIssue{}              -> WarningName
    CoverageIssue_
      CoverageNoExactSplit{}       -> WarningName
    CoverageNoExactSplit_
      DeprecationWarning{}         -> WarningName
    DeprecationWarning_
      Warning
    EmptyRewritePragma           -> WarningName
    EmptyRewritePragma_
      Warning
    EmptyWhere                   -> WarningName
    EmptyWhere_
      IllformedAsClause{}          -> WarningName
    IllformedAsClause_
      WrongInstanceDeclaration{}   -> WarningName
    WrongInstanceDeclaration_
      InstanceWithExplicitArg{}    -> WarningName
    InstanceWithExplicitArg_
      InstanceNoOutputTypeName{}   -> WarningName
    InstanceNoOutputTypeName_
      InstanceArgWithExplicitArg{} -> WarningName
    InstanceArgWithExplicitArg_
      DuplicateUsing{}             -> WarningName
    DuplicateUsing_
      FixityInRenamingModule{}     -> WarningName
    FixityInRenamingModule_
      GenericNonFatalError{}       -> WarningName
    GenericNonFatalError_
      GenericUseless{}             -> WarningName
    GenericUseless_
      GenericWarning{}             -> WarningName
    GenericWarning_
      InversionDepthReached{}      -> WarningName
    InversionDepthReached_
      ModuleDoesntExport{}         -> WarningName
    ModuleDoesntExport_
      NoGuardednessFlag{}          -> WarningName
    NoGuardednessFlag_
      NotInScopeW{}                -> WarningName
    NotInScope_
      NotStrictlyPositive{}        -> WarningName
    NotStrictlyPositive_
      OldBuiltin{}                 -> WarningName
    OldBuiltin_
      Warning
    SafeFlagNoPositivityCheck    -> WarningName
    SafeFlagNoPositivityCheck_
      Warning
    SafeFlagNonTerminating       -> WarningName
    SafeFlagNonTerminating_
      Warning
    SafeFlagNoUniverseCheck      -> WarningName
    SafeFlagNoUniverseCheck_
      Warning
    SafeFlagPolarity             -> WarningName
    SafeFlagPolarity_
      SafeFlagPostulate{}          -> WarningName
    SafeFlagPostulate_
      SafeFlagPragma{}             -> WarningName
    SafeFlagPragma_
      Warning
    SafeFlagEta                  -> WarningName
    SafeFlagEta_
      Warning
    SafeFlagInjective            -> WarningName
    SafeFlagInjective_
      Warning
    SafeFlagNoCoverageCheck      -> WarningName
    SafeFlagNoCoverageCheck_
      Warning
    SafeFlagWithoutKFlagPrimEraseEquality -> WarningName
    SafeFlagWithoutKFlagPrimEraseEquality_
      Warning
    WithoutKFlagPrimEraseEquality -> WarningName
    WithoutKFlagPrimEraseEquality_
      Warning
    SafeFlagTerminating          -> WarningName
    SafeFlagTerminating_
      TerminationIssue{}           -> WarningName
    TerminationIssue_
      UnreachableClauses{}         -> WarningName
    UnreachableClauses_
      UnsolvedInteractionMetas{}   -> WarningName
    UnsolvedInteractionMetas_
      UnsolvedConstraints{}        -> WarningName
    UnsolvedConstraints_
      UnsolvedMetaVariables{}      -> WarningName
    UnsolvedMetaVariables_
      UselessHiding{}              -> WarningName
    UselessHiding_
      UselessInline{}              -> WarningName
    UselessInline_
      UselessPublic{}              -> WarningName
    UselessPublic_
      UselessPatternDeclarationForRecord{} -> WarningName
    UselessPatternDeclarationForRecord_
      ClashesViaRenaming{}         -> WarningName
    ClashesViaRenaming_
      UserWarning{}                -> WarningName
    UserWarning_
      InfectiveImport{}            -> WarningName
    InfectiveImport_
      CoInfectiveImport{}          -> WarningName
    CoInfectiveImport_
      RewriteNonConfluent{}        -> WarningName
    RewriteNonConfluent_
      RewriteMaybeNonConfluent{}   -> WarningName
    RewriteMaybeNonConfluent_
      RewriteAmbiguousRules{}      -> WarningName
    RewriteAmbiguousRules_
      RewriteMissingRule{}         -> WarningName
    RewriteMissingRule_
      PragmaCompileErased{}        -> WarningName
    PragmaCompileErased_
      -- record field warnings
      RecordFieldWarning RecordFieldWarning
    w -> case RecordFieldWarning
    w of
        DuplicateFieldsWarning{}   -> WarningName
    DuplicateFieldsWarning_
        TooManyFieldsWarning{}     -> WarningName
    TooManyFieldsWarning_

    data TCWarning
      = TCWarning
        { TCWarning -> CallStack
    tcWarningLocation :: CallStack
            -- ^ Location in the internal Agda source code location where the error raised
        , TCWarning -> Range
    tcWarningRange    :: Range
            -- ^ Range where the warning was raised
        , TCWarning -> Warning
    tcWarning         :: Warning
            -- ^ The warning itself
        , TCWarning -> Doc
    tcWarningPrintedWarning :: Doc
            -- ^ The warning printed in the state and environment where it was raised
        , TCWarning -> Bool
    tcWarningCached :: Bool
            -- ^ Should the warning be affected by caching.
        }
      deriving (Int -> TCWarning -> ShowS
    [TCWarning] -> ShowS
    TCWarning -> String
    (Int -> TCWarning -> ShowS)
    -> (TCWarning -> String)
    -> ([TCWarning] -> ShowS)
    -> Show TCWarning
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [TCWarning] -> ShowS
    $cshowList :: [TCWarning] -> ShowS
    show :: TCWarning -> String
    $cshow :: TCWarning -> String
    showsPrec :: Int -> TCWarning -> ShowS
    $cshowsPrec :: Int -> TCWarning -> ShowS
    Show, (forall x. TCWarning -> Rep TCWarning x)
    -> (forall x. Rep TCWarning x -> TCWarning) -> Generic TCWarning
    forall x. Rep TCWarning x -> TCWarning
    forall x. TCWarning -> Rep TCWarning x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TCWarning x -> TCWarning
    $cfrom :: forall x. TCWarning -> Rep TCWarning x
    Generic)

    tcWarningOrigin :: TCWarning -> SrcFile
    tcWarningOrigin :: TCWarning -> Maybe AbsolutePath
    tcWarningOrigin = Range -> Maybe AbsolutePath
    rangeFile (Range -> Maybe AbsolutePath)
    -> (TCWarning -> Range) -> TCWarning -> Maybe AbsolutePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCWarning -> Range
    tcWarningRange

    instance HasRange TCWarning where
      getRange :: TCWarning -> Range
    getRange = TCWarning -> Range
    tcWarningRange

    -- used for merging lists of warnings
    instance Eq TCWarning where
      == :: TCWarning -> TCWarning -> Bool
    (==) = Doc -> Doc -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) (Doc -> Doc -> Bool)
    -> (TCWarning -> Doc) -> TCWarning -> TCWarning -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` TCWarning -> Doc
    tcWarningPrintedWarning

    ---------------------------------------------------------------------------
    -- * Type checking errors
    ---------------------------------------------------------------------------

    -- | Information about a call.

    data CallInfo = CallInfo
      { CallInfo -> QName
    callInfoTarget :: QName
        -- ^ Target function name.
      , CallInfo -> Range
    callInfoRange :: Range
        -- ^ Range of the target function.
      , CallInfo -> Closure Term
    callInfoCall :: Closure Term
        -- ^ To be formatted representation of the call.
      } deriving (Int -> CallInfo -> ShowS
    [CallInfo] -> ShowS
    CallInfo -> String
    (Int -> CallInfo -> ShowS)
    -> (CallInfo -> String) -> ([CallInfo] -> ShowS) -> Show CallInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [CallInfo] -> ShowS
    $cshowList :: [CallInfo] -> ShowS
    show :: CallInfo -> String
    $cshow :: CallInfo -> String
    showsPrec :: Int -> CallInfo -> ShowS
    $cshowsPrec :: Int -> CallInfo -> ShowS
    Show, (forall x. CallInfo -> Rep CallInfo x)
    -> (forall x. Rep CallInfo x -> CallInfo) -> Generic CallInfo
    forall x. Rep CallInfo x -> CallInfo
    forall x. CallInfo -> Rep CallInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep CallInfo x -> CallInfo
    $cfrom :: forall x. CallInfo -> Rep CallInfo x
    Generic)
        -- no Eq, Ord instances: too expensive! (see issues 851, 852)

    -- | We only 'show' the name of the callee.
    instance Pretty CallInfo where pretty :: CallInfo -> Doc
    pretty = QName -> Doc
    forall a. Pretty a => a -> Doc
    pretty (QName -> Doc) -> (CallInfo -> QName) -> CallInfo -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CallInfo -> QName
    callInfoTarget

    -- | Information about a mutual block which did not pass the
    -- termination checker.

    data TerminationError = TerminationError
      { TerminationError -> [QName]
    termErrFunctions :: [QName]
        -- ^ The functions which failed to check. (May not include
        -- automatically generated functions.)
      , TerminationError -> [CallInfo]
    termErrCalls :: [CallInfo]
        -- ^ The problematic call sites.
      } deriving (Int -> TerminationError -> ShowS
    [TerminationError] -> ShowS
    TerminationError -> String
    (Int -> TerminationError -> ShowS)
    -> (TerminationError -> String)
    -> ([TerminationError] -> ShowS)
    -> Show TerminationError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [TerminationError] -> ShowS
    $cshowList :: [TerminationError] -> ShowS
    show :: TerminationError -> String
    $cshow :: TerminationError -> String
    showsPrec :: Int -> TerminationError -> ShowS
    $cshowsPrec :: Int -> TerminationError -> ShowS
    Show, (forall x. TerminationError -> Rep TerminationError x)
    -> (forall x. Rep TerminationError x -> TerminationError)
    -> Generic TerminationError
    forall x. Rep TerminationError x -> TerminationError
    forall x. TerminationError -> Rep TerminationError x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TerminationError x -> TerminationError
    $cfrom :: forall x. TerminationError -> Rep TerminationError x
    Generic)

    -- | Error when splitting a pattern variable into possible constructor patterns.
    data SplitError
      = NotADatatype        (Closure Type)  -- ^ Neither data type nor record.
      | BlockedType Blocker (Closure Type)  -- ^ Type could not be sufficiently reduced.
      | ErasedDatatype Bool (Closure Type)  -- ^ Data type, but in erased position.
                                            --   If the boolean is 'True',
                                            --   then the reason for the
                                            --   error is that the K rule
                                            --   is turned off.
      | CoinductiveDatatype (Closure Type)  -- ^ Split on codata not allowed.
      -- UNUSED, but keep!
      -- -- | NoRecordConstructor Type  -- ^ record type, but no constructor
      | UnificationStuck
        { SplitError -> Maybe Blocker
    cantSplitBlocker  :: Maybe Blocker -- ^ Blocking metavariable (if any)
        , SplitError -> QName
    cantSplitConName  :: QName        -- ^ Constructor.
        , SplitError -> Telescope
    cantSplitTel      :: Telescope    -- ^ Context for indices.
        , SplitError -> [Arg Term]
    cantSplitConIdx   :: Args         -- ^ Inferred indices (from type of constructor).
        , SplitError -> [Arg Term]
    cantSplitGivenIdx :: Args         -- ^ Expected indices (from checking pattern).
        , SplitError -> [UnificationFailure]
    cantSplitFailures :: [UnificationFailure] -- ^ Reason(s) why unification got stuck.
        }
      | CosplitCatchall
          -- ^ Copattern split with a catchall
      | CosplitNoTarget
          -- ^ We do not know the target type of the clause.
      | CosplitNoRecordType (Closure Type)
          -- ^ Target type is not a record type.
      | CannotCreateMissingClause QName (Telescope,[NamedArg DeBruijnPattern]) Doc (Closure (Abs Type))

      | GenericSplitError String
      deriving (Int -> SplitError -> ShowS
    [SplitError] -> ShowS
    SplitError -> String
    (Int -> SplitError -> ShowS)
    -> (SplitError -> String)
    -> ([SplitError] -> ShowS)
    -> Show SplitError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [SplitError] -> ShowS
    $cshowList :: [SplitError] -> ShowS
    show :: SplitError -> String
    $cshow :: SplitError -> String
    showsPrec :: Int -> SplitError -> ShowS
    $cshowsPrec :: Int -> SplitError -> ShowS
    Show, (forall x. SplitError -> Rep SplitError x)
    -> (forall x. Rep SplitError x -> SplitError) -> Generic SplitError
    forall x. Rep SplitError x -> SplitError
    forall x. SplitError -> Rep SplitError x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep SplitError x -> SplitError
    $cfrom :: forall x. SplitError -> Rep SplitError x
    Generic)

    data NegativeUnification
      = UnifyConflict Telescope Term Term
      | UnifyCycle Telescope Int Term
      deriving (Int -> NegativeUnification -> ShowS
    [NegativeUnification] -> ShowS
    NegativeUnification -> String
    (Int -> NegativeUnification -> ShowS)
    -> (NegativeUnification -> String)
    -> ([NegativeUnification] -> ShowS)
    -> Show NegativeUnification
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [NegativeUnification] -> ShowS
    $cshowList :: [NegativeUnification] -> ShowS
    show :: NegativeUnification -> String
    $cshow :: NegativeUnification -> String
    showsPrec :: Int -> NegativeUnification -> ShowS
    $cshowsPrec :: Int -> NegativeUnification -> ShowS
    Show, (forall x. NegativeUnification -> Rep NegativeUnification x)
    -> (forall x. Rep NegativeUnification x -> NegativeUnification)
    -> Generic NegativeUnification
    forall x. Rep NegativeUnification x -> NegativeUnification
    forall x. NegativeUnification -> Rep NegativeUnification x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep NegativeUnification x -> NegativeUnification
    $cfrom :: forall x. NegativeUnification -> Rep NegativeUnification x
    Generic)

    data UnificationFailure
      = UnifyIndicesNotVars Telescope Type Term Term Args -- ^ Failed to apply injectivity to constructor of indexed datatype
      | UnifyRecursiveEq Telescope Type Int Term          -- ^ Can't solve equation because variable occurs in (type of) lhs
      | UnifyReflexiveEq Telescope Type Term              -- ^ Can't solve reflexive equation because --without-K is enabled
      | UnifyUnusableModality Telescope Type Int Term Modality  -- ^ Can't solve equation because solution modality is less "usable"
      deriving (Int -> UnificationFailure -> ShowS
    [UnificationFailure] -> ShowS
    UnificationFailure -> String
    (Int -> UnificationFailure -> ShowS)
    -> (UnificationFailure -> String)
    -> ([UnificationFailure] -> ShowS)
    -> Show UnificationFailure
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [UnificationFailure] -> ShowS
    $cshowList :: [UnificationFailure] -> ShowS
    show :: UnificationFailure -> String
    $cshow :: UnificationFailure -> String
    showsPrec :: Int -> UnificationFailure -> ShowS
    $cshowsPrec :: Int -> UnificationFailure -> ShowS
    Show, (forall x. UnificationFailure -> Rep UnificationFailure x)
    -> (forall x. Rep UnificationFailure x -> UnificationFailure)
    -> Generic UnificationFailure
    forall x. Rep UnificationFailure x -> UnificationFailure
    forall x. UnificationFailure -> Rep UnificationFailure x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep UnificationFailure x -> UnificationFailure
    $cfrom :: forall x. UnificationFailure -> Rep UnificationFailure x
    Generic)

    data UnquoteError
      = BadVisibility String (Arg I.Term)
      | ConInsteadOfDef QName String String
      | DefInsteadOfCon QName String String
      | NonCanonical String I.Term
      | BlockedOnMeta TCState Blocker
      | UnquotePanic String
      deriving (Int -> UnquoteError -> ShowS
    [UnquoteError] -> ShowS
    UnquoteError -> String
    (Int -> UnquoteError -> ShowS)
    -> (UnquoteError -> String)
    -> ([UnquoteError] -> ShowS)
    -> Show UnquoteError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [UnquoteError] -> ShowS
    $cshowList :: [UnquoteError] -> ShowS
    show :: UnquoteError -> String
    $cshow :: UnquoteError -> String
    showsPrec :: Int -> UnquoteError -> ShowS
    $cshowsPrec :: Int -> UnquoteError -> ShowS
    Show, (forall x. UnquoteError -> Rep UnquoteError x)
    -> (forall x. Rep UnquoteError x -> UnquoteError)
    -> Generic UnquoteError
    forall x. Rep UnquoteError x -> UnquoteError
    forall x. UnquoteError -> Rep UnquoteError x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep UnquoteError x -> UnquoteError
    $cfrom :: forall x. UnquoteError -> Rep UnquoteError x
    Generic)

    data TypeError
            = InternalError String
            | NotImplemented String
            | NotSupported String
            | CompilationError String
            | PropMustBeSingleton
            | DataMustEndInSort Term
    {- UNUSED
            | DataTooManyParameters
                -- ^ In @data D xs where@ the number of parameters @xs@ does not fit the
                --   the parameters given in the forward declaraion @data D Gamma : T@.
    -}
            | ShouldEndInApplicationOfTheDatatype Type
                -- ^ The target of a constructor isn't an application of its
                -- datatype. The 'Type' records what it does target.
            | ShouldBeAppliedToTheDatatypeParameters Term Term
                -- ^ The target of a constructor isn't its datatype applied to
                --   something that isn't the parameters. First term is the correct
                --   target and the second term is the actual target.
            | ShouldBeApplicationOf Type QName
                -- ^ Expected a type to be an application of a particular datatype.
            | ConstructorPatternInWrongDatatype QName QName -- ^ constructor, datatype
            | CantResolveOverloadedConstructorsTargetingSameDatatype QName (List1 QName)
              -- ^ Datatype, constructors.
            | DoesNotConstructAnElementOf QName Type -- ^ constructor, type
            | WrongHidingInLHS
                -- ^ The left hand side of a function definition has a hidden argument
                --   where a non-hidden was expected.
            | WrongHidingInLambda Type
                -- ^ Expected a non-hidden function and found a hidden lambda.
            | WrongHidingInApplication Type
                -- ^ A function is applied to a hidden argument where a non-hidden was expected.
            | WrongNamedArgument (NamedArg A.Expr) [NamedName]
                -- ^ A function is applied to a hidden named argument it does not have.
                -- The list contains names of possible hidden arguments at this point.
            | WrongIrrelevanceInLambda
                -- ^ Wrong user-given relevance annotation in lambda.
            | WrongQuantityInLambda
                -- ^ Wrong user-given quantity annotation in lambda.
            | WrongCohesionInLambda
                -- ^ Wrong user-given cohesion annotation in lambda.
            | QuantityMismatch Quantity Quantity
                -- ^ The given quantity does not correspond to the expected quantity.
            | HidingMismatch Hiding Hiding
                -- ^ The given hiding does not correspond to the expected hiding.
            | RelevanceMismatch Relevance Relevance
                -- ^ The given relevance does not correspond to the expected relevane.
            | UninstantiatedDotPattern A.Expr
            | ForcedConstructorNotInstantiated A.Pattern
            | IllformedProjectionPattern A.Pattern
            | CannotEliminateWithPattern (Maybe Blocker) (NamedArg A.Pattern) Type
            | WrongNumberOfConstructorArguments QName Nat Nat
            | ShouldBeEmpty Type [DeBruijnPattern]
            | ShouldBeASort Type
                -- ^ The given type should have been a sort.
            | ShouldBePi Type
                -- ^ The given type should have been a pi.
            | ShouldBePath Type
            | ShouldBeRecordType Type
            | ShouldBeRecordPattern DeBruijnPattern
            | NotAProjectionPattern (NamedArg A.Pattern)
            | NotAProperTerm
            | InvalidTypeSort Sort
                -- ^ This sort is not a type expression.
            | InvalidType Term
                -- ^ This term is not a type expression.
            | FunctionTypeInSizeUniv Term
                -- ^ This term, a function type constructor, lives in
                --   @SizeUniv@, which is not allowed.
            | SplitOnIrrelevant (Dom Type)
            | SplitOnUnusableCohesion (Dom Type)
            -- UNUSED: -- | SplitOnErased (Dom Type)
            | SplitOnNonVariable Term Type
            | SplitOnNonEtaRecord QName
            | DefinitionIsIrrelevant QName
            | DefinitionIsErased QName
            | VariableIsIrrelevant Name
            | VariableIsErased Name
            | VariableIsOfUnusableCohesion Name Cohesion
            | UnequalLevel Comparison Level Level
            | UnequalTerms Comparison Term Term CompareAs
            | UnequalTypes Comparison Type Type
    --      | UnequalTelescopes Comparison Telescope Telescope -- UNUSED
            | UnequalRelevance Comparison Term Term
                -- ^ The two function types have different relevance.
            | UnequalQuantity Comparison Term Term
                -- ^ The two function types have different relevance.
            | UnequalCohesion Comparison Term Term
                -- ^ The two function types have different cohesion.
            | UnequalHiding Term Term
                -- ^ The two function types have different hiding.
            | UnequalSorts Sort Sort
            | UnequalBecauseOfUniverseConflict Comparison Term Term
            | NotLeqSort Sort Sort
            | MetaCannotDependOn MetaId Nat
                -- ^ The arguments are the meta variable and the parameter that it wants to depend on.
            | MetaOccursInItself MetaId
            | MetaIrrelevantSolution MetaId Term
            | MetaErasedSolution MetaId Term
            | GenericError String
            | GenericDocError Doc
            | SortOfSplitVarError (Maybe Blocker) Doc
              -- ^ the meta is what we might be blocked on.
            | BuiltinMustBeConstructor String A.Expr
            | NoSuchBuiltinName String
            | DuplicateBuiltinBinding String Term Term
            | NoBindingForBuiltin String
            | NoSuchPrimitiveFunction String
            | DuplicatePrimitiveBinding String QName QName
            | WrongModalityForPrimitive String ArgInfo ArgInfo
            | ShadowedModule C.Name [A.ModuleName]
            | BuiltinInParameterisedModule String
            | IllegalLetInTelescope C.TypedBinding
            | IllegalPatternInTelescope C.Binder
            | NoRHSRequiresAbsurdPattern [NamedArg A.Pattern]
            | TooManyFields QName [C.Name] [C.Name]
              -- ^ Record type, fields not supplied by user, non-fields but supplied.
            | DuplicateFields [C.Name]
            | DuplicateConstructors [C.Name]
            | WithOnFreeVariable A.Expr Term
            | UnexpectedWithPatterns [A.Pattern]
            | WithClausePatternMismatch A.Pattern (NamedArg DeBruijnPattern)
            | FieldOutsideRecord
            | ModuleArityMismatch A.ModuleName Telescope [NamedArg A.Expr]
            | GeneralizeCyclicDependency
            | GeneralizeUnsolvedMeta
        -- Coverage errors
    -- UNUSED:        | IncompletePatternMatching Term [Elim] -- can only happen if coverage checking is switched off
            | SplitError SplitError
            | ImpossibleConstructor QName NegativeUnification
        -- Positivity errors
            | TooManyPolarities QName Int
        -- Import errors
            | LocalVsImportedModuleClash ModuleName
            | SolvedButOpenHoles
              -- ^ Some interaction points (holes) have not been filled by user.
              --   There are not 'UnsolvedMetas' since unification solved them.
              --   This is an error, since interaction points are never filled
              --   without user interaction.
            | CyclicModuleDependency [C.TopLevelModuleName]
            | FileNotFound C.TopLevelModuleName [AbsolutePath]
            | OverlappingProjects AbsolutePath C.TopLevelModuleName C.TopLevelModuleName
            | AmbiguousTopLevelModuleName C.TopLevelModuleName [AbsolutePath]
            | ModuleNameUnexpected C.TopLevelModuleName C.TopLevelModuleName
              -- ^ Found module name, expected module name.
            | ModuleNameDoesntMatchFileName C.TopLevelModuleName [AbsolutePath]
            | ClashingFileNamesFor ModuleName [AbsolutePath]
            | ModuleDefinedInOtherFile C.TopLevelModuleName AbsolutePath AbsolutePath
              -- ^ Module name, file from which it was loaded, file which
              -- the include path says contains the module.
        -- Scope errors
            | BothWithAndRHS
            | AbstractConstructorNotInScope A.QName
            | NotInScope [C.QName]
            | NoSuchModule C.QName
            | AmbiguousName C.QName (List1 A.QName)
            | AmbiguousModule C.QName (List1 A.ModuleName)
            | ClashingDefinition C.QName A.QName (Maybe NiceDeclaration)
            | ClashingModule A.ModuleName A.ModuleName
            | ClashingImport C.Name A.QName
            | ClashingModuleImport C.Name A.ModuleName
            | PatternShadowsConstructor C.Name A.QName
            | DuplicateImports C.QName [C.ImportedName]
            | InvalidPattern C.Pattern
            | RepeatedVariablesInPattern [C.Name]
            | GeneralizeNotSupportedHere A.QName
            | MultipleFixityDecls [(C.Name, [Fixity'])]
            | MultiplePolarityPragmas [C.Name]
        -- Concrete to Abstract errors
            | NotAModuleExpr C.Expr
                -- ^ The expr was used in the right hand side of an implicit module
                --   definition, but it wasn't of the form @m Delta@.
            | NotAnExpression C.Expr
            | NotAValidLetBinding NiceDeclaration
            | NotValidBeforeField NiceDeclaration
            | NothingAppliedToHiddenArg C.Expr
            | NothingAppliedToInstanceArg C.Expr
        -- Pattern synonym errors
            | BadArgumentsToPatternSynonym A.AmbiguousQName
            | TooFewArgumentsToPatternSynonym A.AmbiguousQName
            | CannotResolveAmbiguousPatternSynonym (List1 (A.QName, A.PatternSynDefn))
            | UnusedVariableInPatternSynonym
        -- Operator errors
            | NoParseForApplication (List2 C.Expr)
            | AmbiguousParseForApplication (List2 C.Expr) (List1 C.Expr)
            | NoParseForLHS LHSOrPatSyn [C.Pattern] C.Pattern
                -- ^ The list contains patterns that failed to be interpreted.
                --   If it is non-empty, the first entry could be printed as error hint.
            | AmbiguousParseForLHS LHSOrPatSyn C.Pattern [C.Pattern]
                -- ^ Pattern and its possible interpretations.
            | OperatorInformation [NotationSection] TypeError
    {- UNUSED
            | NoParseForPatternSynonym C.Pattern
            | AmbiguousParseForPatternSynonym C.Pattern [C.Pattern]
    -}
        -- Usage errors
        -- Instance search errors
            | InstanceNoCandidate Type [(Term, TCErr)]
        -- Reflection errors
            | UnquoteFailed UnquoteError
            | DeBruijnIndexOutOfScope Nat Telescope [Name]
        -- Language option errors
            | NeedOptionCopatterns
            | NeedOptionRewriting
            | NeedOptionProp
            | NeedOptionTwoLevel
        -- Failure associated to warnings
            | NonFatalErrors [TCWarning]
        -- Instance search errors
            | InstanceSearchDepthExhausted Term Type Int
            | TriedToCopyConstrainedPrim QName
              deriving (Int -> TypeError -> ShowS
    [TypeError] -> ShowS
    TypeError -> String
    (Int -> TypeError -> ShowS)
    -> (TypeError -> String)
    -> ([TypeError] -> ShowS)
    -> Show TypeError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [TypeError] -> ShowS
    $cshowList :: [TypeError] -> ShowS
    show :: TypeError -> String
    $cshow :: TypeError -> String
    showsPrec :: Int -> TypeError -> ShowS
    $cshowsPrec :: Int -> TypeError -> ShowS
    Show, (forall x. TypeError -> Rep TypeError x)
    -> (forall x. Rep TypeError x -> TypeError) -> Generic TypeError
    forall x. Rep TypeError x -> TypeError
    forall x. TypeError -> Rep TypeError x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TypeError x -> TypeError
    $cfrom :: forall x. TypeError -> Rep TypeError x
    Generic)

    -- | Distinguish error message when parsing lhs or pattern synonym, resp.
    data LHSOrPatSyn = IsLHS | IsPatSyn
      deriving (LHSOrPatSyn -> LHSOrPatSyn -> Bool
    (LHSOrPatSyn -> LHSOrPatSyn -> Bool)
    -> (LHSOrPatSyn -> LHSOrPatSyn -> Bool) -> Eq LHSOrPatSyn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: LHSOrPatSyn -> LHSOrPatSyn -> Bool
    $c/= :: LHSOrPatSyn -> LHSOrPatSyn -> Bool
    == :: LHSOrPatSyn -> LHSOrPatSyn -> Bool
    $c== :: LHSOrPatSyn -> LHSOrPatSyn -> Bool
    Eq, Int -> LHSOrPatSyn -> ShowS
    [LHSOrPatSyn] -> ShowS
    LHSOrPatSyn -> String
    (Int -> LHSOrPatSyn -> ShowS)
    -> (LHSOrPatSyn -> String)
    -> ([LHSOrPatSyn] -> ShowS)
    -> Show LHSOrPatSyn
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [LHSOrPatSyn] -> ShowS
    $cshowList :: [LHSOrPatSyn] -> ShowS
    show :: LHSOrPatSyn -> String
    $cshow :: LHSOrPatSyn -> String
    showsPrec :: Int -> LHSOrPatSyn -> ShowS
    $cshowsPrec :: Int -> LHSOrPatSyn -> ShowS
    Show, (forall x. LHSOrPatSyn -> Rep LHSOrPatSyn x)
    -> (forall x. Rep LHSOrPatSyn x -> LHSOrPatSyn)
    -> Generic LHSOrPatSyn
    forall x. Rep LHSOrPatSyn x -> LHSOrPatSyn
    forall x. LHSOrPatSyn -> Rep LHSOrPatSyn x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep LHSOrPatSyn x -> LHSOrPatSyn
    $cfrom :: forall x. LHSOrPatSyn -> Rep LHSOrPatSyn x
    Generic)

    -- | Type-checking errors.

    data TCErr
      = TypeError
        { TCErr -> CallStack
    tcErrLocation :: CallStack
           -- ^ Location in the internal Agda source code where the error was raised
        , TCErr -> TCState
    tcErrState    :: TCState
            -- ^ The state in which the error was raised.
        , TCErr -> Closure TypeError
    tcErrClosErr  :: Closure TypeError
            -- ^ The environment in which the error as raised plus the error.
        }
      | Exception Range Doc
      | IOException TCState Range E.IOException
        -- ^ The first argument is the state in which the error was
        -- raised.
      | PatternErr Blocker
          -- ^ The exception which is usually caught.
          --   Raised for pattern violations during unification ('assignV')
          --   but also in other situations where we want to backtrack.
          --   Contains an unblocker to control when the computation should
          --   be retried.

    instance Show TCErr where
      show :: TCErr -> String
    show (TypeError CallStack
    _ TCState
    _ Closure TypeError
    e)   = Range -> String
    forall a. Pretty a => a -> String
    prettyShow (TCEnv -> Range
    envRange (TCEnv -> Range) -> TCEnv -> Range
    forall a b. (a -> b) -> a -> b
    $ Closure TypeError -> TCEnv
    forall a. Closure a -> TCEnv
    clEnv Closure TypeError
    e) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ": " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ TypeError -> String
    forall a. Show a => a -> String
    show (Closure TypeError -> TypeError
    forall a. Closure a -> a
    clValue Closure TypeError
    e)
      show (Exception Range
    r Doc
    d)     = Range -> String
    forall a. Pretty a => a -> String
    prettyShow Range
    r String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ": " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Doc -> String
    render Doc
    d
      show (IOException TCState
    _ Range
    r IOException
    e) = Range -> String
    forall a. Pretty a => a -> String
    prettyShow Range
    r String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ": " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ IOException -> String
    forall a. Show a => a -> String
    show IOException
    e
      show PatternErr{}        = String
    "Pattern violation (you shouldn't see this)"

    instance HasRange TCErr where
      getRange :: TCErr -> Range
    getRange (TypeError CallStack
    _ TCState
    _ Closure TypeError
    cl)  = TCEnv -> Range
    envRange (TCEnv -> Range) -> TCEnv -> Range
    forall a b. (a -> b) -> a -> b
    $ Closure TypeError -> TCEnv
    forall a. Closure a -> TCEnv
    clEnv Closure TypeError
    cl
      getRange (Exception Range
    r Doc
    _)     = Range
    r
      getRange (IOException TCState
    s Range
    r IOException
    _) = Range
    r
      getRange PatternErr{}        = Range
    forall a. Range' a
    noRange

    instance E.Exception TCErr

    -----------------------------------------------------------------------------
    -- * Accessing options
    -----------------------------------------------------------------------------

    instance MonadIO m => HasOptions (TCMT m) where
      pragmaOptions :: TCMT m PragmaOptions
    pragmaOptions = Lens' PragmaOptions TCState -> TCMT m PragmaOptions
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useTC Lens' PragmaOptions TCState
    stPragmaOptions

      commandLineOptions :: TCMT m CommandLineOptions
    commandLineOptions = do
        PragmaOptions
    p  <- Lens' PragmaOptions TCState -> TCMT m PragmaOptions
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useTC Lens' PragmaOptions TCState
    stPragmaOptions
        CommandLineOptions
    cl <- PersistentTCState -> CommandLineOptions
    stPersistentOptions (PersistentTCState -> CommandLineOptions)
    -> (TCState -> PersistentTCState) -> TCState -> CommandLineOptions
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCState -> PersistentTCState
    stPersistentState (TCState -> CommandLineOptions)
    -> TCMT m TCState -> TCMT m CommandLineOptions
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT m TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC
        CommandLineOptions -> TCMT m CommandLineOptions
    forall (m :: * -> *) a. Monad m => a -> m a
    return (CommandLineOptions -> TCMT m CommandLineOptions)
    -> CommandLineOptions -> TCMT m CommandLineOptions
    forall a b. (a -> b) -> a -> b
    $ CommandLineOptions
    cl { optPragmaOptions :: PragmaOptions
    optPragmaOptions = PragmaOptions
    p }

    -- HasOptions lifts through monad transformers
    -- (see default signatures in the HasOptions class).

    -- Ternary options are annoying to deal with so we provide auxiliary
    -- definitions using @collapseDefault@.

    sizedTypesOption :: HasOptions m => m Bool
    sizedTypesOption :: forall (m :: * -> *). HasOptions m => m Bool
    sizedTypesOption = WithDefault 'False -> Bool
    forall (b :: Bool). KnownBool b => WithDefault b -> Bool
    collapseDefault (WithDefault 'False -> Bool)
    -> (PragmaOptions -> WithDefault 'False) -> PragmaOptions -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PragmaOptions -> WithDefault 'False
    optSizedTypes (PragmaOptions -> Bool) -> m PragmaOptions -> m Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m PragmaOptions
    forall (m :: * -> *). HasOptions m => m PragmaOptions
    pragmaOptions

    guardednessOption :: HasOptions m => m Bool
    guardednessOption :: forall (m :: * -> *). HasOptions m => m Bool
    guardednessOption = WithDefault 'False -> Bool
    forall (b :: Bool). KnownBool b => WithDefault b -> Bool
    collapseDefault (WithDefault 'False -> Bool)
    -> (PragmaOptions -> WithDefault 'False) -> PragmaOptions -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PragmaOptions -> WithDefault 'False
    optGuardedness (PragmaOptions -> Bool) -> m PragmaOptions -> m Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m PragmaOptions
    forall (m :: * -> *). HasOptions m => m PragmaOptions
    pragmaOptions

    withoutKOption :: HasOptions m => m Bool
    withoutKOption :: forall (m :: * -> *). HasOptions m => m Bool
    withoutKOption = WithDefault 'False -> Bool
    forall (b :: Bool). KnownBool b => WithDefault b -> Bool
    collapseDefault (WithDefault 'False -> Bool)
    -> (PragmaOptions -> WithDefault 'False) -> PragmaOptions -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PragmaOptions -> WithDefault 'False
    optWithoutK (PragmaOptions -> Bool) -> m PragmaOptions -> m Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m PragmaOptions
    forall (m :: * -> *). HasOptions m => m PragmaOptions
    pragmaOptions

    enableCaching :: HasOptions m => m Bool
    enableCaching :: forall (m :: * -> *). HasOptions m => m Bool
    enableCaching = PragmaOptions -> Bool
    optCaching (PragmaOptions -> Bool) -> m PragmaOptions -> m Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m PragmaOptions
    forall (m :: * -> *). HasOptions m => m PragmaOptions
    pragmaOptions
    -----------------------------------------------------------------------------
    -- * The reduce monad
    -----------------------------------------------------------------------------

    -- | Environment of the reduce monad.
    data ReduceEnv = ReduceEnv
      { ReduceEnv -> TCEnv
    redEnv :: TCEnv    -- ^ Read only access to environment.
      , ReduceEnv -> TCState
    redSt  :: TCState  -- ^ Read only access to state (signature, metas...).
      }

    mapRedEnv :: (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv
    mapRedEnv :: (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv
    mapRedEnv TCEnv -> TCEnv
    f ReduceEnv
    s = ReduceEnv
    s { redEnv :: TCEnv
    redEnv = TCEnv -> TCEnv
    f (ReduceEnv -> TCEnv
    redEnv ReduceEnv
    s) }

    mapRedSt :: (TCState -> TCState) -> ReduceEnv -> ReduceEnv
    mapRedSt :: (TCState -> TCState) -> ReduceEnv -> ReduceEnv
    mapRedSt TCState -> TCState
    f ReduceEnv
    s = ReduceEnv
    s { redSt :: TCState
    redSt = TCState -> TCState
    f (ReduceEnv -> TCState
    redSt ReduceEnv
    s) }

    mapRedEnvSt :: (TCEnv -> TCEnv) -> (TCState -> TCState) -> ReduceEnv
                -> ReduceEnv
    mapRedEnvSt :: (TCEnv -> TCEnv) -> (TCState -> TCState) -> ReduceEnv -> ReduceEnv
    mapRedEnvSt TCEnv -> TCEnv
    f TCState -> TCState
    g (ReduceEnv TCEnv
    e TCState
    s) = TCEnv -> TCState -> ReduceEnv
    ReduceEnv (TCEnv -> TCEnv
    f TCEnv
    e) (TCState -> TCState
    g TCState
    s)

    -- Lenses
    reduceEnv :: Lens' TCEnv ReduceEnv
    reduceEnv :: Lens' TCEnv ReduceEnv
    reduceEnv TCEnv -> f TCEnv
    f ReduceEnv
    s = TCEnv -> f TCEnv
    f (ReduceEnv -> TCEnv
    redEnv ReduceEnv
    s) f TCEnv -> (TCEnv -> ReduceEnv) -> f ReduceEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ TCEnv
    e -> ReduceEnv
    s { redEnv :: TCEnv
    redEnv = TCEnv
    e }

    reduceSt :: Lens' TCState ReduceEnv
    reduceSt :: Lens' TCState ReduceEnv
    reduceSt TCState -> f TCState
    f ReduceEnv
    s = TCState -> f TCState
    f (ReduceEnv -> TCState
    redSt ReduceEnv
    s) f TCState -> (TCState -> ReduceEnv) -> f ReduceEnv
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ TCState
    e -> ReduceEnv
    s { redSt :: TCState
    redSt = TCState
    e }

    newtype ReduceM a = ReduceM { forall a. ReduceM a -> ReduceEnv -> a
    unReduceM :: ReduceEnv -> a }
    --  deriving (Functor, Applicative, Monad)

    onReduceEnv :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
    onReduceEnv :: forall a. (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
    onReduceEnv ReduceEnv -> ReduceEnv
    f (ReduceM ReduceEnv -> a
    m) = (ReduceEnv -> a) -> ReduceM a
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM (ReduceEnv -> a
    m (ReduceEnv -> a) -> (ReduceEnv -> ReduceEnv) -> ReduceEnv -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReduceEnv -> ReduceEnv
    f)

    fmapReduce :: (a -> b) -> ReduceM a -> ReduceM b
    fmapReduce :: forall a b. (a -> b) -> ReduceM a -> ReduceM b
    fmapReduce a -> b
    f (ReduceM ReduceEnv -> a
    m) = (ReduceEnv -> b) -> ReduceM b
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ((ReduceEnv -> b) -> ReduceM b) -> (ReduceEnv -> b) -> ReduceM b
    forall a b. (a -> b) -> a -> b
    $ \ ReduceEnv
    e -> a -> b
    f (a -> b) -> a -> b
    forall a b. (a -> b) -> a -> b
    $! ReduceEnv -> a
    m ReduceEnv
    e
    {-# INLINE fmapReduce #-}

    -- Andreas, 2021-05-12, issue #5379:
    -- It seems more stable to force to evaluate @mf <*> ma@
    -- from left to right, for the sake of printing
    -- debug messages in order.
    apReduce :: ReduceM (a -> b) -> ReduceM a -> ReduceM b
    apReduce :: forall a b. ReduceM (a -> b) -> ReduceM a -> ReduceM b
    apReduce (ReduceM ReduceEnv -> a -> b
    f) (ReduceM ReduceEnv -> a
    x) = (ReduceEnv -> b) -> ReduceM b
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ((ReduceEnv -> b) -> ReduceM b) -> (ReduceEnv -> b) -> ReduceM b
    forall a b. (a -> b) -> a -> b
    $ \ ReduceEnv
    e ->
      let g :: a -> b
    g = ReduceEnv -> a -> b
    f ReduceEnv
    e
          a :: a
    a = ReduceEnv -> a
    x ReduceEnv
    e
      in  a -> b
    g (a -> b) -> b -> b
    forall a b. a -> b -> b
    `pseq` a
    a a -> b -> b
    forall a b. a -> b -> b
    `pseq` a -> b
    g a
    a
    {-# INLINE apReduce #-}

    -- Andreas, 2021-05-12, issue #5379
    -- Since the MonadDebug instance of ReduceM is implemented via
    -- unsafePerformIO, we need to force results that later
    -- computations do not depend on, otherwise we lose debug messages.
    thenReduce :: ReduceM a -> ReduceM b -> ReduceM b
    thenReduce :: forall a b. ReduceM a -> ReduceM b -> ReduceM b
    thenReduce (ReduceM ReduceEnv -> a
    x) (ReduceM ReduceEnv -> b
    y) = (ReduceEnv -> b) -> ReduceM b
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ((ReduceEnv -> b) -> ReduceM b) -> (ReduceEnv -> b) -> ReduceM b
    forall a b. (a -> b) -> a -> b
    $ \ ReduceEnv
    e -> ReduceEnv -> a
    x ReduceEnv
    e a -> b -> b
    forall a b. a -> b -> b
    `pseq` ReduceEnv -> b
    y ReduceEnv
    e
    {-# INLINE thenReduce #-}

    -- Andreas, 2021-05-14:
    -- `seq` does not force evaluation order, the optimizier is allowed to replace
    -- @
    --    a `seq` b`
    -- @
    -- by:
    -- @
    --    b `seq` a `seq` b
    -- @
    -- see https://hackage.haskell.org/package/parallel/docs/Control-Parallel.html
    --
    -- In contrast, `pseq` is only strict in its first argument, so such a permutation
    -- is forbidden.
    -- If we want to ensure that debug messages are printed before exceptions are
    -- propagated, we need to use `pseq`, as in:
    -- @
    --    unsafePerformIO (putStrLn "Black hawk is going down...") `pseq` throw HitByRPG
    -- @
    beforeReduce :: ReduceM a -> ReduceM b -> ReduceM a
    beforeReduce :: forall a b. ReduceM a -> ReduceM b -> ReduceM a
    beforeReduce (ReduceM ReduceEnv -> a
    x) (ReduceM ReduceEnv -> b
    y) = (ReduceEnv -> a) -> ReduceM a
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ((ReduceEnv -> a) -> ReduceM a) -> (ReduceEnv -> a) -> ReduceM a
    forall a b. (a -> b) -> a -> b
    $ \ ReduceEnv
    e ->
      let a :: a
    a = ReduceEnv -> a
    x ReduceEnv
    e
      in  a
    a a -> a -> a
    forall a b. a -> b -> b
    `pseq` ReduceEnv -> b
    y ReduceEnv
    e b -> a -> a
    forall a b. a -> b -> b
    `pseq` a
    a
    {-# INLINE beforeReduce #-}

    bindReduce :: ReduceM a -> (a -> ReduceM b) -> ReduceM b
    bindReduce :: forall a b. ReduceM a -> (a -> ReduceM b) -> ReduceM b
    bindReduce (ReduceM ReduceEnv -> a
    m) a -> ReduceM b
    f = (ReduceEnv -> b) -> ReduceM b
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ((ReduceEnv -> b) -> ReduceM b) -> (ReduceEnv -> b) -> ReduceM b
    forall a b. (a -> b) -> a -> b
    $ \ ReduceEnv
    e -> ReduceM b -> ReduceEnv -> b
    forall a. ReduceM a -> ReduceEnv -> a
    unReduceM (a -> ReduceM b
    f (a -> ReduceM b) -> a -> ReduceM b
    forall a b. (a -> b) -> a -> b
    $! ReduceEnv -> a
    m ReduceEnv
    e) ReduceEnv
    e
    {-# INLINE bindReduce #-}

    instance Functor ReduceM where
      fmap :: forall a b. (a -> b) -> ReduceM a -> ReduceM b
    fmap = (a -> b) -> ReduceM a -> ReduceM b
    forall a b. (a -> b) -> ReduceM a -> ReduceM b
    fmapReduce

    instance Applicative ReduceM where
      pure :: forall a. a -> ReduceM a
    pure a
    x = (ReduceEnv -> a) -> ReduceM a
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM (a -> ReduceEnv -> a
    forall a b. a -> b -> a
    const a
    x)
      <*> :: forall a b. ReduceM (a -> b) -> ReduceM a -> ReduceM b
    (<*>) = ReduceM (a -> b) -> ReduceM a -> ReduceM b
    forall a b. ReduceM (a -> b) -> ReduceM a -> ReduceM b
    apReduce
      *> :: forall a b. ReduceM a -> ReduceM b -> ReduceM b
    (*>)  = ReduceM a -> ReduceM b -> ReduceM b
    forall a b. ReduceM a -> ReduceM b -> ReduceM b
    thenReduce
      <* :: forall a b. ReduceM a -> ReduceM b -> ReduceM a
    (<*)  = ReduceM a -> ReduceM b -> ReduceM a
    forall a b. ReduceM a -> ReduceM b -> ReduceM a
    beforeReduce

    instance Monad ReduceM where
      return :: forall a. a -> ReduceM a
    return = a -> ReduceM a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
      >>= :: forall a b. ReduceM a -> (a -> ReduceM b) -> ReduceM b
    (>>=) = ReduceM a -> (a -> ReduceM b) -> ReduceM b
    forall a b. ReduceM a -> (a -> ReduceM b) -> ReduceM b
    bindReduce
      >> :: forall a b. ReduceM a -> ReduceM b -> ReduceM b
    (>>) = ReduceM a -> ReduceM b -> ReduceM b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    (*>)
    #if __GLASGOW_HASKELL__ < 808
      fail = Fail.fail
    #endif

    instance Fail.MonadFail ReduceM where
      fail :: forall a. String -> ReduceM a
    fail = String -> ReduceM a
    forall a. HasCallStack => String -> a
    error

    instance ReadTCState ReduceM where
      getTCState :: ReduceM TCState
    getTCState = (ReduceEnv -> TCState) -> ReduceM TCState
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ReduceEnv -> TCState
    redSt
      locallyTCState :: forall a b. Lens' a TCState -> (a -> a) -> ReduceM b -> ReduceM b
    locallyTCState Lens' a TCState
    l a -> a
    f = (ReduceEnv -> ReduceEnv) -> ReduceM b -> ReduceM b
    forall a. (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
    onReduceEnv ((ReduceEnv -> ReduceEnv) -> ReduceM b -> ReduceM b)
    -> (ReduceEnv -> ReduceEnv) -> ReduceM b -> ReduceM b
    forall a b. (a -> b) -> a -> b
    $ (TCState -> TCState) -> ReduceEnv -> ReduceEnv
    mapRedSt ((TCState -> TCState) -> ReduceEnv -> ReduceEnv)
    -> (TCState -> TCState) -> ReduceEnv -> ReduceEnv
    forall a b. (a -> b) -> a -> b
    $ Lens' a TCState -> LensMap a TCState
    forall i o. Lens' i o -> LensMap i o
    over Lens' a TCState
    l a -> a
    f

    runReduceM :: ReduceM a -> TCM a
    runReduceM :: forall a. ReduceM a -> TCM a
    runReduceM ReduceM a
    m = (IORef TCState -> TCEnv -> IO a) -> TCMT IO a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> IO a) -> TCMT IO a)
    -> (IORef TCState -> TCEnv -> IO a) -> TCMT IO a
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    r TCEnv
    e -> do
      TCState
    s <- IORef TCState -> IO TCState
    forall a. IORef a -> IO a
    readIORef IORef TCState
    r
      a -> IO a
    forall a. a -> IO a
    E.evaluate (a -> IO a) -> a -> IO a
    forall a b. (a -> b) -> a -> b
    $ ReduceM a -> ReduceEnv -> a
    forall a. ReduceM a -> ReduceEnv -> a
    unReduceM ReduceM a
    m (ReduceEnv -> a) -> ReduceEnv -> a
    forall a b. (a -> b) -> a -> b
    $ TCEnv -> TCState -> ReduceEnv
    ReduceEnv TCEnv
    e TCState
    s
      -- Andreas, 2021-05-13, issue #5379
      -- This was the following, which is apparently not strict enough
      -- to force all unsafePerformIOs...
      -- runReduceM m = do
      --   e <- askTC
      --   s <- getTC
      --   return $! unReduceM m (ReduceEnv e s)

    runReduceF :: (a -> ReduceM b) -> TCM (a -> b)
    runReduceF :: forall a b. (a -> ReduceM b) -> TCM (a -> b)
    runReduceF a -> ReduceM b
    f = do
      TCEnv
    e <- TCMT IO TCEnv
    forall (m :: * -> *). MonadTCEnv m => m TCEnv
    askTC
      TCState
    s <- TCMT IO TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC
      (a -> b) -> TCM (a -> b)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((a -> b) -> TCM (a -> b)) -> (a -> b) -> TCM (a -> b)
    forall a b. (a -> b) -> a -> b
    $ \a
    x -> ReduceM b -> ReduceEnv -> b
    forall a. ReduceM a -> ReduceEnv -> a
    unReduceM (a -> ReduceM b
    f a
    x) (TCEnv -> TCState -> ReduceEnv
    ReduceEnv TCEnv
    e TCState
    s)

    instance MonadTCEnv ReduceM where
      askTC :: ReduceM TCEnv
    askTC   = (ReduceEnv -> TCEnv) -> ReduceM TCEnv
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ReduceEnv -> TCEnv
    redEnv
      localTC :: forall a. (TCEnv -> TCEnv) -> ReduceM a -> ReduceM a
    localTC = (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
    forall a. (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
    onReduceEnv ((ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a)
    -> ((TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv)
    -> (TCEnv -> TCEnv)
    -> ReduceM a
    -> ReduceM a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv
    mapRedEnv

    -- Andrea comments (https://github.com/agda/agda/issues/1829#issuecomment-522312084):
    --
    --   useR forces the result of projecting the lens,
    --   this usually prevents retaining the whole structure when we only need a field.
    --
    -- This fixes (or contributes to the fix of) the space leak issue #1829 (caching).
    useR :: (ReadTCState m) => Lens' a TCState -> m a
    useR :: forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' a TCState
    l = do
      !a
    x <- (TCState -> Lens' a TCState -> a
    forall o i. o -> Lens' i o -> i
    ^.Lens' a TCState
    l) (TCState -> a) -> m TCState -> m a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m TCState
    forall (m :: * -> *). ReadTCState m => m TCState
    getTCState
      a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    askR :: ReduceM ReduceEnv
    askR :: ReduceM ReduceEnv
    askR = (ReduceEnv -> ReduceEnv) -> ReduceM ReduceEnv
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ReduceEnv -> ReduceEnv
    forall r (m :: * -> *). MonadReader r m => m r
    ask

    localR :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
    localR :: forall a. (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
    localR ReduceEnv -> ReduceEnv
    f = (ReduceEnv -> a) -> ReduceM a
    forall a. (ReduceEnv -> a) -> ReduceM a
    ReduceM ((ReduceEnv -> a) -> ReduceM a)
    -> (ReduceM a -> ReduceEnv -> a) -> ReduceM a -> ReduceM a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ReduceEnv -> ReduceEnv) -> (ReduceEnv -> a) -> ReduceEnv -> a
    forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
    local ReduceEnv -> ReduceEnv
    f ((ReduceEnv -> a) -> ReduceEnv -> a)
    -> (ReduceM a -> ReduceEnv -> a) -> ReduceM a -> ReduceEnv -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReduceM a -> ReduceEnv -> a
    forall a. ReduceM a -> ReduceEnv -> a
    unReduceM

    instance HasOptions ReduceM where
      pragmaOptions :: ReduceM PragmaOptions
    pragmaOptions      = Lens' PragmaOptions TCState -> ReduceM PragmaOptions
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' PragmaOptions TCState
    stPragmaOptions
      commandLineOptions :: ReduceM CommandLineOptions
    commandLineOptions = do
        PragmaOptions
    p  <- Lens' PragmaOptions TCState -> ReduceM PragmaOptions
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useR Lens' PragmaOptions TCState
    stPragmaOptions
        CommandLineOptions
    cl <- PersistentTCState -> CommandLineOptions
    stPersistentOptions (PersistentTCState -> CommandLineOptions)
    -> (TCState -> PersistentTCState) -> TCState -> CommandLineOptions
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCState -> PersistentTCState
    stPersistentState (TCState -> CommandLineOptions)
    -> ReduceM TCState -> ReduceM CommandLineOptions
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ReduceM TCState
    forall (m :: * -> *). ReadTCState m => m TCState
    getTCState
        CommandLineOptions -> ReduceM CommandLineOptions
    forall (m :: * -> *) a. Monad m => a -> m a
    return (CommandLineOptions -> ReduceM CommandLineOptions)
    -> CommandLineOptions -> ReduceM CommandLineOptions
    forall a b. (a -> b) -> a -> b
    $ CommandLineOptions
    cl{ optPragmaOptions :: PragmaOptions
    optPragmaOptions = PragmaOptions
    p }

    class ( Applicative m
          , MonadTCEnv m
          , ReadTCState m
          , HasOptions m
          ) => MonadReduce m where
      liftReduce :: ReduceM a -> m a

      default liftReduce :: (MonadTrans t, MonadReduce n, t n ~ m) => ReduceM a -> m a
      liftReduce = n a -> t n a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (n a -> t n a) -> (ReduceM a -> n a) -> ReduceM a -> t n a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReduceM a -> n a
    forall (m :: * -> *) a. MonadReduce m => ReduceM a -> m a
    liftReduce

    instance MonadReduce ReduceM where
      liftReduce :: forall a. ReduceM a -> ReduceM a
    liftReduce = ReduceM a -> ReduceM a
    forall a. a -> a
    id

    instance MonadReduce m => MonadReduce (ChangeT m)
    instance MonadReduce m => MonadReduce (ExceptT err m)
    instance MonadReduce m => MonadReduce (IdentityT m)
    instance MonadReduce m => MonadReduce (ListT m)
    instance MonadReduce m => MonadReduce (MaybeT m)
    instance MonadReduce m => MonadReduce (ReaderT r m)
    instance MonadReduce m => MonadReduce (StateT w m)
    instance (Monoid w, MonadReduce m) => MonadReduce (WriterT w m)
    instance MonadReduce m => MonadReduce (BlockT m)

    ---------------------------------------------------------------------------
    -- * Monad with read-only 'TCEnv'
    ---------------------------------------------------------------------------

    -- | @MonadTCEnv@ made into its own dedicated service class.
    --   This allows us to use 'MonadReader' for 'ReaderT' extensions of @TCM@.
    class Monad m => MonadTCEnv m where
      askTC   :: m TCEnv
      localTC :: (TCEnv -> TCEnv) -> m a -> m a

      default askTC :: (MonadTrans t, MonadTCEnv n, t n ~ m) => m TCEnv
      askTC = n TCEnv -> t n TCEnv
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift n TCEnv
    forall (m :: * -> *). MonadTCEnv m => m TCEnv
    askTC

      default localTC
        :: (MonadTransControl t, MonadTCEnv n, t n ~ m)
        =>  (TCEnv -> TCEnv) -> m a -> m a
      localTC = (n (StT t a) -> n (StT t a)) -> t n a -> t n a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b.
    (MonadTransControl t, Monad (t m), Monad m) =>
    (m (StT t a) -> m (StT t b)) -> t m a -> t m b
    liftThrough ((n (StT t a) -> n (StT t a)) -> t n a -> t n a)
    -> ((TCEnv -> TCEnv) -> n (StT t a) -> n (StT t a))
    -> (TCEnv -> TCEnv)
    -> t n a
    -> t n a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (TCEnv -> TCEnv) -> n (StT t a) -> n (StT t a)
    forall (m :: * -> *) a.
    MonadTCEnv m =>
    (TCEnv -> TCEnv) -> m a -> m a
    localTC

    instance MonadTCEnv m => MonadTCEnv (ChangeT m)
    instance MonadTCEnv m => MonadTCEnv (ExceptT err m)
    instance MonadTCEnv m => MonadTCEnv (IdentityT m)
    instance MonadTCEnv m => MonadTCEnv (MaybeT m)
    instance MonadTCEnv m => MonadTCEnv (ReaderT r m)
    instance MonadTCEnv m => MonadTCEnv (StateT s m)
    instance (Monoid w, MonadTCEnv m) => MonadTCEnv (WriterT w m)

    instance MonadTCEnv m => MonadTCEnv (ListT m) where
      localTC :: forall a. (TCEnv -> TCEnv) -> ListT m a -> ListT m a
    localTC = (m (Maybe (a, ListT m a)) -> m (Maybe (a, ListT m a)))
    -> ListT m a -> ListT m a
    forall (m :: * -> *) a (n :: * -> *) b.
    (m (Maybe (a, ListT m a)) -> n (Maybe (b, ListT n b)))
    -> ListT m a -> ListT n b
    mapListT ((m (Maybe (a, ListT m a)) -> m (Maybe (a, ListT m a)))
     -> ListT m a -> ListT m a)
    -> ((TCEnv -> TCEnv)
        -> m (Maybe (a, ListT m a)) -> m (Maybe (a, ListT m a)))
    -> (TCEnv -> TCEnv)
    -> ListT m a
    -> ListT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (TCEnv -> TCEnv)
    -> m (Maybe (a, ListT m a)) -> m (Maybe (a, ListT m a))
    forall (m :: * -> *) a.
    MonadTCEnv m =>
    (TCEnv -> TCEnv) -> m a -> m a
    localTC

    asksTC :: MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC :: forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> a
    f = TCEnv -> a
    f (TCEnv -> a) -> m TCEnv -> m a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m TCEnv
    forall (m :: * -> *). MonadTCEnv m => m TCEnv
    askTC

    viewTC :: MonadTCEnv m => Lens' a TCEnv -> m a
    viewTC :: forall (m :: * -> *) a. MonadTCEnv m => Lens' a TCEnv -> m a
    viewTC Lens' a TCEnv
    l = (TCEnv -> a) -> m a
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC (TCEnv -> Lens' a TCEnv -> a
    forall o i. o -> Lens' i o -> i
    ^. Lens' a TCEnv
    l)

    -- | Modify the lens-indicated part of the @TCEnv@ in a subcomputation.
    locallyTC :: MonadTCEnv m => Lens' a TCEnv -> (a -> a) -> m b -> m b
    locallyTC :: forall (m :: * -> *) a b.
    MonadTCEnv m =>
    Lens' a TCEnv -> (a -> a) -> m b -> m b
    locallyTC Lens' a TCEnv
    l = (TCEnv -> TCEnv) -> m b -> m b
    forall (m :: * -> *) a.
    MonadTCEnv m =>
    (TCEnv -> TCEnv) -> m a -> m a
    localTC ((TCEnv -> TCEnv) -> m b -> m b)
    -> ((a -> a) -> TCEnv -> TCEnv) -> (a -> a) -> m b -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Lens' a TCEnv -> (a -> a) -> TCEnv -> TCEnv
    forall i o. Lens' i o -> LensMap i o
    over Lens' a TCEnv
    l

    ---------------------------------------------------------------------------
    -- * Monad with mutable 'TCState'
    ---------------------------------------------------------------------------

    -- | @MonadTCState@ made into its own dedicated service class.
    --   This allows us to use 'MonadState' for 'StateT' extensions of @TCM@.
    class Monad m => MonadTCState m where
      getTC :: m TCState
      putTC :: TCState -> m ()
      modifyTC :: (TCState -> TCState) -> m ()

      default getTC :: (MonadTrans t, MonadTCState n, t n ~ m) => m TCState
      getTC = n TCState -> t n TCState
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift n TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC

      default putTC :: (MonadTrans t, MonadTCState n, t n ~ m) => TCState -> m ()
      putTC = n () -> t n ()
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (n () -> t n ()) -> (TCState -> n ()) -> TCState -> t n ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCState -> n ()
    forall (m :: * -> *). MonadTCState m => TCState -> m ()
    putTC

      default modifyTC :: (MonadTrans t, MonadTCState n, t n ~ m) => (TCState -> TCState) -> m ()
      modifyTC = n () -> t n ()
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (n () -> t n ())
    -> ((TCState -> TCState) -> n ()) -> (TCState -> TCState) -> t n ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (TCState -> TCState) -> n ()
    forall (m :: * -> *).
    MonadTCState m =>
    (TCState -> TCState) -> m ()
    modifyTC

    instance MonadTCState m => MonadTCState (MaybeT m)
    instance MonadTCState m => MonadTCState (ListT m)
    instance MonadTCState m => MonadTCState (ExceptT err m)
    instance MonadTCState m => MonadTCState (ReaderT r m)
    instance MonadTCState m => MonadTCState (StateT s m)
    instance MonadTCState m => MonadTCState (ChangeT m)
    instance MonadTCState m => MonadTCState (IdentityT m)
    instance (Monoid w, MonadTCState m) => MonadTCState (WriterT w m)

    -- ** @TCState@ accessors (no lenses)

    getsTC :: ReadTCState m => (TCState -> a) -> m a
    getsTC :: forall (m :: * -> *) a. ReadTCState m => (TCState -> a) -> m a
    getsTC TCState -> a
    f = TCState -> a
    f (TCState -> a) -> m TCState -> m a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m TCState
    forall (m :: * -> *). ReadTCState m => m TCState
    getTCState

    -- | A variant of 'modifyTC' in which the computation is strict in the
    -- new state.
    modifyTC' :: MonadTCState m => (TCState -> TCState) -> m ()
    modifyTC' :: forall (m :: * -> *).
    MonadTCState m =>
    (TCState -> TCState) -> m ()
    modifyTC' TCState -> TCState
    f = do
      TCState
    s' <- m TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC
      TCState -> m ()
    forall (m :: * -> *). MonadTCState m => TCState -> m ()
    putTC (TCState -> m ()) -> TCState -> m ()
    forall a b. (a -> b) -> a -> b
    $! TCState -> TCState
    f TCState
    s'

    -- SEE TC.Monad.State
    -- -- | Restore the 'TCState' after computation.
    -- localTCState :: MonadTCState m => m a -> m a
    -- localTCState = bracket_ getTC putTC

    -- ** @TCState@ accessors via lenses

    useTC :: ReadTCState m => Lens' a TCState -> m a
    useTC :: forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useTC Lens' a TCState
    l = do
      !a
    x <- (TCState -> a) -> m a
    forall (m :: * -> *) a. ReadTCState m => (TCState -> a) -> m a
    getsTC (TCState -> Lens' a TCState -> a
    forall o i. o -> Lens' i o -> i
    ^. Lens' a TCState
    l)
      a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    infix 4 `setTCLens`

    -- | Overwrite the part of the 'TCState' focused on by the lens.
    setTCLens :: MonadTCState m => Lens' a TCState -> a -> m ()
    setTCLens :: forall (m :: * -> *) a.
    MonadTCState m =>
    Lens' a TCState -> a -> m ()
    setTCLens Lens' a TCState
    l = (TCState -> TCState) -> m ()
    forall (m :: * -> *).
    MonadTCState m =>
    (TCState -> TCState) -> m ()
    modifyTC ((TCState -> TCState) -> m ())
    -> (a -> TCState -> TCState) -> a -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Lens' a TCState -> a -> TCState -> TCState
    forall i o. Lens' i o -> LensSet i o
    set Lens' a TCState
    l

    -- | Modify the part of the 'TCState' focused on by the lens.
    modifyTCLens :: MonadTCState m => Lens' a TCState -> (a -> a) -> m ()
    modifyTCLens :: forall (m :: * -> *) a.
    MonadTCState m =>
    Lens' a TCState -> (a -> a) -> m ()
    modifyTCLens Lens' a TCState
    l = (TCState -> TCState) -> m ()
    forall (m :: * -> *).
    MonadTCState m =>
    (TCState -> TCState) -> m ()
    modifyTC ((TCState -> TCState) -> m ())
    -> ((a -> a) -> TCState -> TCState) -> (a -> a) -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Lens' a TCState -> (a -> a) -> TCState -> TCState
    forall i o. Lens' i o -> LensMap i o
    over Lens' a TCState
    l

    -- | Modify a part of the state monadically.
    modifyTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m a) -> m ()
    modifyTCLensM :: forall (m :: * -> *) a.
    MonadTCState m =>
    Lens' a TCState -> (a -> m a) -> m ()
    modifyTCLensM Lens' a TCState
    l a -> m a
    f = TCState -> m ()
    forall (m :: * -> *). MonadTCState m => TCState -> m ()
    putTC (TCState -> m ()) -> m TCState -> m ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< (a -> m a) -> TCState -> m TCState
    Lens' a TCState
    l a -> m a
    f (TCState -> m TCState) -> m TCState -> m TCState
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< m TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC

    -- | Modify the part of the 'TCState' focused on by the lens, and return some result.
    stateTCLens :: MonadTCState m => Lens' a TCState -> (a -> (r , a)) -> m r
    stateTCLens :: forall (m :: * -> *) a r.
    MonadTCState m =>
    Lens' a TCState -> (a -> (r, a)) -> m r
    stateTCLens Lens' a TCState
    l a -> (r, a)
    f = Lens' a TCState -> (a -> m (r, a)) -> m r
    forall (m :: * -> *) a r.
    MonadTCState m =>
    Lens' a TCState -> (a -> m (r, a)) -> m r
    stateTCLensM Lens' a TCState
    l ((a -> m (r, a)) -> m r) -> (a -> m (r, a)) -> m r
    forall a b. (a -> b) -> a -> b
    $ (r, a) -> m (r, a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((r, a) -> m (r, a)) -> (a -> (r, a)) -> a -> m (r, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> (r, a)
    f

    -- | Modify a part of the state monadically, and return some result.
    stateTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m (r , a)) -> m r
    stateTCLensM :: forall (m :: * -> *) a r.
    MonadTCState m =>
    Lens' a TCState -> (a -> m (r, a)) -> m r
    stateTCLensM Lens' a TCState
    l a -> m (r, a)
    f = do
      TCState
    s <- m TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC
      (r
    result , a
    x) <- a -> m (r, a)
    f (a -> m (r, a)) -> a -> m (r, a)
    forall a b. (a -> b) -> a -> b
    $ TCState
    s TCState -> Lens' a TCState -> a
    forall o i. o -> Lens' i o -> i
    ^. Lens' a TCState
    l
      TCState -> m ()
    forall (m :: * -> *). MonadTCState m => TCState -> m ()
    putTC (TCState -> m ()) -> TCState -> m ()
    forall a b. (a -> b) -> a -> b
    $ Lens' a TCState -> LensSet a TCState
    forall i o. Lens' i o -> LensSet i o
    set Lens' a TCState
    l a
    x TCState
    s
      r -> m r
    forall (m :: * -> *) a. Monad m => a -> m a
    return r
    result

    ---------------------------------------------------------------------------
    -- ** Monad with capability to block a computation
    ---------------------------------------------------------------------------

    class Monad m => MonadBlock m where

      -- | `patternViolation b` aborts the current computation
      patternViolation :: Blocker -> m a

      default patternViolation :: (MonadTrans t, MonadBlock n, m ~ t n) => Blocker -> m a
      patternViolation = n a -> t n a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (n a -> t n a) -> (Blocker -> n a) -> Blocker -> t n a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Blocker -> n a
    forall (m :: * -> *) a. MonadBlock m => Blocker -> m a
    patternViolation

      -- | `catchPatternErr handle m` runs m, handling pattern violations
      --    with `handle` (doesn't roll back the state)
      catchPatternErr :: (Blocker -> m a) -> m a -> m a

    newtype BlockT m a = BlockT { forall (m :: * -> *) a. BlockT m a -> ExceptT Blocker m a
    unBlockT :: ExceptT Blocker m a }
      deriving ( (forall a b. (a -> b) -> BlockT m a -> BlockT m b)
    -> (forall a b. a -> BlockT m b -> BlockT m a)
    -> Functor (BlockT m)
    forall a b. a -> BlockT m b -> BlockT m a
    forall a b. (a -> b) -> BlockT m a -> BlockT m b
    forall (m :: * -> *) a b.
    Functor m =>
    a -> BlockT m b -> BlockT m a
    forall (m :: * -> *) a b.
    Functor m =>
    (a -> b) -> BlockT m a -> BlockT m b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: forall a b. a -> BlockT m b -> BlockT m a
    $c<$ :: forall (m :: * -> *) a b.
    Functor m =>
    a -> BlockT m b -> BlockT m a
    fmap :: forall a b. (a -> b) -> BlockT m a -> BlockT m b
    $cfmap :: forall (m :: * -> *) a b.
    Functor m =>
    (a -> b) -> BlockT m a -> BlockT m b
    Functor, Functor (BlockT m)
    Functor (BlockT m)
    -> (forall a. a -> BlockT m a)
    -> (forall a b. BlockT m (a -> b) -> BlockT m a -> BlockT m b)
    -> (forall a b c.
        (a -> b -> c) -> BlockT m a -> BlockT m b -> BlockT m c)
    -> (forall a b. BlockT m a -> BlockT m b -> BlockT m b)
    -> (forall a b. BlockT m a -> BlockT m b -> BlockT m a)
    -> Applicative (BlockT m)
    forall a. a -> BlockT m a
    forall a b. BlockT m a -> BlockT m b -> BlockT m a
    forall a b. BlockT m a -> BlockT m b -> BlockT m b
    forall a b. BlockT m (a -> b) -> BlockT m a -> BlockT m b
    forall a b c.
    (a -> b -> c) -> BlockT m a -> BlockT m b -> BlockT m c
    forall {m :: * -> *}. Monad m => Functor (BlockT m)
    forall (m :: * -> *) a. Monad m => a -> BlockT m a
    forall (m :: * -> *) a b.
    Monad m =>
    BlockT m a -> BlockT m b -> BlockT m a
    forall (m :: * -> *) a b.
    Monad m =>
    BlockT m a -> BlockT m b -> BlockT m b
    forall (m :: * -> *) a b.
    Monad m =>
    BlockT m (a -> b) -> BlockT m a -> BlockT m b
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> b -> c) -> BlockT m a -> BlockT m b -> BlockT m c
    forall (f :: * -> *).
    Functor f
    -> (forall a. a -> f a)
    -> (forall a b. f (a -> b) -> f a -> f b)
    -> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
    -> (forall a b. f a -> f b -> f b)
    -> (forall a b. f a -> f b -> f a)
    -> Applicative f
    <* :: forall a b. BlockT m a -> BlockT m b -> BlockT m a
    $c<* :: forall (m :: * -> *) a b.
    Monad m =>
    BlockT m a -> BlockT m b -> BlockT m a
    *> :: forall a b. BlockT m a -> BlockT m b -> BlockT m b
    $c*> :: forall (m :: * -> *) a b.
    Monad m =>
    BlockT m a -> BlockT m b -> BlockT m b
    liftA2 :: forall a b c.
    (a -> b -> c) -> BlockT m a -> BlockT m b -> BlockT m c
    $cliftA2 :: forall (m :: * -> *) a b c.
    Monad m =>
    (a -> b -> c) -> BlockT m a -> BlockT m b -> BlockT m c
    <*> :: forall a b. BlockT m (a -> b) -> BlockT m a -> BlockT m b
    $c<*> :: forall (m :: * -> *) a b.
    Monad m =>
    BlockT m (a -> b) -> BlockT m a -> BlockT m b
    pure :: forall a. a -> BlockT m a
    $cpure :: forall (m :: * -> *) a. Monad m => a -> BlockT m a
    Applicative, Applicative (BlockT m)
    Applicative (BlockT m)
    -> (forall a b. BlockT m a -> (a -> BlockT m b) -> BlockT m b)
    -> (forall a b. BlockT m a -> BlockT m b -> BlockT m b)
    -> (forall a. a -> BlockT m a)
    -> Monad (BlockT m)
    forall a. a -> BlockT m a
    forall a b. BlockT m a -> BlockT m b -> BlockT m b
    forall a b. BlockT m a -> (a -> BlockT m b) -> BlockT m b
    forall (m :: * -> *). Monad m => Applicative (BlockT m)
    forall (m :: * -> *) a. Monad m => a -> BlockT m a
    forall (m :: * -> *) a b.
    Monad m =>
    BlockT m a -> BlockT m b -> BlockT m b
    forall (m :: * -> *) a b.
    Monad m =>
    BlockT m a -> (a -> BlockT m b) -> BlockT m b
    forall (m :: * -> *).
    Applicative m
    -> (forall a b. m a -> (a -> m b) -> m b)
    -> (forall a b. m a -> m b -> m b)
    -> (forall a. a -> m a)
    -> Monad m
    return :: forall a. a -> BlockT m a
    $creturn :: forall (m :: * -> *) a. Monad m => a -> BlockT m a
    >> :: forall a b. BlockT m a -> BlockT m b -> BlockT m b
    $c>> :: forall (m :: * -> *) a b.
    Monad m =>
    BlockT m a -> BlockT m b -> BlockT m b
    >>= :: forall a b. BlockT m a -> (a -> BlockT m b) -> BlockT m b
    $c>>= :: forall (m :: * -> *) a b.
    Monad m =>
    BlockT m a -> (a -> BlockT m b) -> BlockT m b
    Monad, (forall (m :: * -> *) a. Monad m => m a -> BlockT m a)
    -> MonadTrans BlockT
    forall (m :: * -> *) a. Monad m => m a -> BlockT m a
    forall (t :: (* -> *) -> * -> *).
    (forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
    lift :: forall (m :: * -> *) a. Monad m => m a -> BlockT m a
    $clift :: forall (m :: * -> *) a. Monad m => m a -> BlockT m a
    MonadTrans -- , MonadTransControl -- requires GHC >= 8.2
               , Monad (BlockT m)
    Monad (BlockT m)
    -> (forall a. IO a -> BlockT m a) -> MonadIO (BlockT m)
    forall a. IO a -> BlockT m a
    forall (m :: * -> *).
    Monad m -> (forall a. IO a -> m a) -> MonadIO m
    forall {m :: * -> *}. MonadIO m => Monad (BlockT m)
    forall (m :: * -> *) a. MonadIO m => IO a -> BlockT m a
    liftIO :: forall a. IO a -> BlockT m a
    $cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> BlockT m a
    MonadIO, Monad (BlockT m)
    Monad (BlockT m)
    -> (forall a. String -> BlockT m a) -> MonadFail (BlockT m)
    forall a. String -> BlockT m a
    forall (m :: * -> *).
    Monad m -> (forall a. String -> m a) -> MonadFail m
    forall {m :: * -> *}. MonadFail m => Monad (BlockT m)
    forall (m :: * -> *) a. MonadFail m => String -> BlockT m a
    fail :: forall a. String -> BlockT m a
    $cfail :: forall (m :: * -> *) a. MonadFail m => String -> BlockT m a
    Fail.MonadFail
               , Monad (BlockT m)
    BlockT m TCState
    Monad (BlockT m)
    -> BlockT m TCState
    -> (forall a b.
        Lens' a TCState -> (a -> a) -> BlockT m b -> BlockT m b)
    -> (forall a. (TCState -> TCState) -> BlockT m a -> BlockT m a)
    -> ReadTCState (BlockT m)
    forall a. (TCState -> TCState) -> BlockT m a -> BlockT m a
    forall a b. Lens' a TCState -> (a -> a) -> BlockT m b -> BlockT m b
    forall (m :: * -> *).
    Monad m
    -> m TCState
    -> (forall a b. Lens' a TCState -> (a -> a) -> m b -> m b)
    -> (forall a. (TCState -> TCState) -> m a -> m a)
    -> ReadTCState m
    forall {m :: * -> *}. ReadTCState m => Monad (BlockT m)
    forall (m :: * -> *). ReadTCState m => BlockT m TCState
    forall (m :: * -> *) a.
    ReadTCState m =>
    (TCState -> TCState) -> BlockT m a -> BlockT m a
    forall (m :: * -> *) a b.
    ReadTCState m =>
    Lens' a TCState -> (a -> a) -> BlockT m b -> BlockT m b
    withTCState :: forall a. (TCState -> TCState) -> BlockT m a -> BlockT m a
    $cwithTCState :: forall (m :: * -> *) a.
    ReadTCState m =>
    (TCState -> TCState) -> BlockT m a -> BlockT m a
    locallyTCState :: forall a b. Lens' a TCState -> (a -> a) -> BlockT m b -> BlockT m b
    $clocallyTCState :: forall (m :: * -> *) a b.
    ReadTCState m =>
    Lens' a TCState -> (a -> a) -> BlockT m b -> BlockT m b
    getTCState :: BlockT m TCState
    $cgetTCState :: forall (m :: * -> *). ReadTCState m => BlockT m TCState
    ReadTCState, Monad (BlockT m)
    Functor (BlockT m)
    Applicative (BlockT m)
    BlockT m PragmaOptions
    BlockT m CommandLineOptions
    Functor (BlockT m)
    -> Applicative (BlockT m)
    -> Monad (BlockT m)
    -> BlockT m PragmaOptions
    -> BlockT m CommandLineOptions
    -> HasOptions (BlockT m)
    forall (m :: * -> *).
    Functor m
    -> Applicative m
    -> Monad m
    -> m PragmaOptions
    -> m CommandLineOptions
    -> HasOptions m
    forall {m :: * -> *}. HasOptions m => Monad (BlockT m)
    forall {m :: * -> *}. HasOptions m => Functor (BlockT m)
    forall {m :: * -> *}. HasOptions m => Applicative (BlockT m)
    forall (m :: * -> *). HasOptions m => BlockT m PragmaOptions
    forall (m :: * -> *). HasOptions m => BlockT m CommandLineOptions
    commandLineOptions :: BlockT m CommandLineOptions
    $ccommandLineOptions :: forall (m :: * -> *). HasOptions m => BlockT m CommandLineOptions
    pragmaOptions :: BlockT m PragmaOptions
    $cpragmaOptions :: forall (m :: * -> *). HasOptions m => BlockT m PragmaOptions
    HasOptions
               , Monad (BlockT m)
    BlockT m TCEnv
    Monad (BlockT m)
    -> BlockT m TCEnv
    -> (forall a. (TCEnv -> TCEnv) -> BlockT m a -> BlockT m a)
    -> MonadTCEnv (BlockT m)
    forall a. (TCEnv -> TCEnv) -> BlockT m a -> BlockT m a
    forall (m :: * -> *).
    Monad m
    -> m TCEnv
    -> (forall a. (TCEnv -> TCEnv) -> m a -> m a)
    -> MonadTCEnv m
    forall {m :: * -> *}. MonadTCEnv m => Monad (BlockT m)
    forall (m :: * -> *). MonadTCEnv m => BlockT m TCEnv
    forall (m :: * -> *) a.
    MonadTCEnv m =>
    (TCEnv -> TCEnv) -> BlockT m a -> BlockT m a
    localTC :: forall a. (TCEnv -> TCEnv) -> BlockT m a -> BlockT m a
    $clocalTC :: forall (m :: * -> *) a.
    MonadTCEnv m =>
    (TCEnv -> TCEnv) -> BlockT m a -> BlockT m a
    askTC :: BlockT m TCEnv
    $caskTC :: forall (m :: * -> *). MonadTCEnv m => BlockT m TCEnv
    MonadTCEnv, Monad (BlockT m)
    BlockT m TCState
    Monad (BlockT m)
    -> BlockT m TCState
    -> (TCState -> BlockT m ())
    -> ((TCState -> TCState) -> BlockT m ())
    -> MonadTCState (BlockT m)
    TCState -> BlockT m ()
    (TCState -> TCState) -> BlockT m ()
    forall (m :: * -> *).
    Monad m
    -> m TCState
    -> (TCState -> m ())
    -> ((TCState -> TCState) -> m ())
    -> MonadTCState m
    forall {m :: * -> *}. MonadTCState m => Monad (BlockT m)
    forall (m :: * -> *). MonadTCState m => BlockT m TCState
    forall (m :: * -> *). MonadTCState m => TCState -> BlockT m ()
    forall (m :: * -> *).
    MonadTCState m =>
    (TCState -> TCState) -> BlockT m ()
    modifyTC :: (TCState -> TCState) -> BlockT m ()
    $cmodifyTC :: forall (m :: * -> *).
    MonadTCState m =>
    (TCState -> TCState) -> BlockT m ()
    putTC :: TCState -> BlockT m ()
    $cputTC :: forall (m :: * -> *). MonadTCState m => TCState -> BlockT m ()
    getTC :: BlockT m TCState
    $cgetTC :: forall (m :: * -> *). MonadTCState m => BlockT m TCState
    MonadTCState, Applicative (BlockT m)
    MonadIO (BlockT m)
    HasOptions (BlockT m)
    MonadTCState (BlockT m)
    MonadTCEnv (BlockT m)
    Applicative (BlockT m)
    -> MonadIO (BlockT m)
    -> MonadTCEnv (BlockT m)
    -> MonadTCState (BlockT m)
    -> HasOptions (BlockT m)
    -> (forall a. TCM a -> BlockT m a)
    -> MonadTCM (BlockT m)
    forall a. TCM a -> BlockT m a
    forall (tcm :: * -> *).
    Applicative tcm
    -> MonadIO tcm
    -> MonadTCEnv tcm
    -> MonadTCState tcm
    -> HasOptions tcm
    -> (forall a. TCM a -> tcm a)
    -> MonadTCM tcm
    forall {m :: * -> *}. MonadTCM m => Applicative (BlockT m)
    forall {m :: * -> *}. MonadTCM m => MonadIO (BlockT m)
    forall {m :: * -> *}. MonadTCM m => HasOptions (BlockT m)
    forall {m :: * -> *}. MonadTCM m => MonadTCState (BlockT m)
    forall {m :: * -> *}. MonadTCM m => MonadTCEnv (BlockT m)
    forall (m :: * -> *) a. MonadTCM m => TCM a -> BlockT m a
    liftTCM :: forall a. TCM a -> BlockT m a
    $cliftTCM :: forall (m :: * -> *) a. MonadTCM m => TCM a -> BlockT m a
    MonadTCM
               )

    instance Monad m => MonadBlock (BlockT m) where
      patternViolation :: forall a. Blocker -> BlockT m a
    patternViolation = ExceptT Blocker m a -> BlockT m a
    forall (m :: * -> *) a. ExceptT Blocker m a -> BlockT m a
    BlockT (ExceptT Blocker m a -> BlockT m a)
    -> (Blocker -> ExceptT Blocker m a) -> Blocker -> BlockT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Blocker -> ExceptT Blocker m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError
      catchPatternErr :: forall a. (Blocker -> BlockT m a) -> BlockT m a -> BlockT m a
    catchPatternErr Blocker -> BlockT m a
    h BlockT m a
    f = ExceptT Blocker m a -> BlockT m a
    forall (m :: * -> *) a. ExceptT Blocker m a -> BlockT m a
    BlockT (ExceptT Blocker m a -> BlockT m a)
    -> ExceptT Blocker m a -> BlockT m a
    forall a b. (a -> b) -> a -> b
    $ ExceptT Blocker m a
    -> (Blocker -> ExceptT Blocker m a) -> ExceptT Blocker m a
    forall e (m :: * -> *) a.
    MonadError e m =>
    m a -> (e -> m a) -> m a
    catchError (BlockT m a -> ExceptT Blocker m a
    forall (m :: * -> *) a. BlockT m a -> ExceptT Blocker m a
    unBlockT BlockT m a
    f) (BlockT m a -> ExceptT Blocker m a
    forall (m :: * -> *) a. BlockT m a -> ExceptT Blocker m a
    unBlockT (BlockT m a -> ExceptT Blocker m a)
    -> (Blocker -> BlockT m a) -> Blocker -> ExceptT Blocker m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Blocker -> BlockT m a
    h)

    instance Monad m => MonadBlock (ExceptT TCErr m) where
      patternViolation :: forall a. Blocker -> ExceptT TCErr m a
    patternViolation = TCErr -> ExceptT TCErr m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (TCErr -> ExceptT TCErr m a)
    -> (Blocker -> TCErr) -> Blocker -> ExceptT TCErr m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Blocker -> TCErr
    PatternErr
      catchPatternErr :: forall a.
    (Blocker -> ExceptT TCErr m a)
    -> ExceptT TCErr m a -> ExceptT TCErr m a
    catchPatternErr Blocker -> ExceptT TCErr m a
    h ExceptT TCErr m a
    f = ExceptT TCErr m a
    -> (TCErr -> ExceptT TCErr m a) -> ExceptT TCErr m a
    forall e (m :: * -> *) a.
    MonadError e m =>
    m a -> (e -> m a) -> m a
    catchError ExceptT TCErr m a
    f ((TCErr -> ExceptT TCErr m a) -> ExceptT TCErr m a)
    -> (TCErr -> ExceptT TCErr m a) -> ExceptT TCErr m a
    forall a b. (a -> b) -> a -> b
    $ \case
        PatternErr Blocker
    b -> Blocker -> ExceptT TCErr m a
    h Blocker
    b
        TCErr
    err          -> TCErr -> ExceptT TCErr m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError TCErr
    err

    runBlocked :: Monad m => BlockT m a -> m (Either Blocker a)
    runBlocked :: forall (m :: * -> *) a.
    Monad m =>
    BlockT m a -> m (Either Blocker a)
    runBlocked = ExceptT Blocker m a -> m (Either Blocker a)
    forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
    runExceptT (ExceptT Blocker m a -> m (Either Blocker a))
    -> (BlockT m a -> ExceptT Blocker m a)
    -> BlockT m a
    -> m (Either Blocker a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . BlockT m a -> ExceptT Blocker m a
    forall (m :: * -> *) a. BlockT m a -> ExceptT Blocker m a
    unBlockT

    instance MonadBlock m => MonadBlock (MaybeT m) where
      catchPatternErr :: forall a. (Blocker -> MaybeT m a) -> MaybeT m a -> MaybeT m a
    catchPatternErr Blocker -> MaybeT m a
    h MaybeT m a
    m = m (Maybe a) -> MaybeT m a
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (m (Maybe a) -> MaybeT m a) -> m (Maybe a) -> MaybeT m a
    forall a b. (a -> b) -> a -> b
    $ (Blocker -> m (Maybe a)) -> m (Maybe a) -> m (Maybe a)
    forall (m :: * -> *) a.
    MonadBlock m =>
    (Blocker -> m a) -> m a -> m a
    catchPatternErr (MaybeT m a -> m (Maybe a)
    forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
    runMaybeT (MaybeT m a -> m (Maybe a))
    -> (Blocker -> MaybeT m a) -> Blocker -> m (Maybe a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Blocker -> MaybeT m a
    h) (m (Maybe a) -> m (Maybe a)) -> m (Maybe a) -> m (Maybe a)
    forall a b. (a -> b) -> a -> b
    $ MaybeT m a -> m (Maybe a)
    forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
    runMaybeT MaybeT m a
    m

    instance MonadBlock m => MonadBlock (ReaderT e m) where
      catchPatternErr :: forall a.
    (Blocker -> ReaderT e m a) -> ReaderT e m a -> ReaderT e m a
    catchPatternErr Blocker -> ReaderT e m a
    h ReaderT e m a
    m = (e -> m a) -> ReaderT e m a
    forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
    ReaderT ((e -> m a) -> ReaderT e m a) -> (e -> m a) -> ReaderT e m a
    forall a b. (a -> b) -> a -> b
    $ \ e
    e ->
        let run :: ReaderT e m a -> m a
    run = (ReaderT e m a -> e -> m a) -> e -> ReaderT e m a -> m a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ReaderT e m a -> e -> m a
    forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
    runReaderT e
    e in (Blocker -> m a) -> m a -> m a
    forall (m :: * -> *) a.
    MonadBlock m =>
    (Blocker -> m a) -> m a -> m a
    catchPatternErr (ReaderT e m a -> m a
    run (ReaderT e m a -> m a)
    -> (Blocker -> ReaderT e m a) -> Blocker -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Blocker -> ReaderT e m a
    h) (ReaderT e m a -> m a
    run ReaderT e m a
    m)

    ---------------------------------------------------------------------------
    -- * Type checking monad transformer
    ---------------------------------------------------------------------------

    -- | The type checking monad transformer.
    -- Adds readonly 'TCEnv' and mutable 'TCState'.
    newtype TCMT m a = TCM { forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM :: IORef TCState -> TCEnv -> m a }

    -- | Type checking monad.
    type TCM = TCMT IO

    {-# SPECIALIZE INLINE mapTCMT :: (forall a. IO a -> IO a) -> TCM a -> TCM a #-}
    mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a
    mapTCMT :: forall (m :: * -> *) (n :: * -> *) a.
    (forall a. m a -> n a) -> TCMT m a -> TCMT n a
    mapTCMT forall a. m a -> n a
    f (TCM IORef TCState -> TCEnv -> m a
    m) = (IORef TCState -> TCEnv -> n a) -> TCMT n a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> n a) -> TCMT n a)
    -> (IORef TCState -> TCEnv -> n a) -> TCMT n a
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    s TCEnv
    e -> m a -> n a
    forall a. m a -> n a
    f (IORef TCState -> TCEnv -> m a
    m IORef TCState
    s TCEnv
    e)

    pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a
    pureTCM :: forall (m :: * -> *) a.
    MonadIO m =>
    (TCState -> TCEnv -> a) -> TCMT m a
    pureTCM TCState -> TCEnv -> a
    f = (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m a) -> TCMT m a)
    -> (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    r TCEnv
    e -> do
      TCState
    s <- IO TCState -> m TCState
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TCState -> m TCState) -> IO TCState -> m TCState
    forall a b. (a -> b) -> a -> b
    $ IORef TCState -> IO TCState
    forall a. IORef a -> IO a
    readIORef IORef TCState
    r
      a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (TCState -> TCEnv -> a
    f TCState
    s TCEnv
    e)

    -- One goal of the definitions and pragmas below is to inline the
    -- monad operations as much as possible. This doesn't seem to have a
    -- large effect on the performance of the normal executable, but (at
    -- least on one machine/configuration) it has a massive effect on the
    -- performance of the profiling executable [1], and reduces the time
    -- attributed to bind from over 90% to about 25%.
    --
    -- [1] When compiled with -auto-all and run with -p: roughly 750%
    -- faster for one example.

    returnTCMT :: Applicative m => a -> TCMT m a
    returnTCMT :: forall (m :: * -> *) a. Applicative m => a -> TCMT m a
    returnTCMT = \a
    x -> (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m a) -> TCMT m a)
    -> (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall a b. (a -> b) -> a -> b
    $ \IORef TCState
    _ TCEnv
    _ -> a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    x
    {-# INLINE returnTCMT #-}

    bindTCMT :: Monad m => TCMT m a -> (a -> TCMT m b) -> TCMT m b
    bindTCMT :: forall (m :: * -> *) a b.
    Monad m =>
    TCMT m a -> (a -> TCMT m b) -> TCMT m b
    bindTCMT = \(TCM IORef TCState -> TCEnv -> m a
    m) a -> TCMT m b
    k -> (IORef TCState -> TCEnv -> m b) -> TCMT m b
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m b) -> TCMT m b)
    -> (IORef TCState -> TCEnv -> m b) -> TCMT m b
    forall a b. (a -> b) -> a -> b
    $ \IORef TCState
    r TCEnv
    e -> IORef TCState -> TCEnv -> m a
    m IORef TCState
    r TCEnv
    e m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \a
    x -> TCMT m b -> IORef TCState -> TCEnv -> m b
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM (a -> TCMT m b
    k a
    x) IORef TCState
    r TCEnv
    e
    {-# INLINE bindTCMT #-}

    thenTCMT :: Applicative m => TCMT m a -> TCMT m b -> TCMT m b
    thenTCMT :: forall (m :: * -> *) a b.
    Applicative m =>
    TCMT m a -> TCMT m b -> TCMT m b
    thenTCMT = \(TCM IORef TCState -> TCEnv -> m a
    m1) (TCM IORef TCState -> TCEnv -> m b
    m2) -> (IORef TCState -> TCEnv -> m b) -> TCMT m b
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m b) -> TCMT m b)
    -> (IORef TCState -> TCEnv -> m b) -> TCMT m b
    forall a b. (a -> b) -> a -> b
    $ \IORef TCState
    r TCEnv
    e -> IORef TCState -> TCEnv -> m a
    m1 IORef TCState
    r TCEnv
    e m a -> m b -> m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> IORef TCState -> TCEnv -> m b
    m2 IORef TCState
    r TCEnv
    e
    {-# INLINE thenTCMT #-}

    instance Functor m => Functor (TCMT m) where
      fmap :: forall a b. (a -> b) -> TCMT m a -> TCMT m b
    fmap = (a -> b) -> TCMT m a -> TCMT m b
    forall (m :: * -> *) a b.
    Functor m =>
    (a -> b) -> TCMT m a -> TCMT m b
    fmapTCMT

    fmapTCMT :: Functor m => (a -> b) -> TCMT m a -> TCMT m b
    fmapTCMT :: forall (m :: * -> *) a b.
    Functor m =>
    (a -> b) -> TCMT m a -> TCMT m b
    fmapTCMT = \a -> b
    f (TCM IORef TCState -> TCEnv -> m a
    m) -> (IORef TCState -> TCEnv -> m b) -> TCMT m b
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m b) -> TCMT m b)
    -> (IORef TCState -> TCEnv -> m b) -> TCMT m b
    forall a b. (a -> b) -> a -> b
    $ \IORef TCState
    r TCEnv
    e -> (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> b
    f (IORef TCState -> TCEnv -> m a
    m IORef TCState
    r TCEnv
    e)
    {-# INLINE fmapTCMT #-}

    instance Applicative m => Applicative (TCMT m) where
      pure :: forall a. a -> TCMT m a
    pure  = a -> TCMT m a
    forall (m :: * -> *) a. Applicative m => a -> TCMT m a
    returnTCMT
      <*> :: forall a b. TCMT m (a -> b) -> TCMT m a -> TCMT m b
    (<*>) = TCMT m (a -> b) -> TCMT m a -> TCMT m b
    forall (m :: * -> *) a b.
    Applicative m =>
    TCMT m (a -> b) -> TCMT m a -> TCMT m b
    apTCMT

    apTCMT :: Applicative m => TCMT m (a -> b) -> TCMT m a -> TCMT m b
    apTCMT :: forall (m :: * -> *) a b.
    Applicative m =>
    TCMT m (a -> b) -> TCMT m a -> TCMT m b
    apTCMT = \(TCM IORef TCState -> TCEnv -> m (a -> b)
    mf) (TCM IORef TCState -> TCEnv -> m a
    m) -> (IORef TCState -> TCEnv -> m b) -> TCMT m b
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m b) -> TCMT m b)
    -> (IORef TCState -> TCEnv -> m b) -> TCMT m b
    forall a b. (a -> b) -> a -> b
    $ \IORef TCState
    r TCEnv
    e -> IORef TCState -> TCEnv -> m (a -> b)
    mf IORef TCState
    r TCEnv
    e m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> IORef TCState -> TCEnv -> m a
    m IORef TCState
    r TCEnv
    e
    {-# INLINE apTCMT #-}

    instance MonadTrans TCMT where
        lift :: forall (m :: * -> *) a. Monad m => m a -> TCMT m a
    lift m a
    m = (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m a) -> TCMT m a)
    -> (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall a b. (a -> b) -> a -> b
    $ \IORef TCState
    _ TCEnv
    _ -> m a
    m

    -- We want a special monad implementation of fail.
    #if __GLASGOW_HASKELL__ < 808
    instance MonadIO m => Monad (TCMT m) where
    #else
    -- Andreas, 2022-02-02, issue #5659:
    -- @transformers-0.6@ requires exactly a @Monad@ superclass constraint here
    -- if we want @instance MonadTrans TCMT@.
    instance Monad m => Monad (TCMT m) where
    #endif
        return :: forall a. a -> TCMT m a
    return = a -> TCMT m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
        >>= :: forall a b. TCMT m a -> (a -> TCMT m b) -> TCMT m b
    (>>=)  = TCMT m a -> (a -> TCMT m b) -> TCMT m b
    forall (m :: * -> *) a b.
    Monad m =>
    TCMT m a -> (a -> TCMT m b) -> TCMT m b
    bindTCMT
        >> :: forall a b. TCMT m a -> TCMT m b -> TCMT m b
    (>>)   = TCMT m a -> TCMT m b -> TCMT m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    (*>)
    #if __GLASGOW_HASKELL__ < 808
        fail   = Fail.fail
    #endif

    instance MonadIO m => Fail.MonadFail (TCMT m) where
      fail :: forall a. String -> TCMT m a
    fail = String -> TCMT m a
    forall (tcm :: * -> *) a.
    (HasCallStack, MonadTCM tcm) =>
    String -> tcm a
    internalError

    instance MonadIO m => MonadIO (TCMT m) where
      liftIO :: forall a. IO a -> TCMT m a
    liftIO IO a
    m = (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m a) -> TCMT m a)
    -> (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    s TCEnv
    env -> do
        IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO a -> m a) -> IO a -> m a
    forall a b. (a -> b) -> a -> b
    $ IORef TCState -> Range -> IO a -> IO a
    forall {a}. IORef TCState -> Range -> IO a -> IO a
    wrap IORef TCState
    s (TCEnv -> Range
    envRange TCEnv
    env) (IO a -> IO a) -> IO a -> IO a
    forall a b. (a -> b) -> a -> b
    $ do
          a
    x <- IO a
    m
          a
    x a -> IO a -> IO a
    `seq` a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x
        where
          wrap :: IORef TCState -> Range -> IO a -> IO a
    wrap IORef TCState
    s Range
    r IO a
    m = IO a -> (IOException -> IO a) -> IO a
    forall e a. Exception e => IO a -> (e -> IO a) -> IO a
    E.catch IO a
    m ((IOException -> IO a) -> IO a) -> (IOException -> IO a) -> IO a
    forall a b. (a -> b) -> a -> b
    $ \ IOException
    err -> do
            TCState
    s <- IORef TCState -> IO TCState
    forall a. IORef a -> IO a
    readIORef IORef TCState
    s
            TCErr -> IO a
    forall e a. Exception e => e -> IO a
    E.throwIO (TCErr -> IO a) -> TCErr -> IO a
    forall a b. (a -> b) -> a -> b
    $ TCState -> Range -> IOException -> TCErr
    IOException TCState
    s Range
    r IOException
    err

    instance MonadIO m => MonadTCEnv (TCMT m) where
      askTC :: TCMT m TCEnv
    askTC             = (IORef TCState -> TCEnv -> m TCEnv) -> TCMT m TCEnv
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m TCEnv) -> TCMT m TCEnv)
    -> (IORef TCState -> TCEnv -> m TCEnv) -> TCMT m TCEnv
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    _ TCEnv
    e -> TCEnv -> m TCEnv
    forall (m :: * -> *) a. Monad m => a -> m a
    return TCEnv
    e
      localTC :: forall a. (TCEnv -> TCEnv) -> TCMT m a -> TCMT m a
    localTC TCEnv -> TCEnv
    f (TCM IORef TCState -> TCEnv -> m a
    m) = (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m a) -> TCMT m a)
    -> (IORef TCState -> TCEnv -> m a) -> TCMT m a
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    s TCEnv
    e -> IORef TCState -> TCEnv -> m a
    m IORef TCState
    s (TCEnv -> TCEnv
    f TCEnv
    e)

    instance MonadIO m => MonadTCState (TCMT m) where
      getTC :: TCMT m TCState
    getTC   = (IORef TCState -> TCEnv -> m TCState) -> TCMT m TCState
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m TCState) -> TCMT m TCState)
    -> (IORef TCState -> TCEnv -> m TCState) -> TCMT m TCState
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    r TCEnv
    _e -> IO TCState -> m TCState
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IORef TCState -> IO TCState
    forall a. IORef a -> IO a
    readIORef IORef TCState
    r)
      putTC :: TCState -> TCMT m ()
    putTC TCState
    s = (IORef TCState -> TCEnv -> m ()) -> TCMT m ()
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> m ()) -> TCMT m ())
    -> (IORef TCState -> TCEnv -> m ()) -> TCMT m ()
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    r TCEnv
    _e -> IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IORef TCState -> TCState -> IO ()
    forall a. IORef a -> a -> IO ()
    writeIORef IORef TCState
    r TCState
    s)
      modifyTC :: (TCState -> TCState) -> TCMT m ()
    modifyTC TCState -> TCState
    f = TCState -> TCMT m ()
    forall (m :: * -> *). MonadTCState m => TCState -> m ()
    putTC (TCState -> TCMT m ())
    -> (TCState -> TCState) -> TCState -> TCMT m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCState -> TCState
    f (TCState -> TCMT m ()) -> TCMT m TCState -> TCMT m ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< TCMT m TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC

    instance MonadIO m => ReadTCState (TCMT m) where
      getTCState :: TCMT m TCState
    getTCState = TCMT m TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC
      locallyTCState :: forall a b. Lens' a TCState -> (a -> a) -> TCMT m b -> TCMT m b
    locallyTCState Lens' a TCState
    l a -> a
    f = TCMT m a -> (a -> TCMT m ()) -> TCMT m b -> TCMT m b
    forall (m :: * -> *) a b.
    Monad m =>
    m a -> (a -> m ()) -> m b -> m b
    bracket_ (Lens' a TCState -> TCMT m a
    forall (m :: * -> *) a. ReadTCState m => Lens' a TCState -> m a
    useTC Lens' a TCState
    l TCMT m a -> TCMT m () -> TCMT m a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Lens' a TCState -> (a -> a) -> TCMT m ()
    forall (m :: * -> *) a.
    MonadTCState m =>
    Lens' a TCState -> (a -> a) -> m ()
    modifyTCLens Lens' a TCState
    l a -> a
    f) (Lens' a TCState -> a -> TCMT m ()
    forall (m :: * -> *) a.
    MonadTCState m =>
    Lens' a TCState -> a -> m ()
    setTCLens Lens' a TCState
    l)

    instance MonadBlock TCM where
      patternViolation :: forall a. Blocker -> TCM a
    patternViolation Blocker
    b = TCErr -> TCMT IO a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (Blocker -> TCErr
    PatternErr Blocker
    b)
      catchPatternErr :: forall a. (Blocker -> TCM a) -> TCM a -> TCM a
    catchPatternErr Blocker -> TCM a
    handle TCM a
    v =
           TCM a -> (TCErr -> TCM a) -> TCM a
    forall a. TCM a -> (TCErr -> TCM a) -> TCM a
    catchError_ TCM a
    v ((TCErr -> TCM a) -> TCM a) -> (TCErr -> TCM a) -> TCM a
    forall a b. (a -> b) -> a -> b
    $ \TCErr
    err ->
           case TCErr
    err of
                -- Not putting s (which should really be the what's already there) makes things go
                -- a lot slower (+20% total time on standard library). How is that possible??
                -- The problem is most likely that there are internal catchErrors which forgets the
                -- state. catchError should preserve the state on pattern violations.
               PatternErr Blocker
    u -> Blocker -> TCM a
    handle Blocker
    u
               TCErr
    _            -> TCErr -> TCM a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError TCErr
    err

    instance MonadError TCErr TCM where
      throwError :: forall a. TCErr -> TCM a
    throwError = IO a -> TCMT IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO a -> TCMT IO a) -> (TCErr -> IO a) -> TCErr -> TCMT IO a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCErr -> IO a
    forall e a. Exception e => e -> IO a
    E.throwIO
      catchError :: forall a. TCM a -> (TCErr -> TCM a) -> TCM a
    catchError TCM a
    m TCErr -> TCM a
    h = (IORef TCState -> TCEnv -> IO a) -> TCM a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> IO a) -> TCM a)
    -> (IORef TCState -> TCEnv -> IO a) -> TCM a
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    r TCEnv
    e -> do  -- now we are in the IO monad
        TCState
    oldState <- IORef TCState -> IO TCState
    forall a. IORef a -> IO a
    readIORef IORef TCState
    r
        TCM a -> IORef TCState -> TCEnv -> IO a
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM TCM a
    m IORef TCState
    r TCEnv
    e IO a -> (TCErr -> IO a) -> IO a
    forall e a. Exception e => IO a -> (e -> IO a) -> IO a
    `E.catch` \TCErr
    err -> do
          -- Reset the state, but do not forget changes to the persistent
          -- component. Not for pattern violations.
          case TCErr
    err of
            PatternErr{} -> () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
            TCErr
    _            ->
              IO () -> IO ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> IO ()) -> IO () -> IO ()
    forall a b. (a -> b) -> a -> b
    $ do
                TCState
    newState <- IORef TCState -> IO TCState
    forall a. IORef a -> IO a
    readIORef IORef TCState
    r
                IORef TCState -> TCState -> IO ()
    forall a. IORef a -> a -> IO ()
    writeIORef IORef TCState
    r (TCState -> IO ()) -> TCState -> IO ()
    forall a b. (a -> b) -> a -> b
    $ TCState
    oldState { stPersistentState :: PersistentTCState
    stPersistentState = TCState -> PersistentTCState
    stPersistentState TCState
    newState }
          TCM a -> IORef TCState -> TCEnv -> IO a
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM (TCErr -> TCM a
    h TCErr
    err) IORef TCState
    r TCEnv
    e

    -- | Like 'catchError', but resets the state completely before running the handler.
    --   This means it also loses changes to the 'stPersistentState'.
    --
    --   The intended use is to catch internal errors during debug printing.
    --   In debug printing, we are not expecting state changes.
    instance CatchImpossible TCM where
      catchImpossibleJust :: forall b a.
    (Impossible -> Maybe b) -> TCM a -> (b -> TCM a) -> TCM a
    catchImpossibleJust Impossible -> Maybe b
    f TCM a
    m b -> TCM a
    h = (IORef TCState -> TCEnv -> IO a) -> TCM a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> IO a) -> TCM a)
    -> (IORef TCState -> TCEnv -> IO a) -> TCM a
    forall a b. (a -> b) -> a -> b
    $ \ IORef TCState
    r TCEnv
    e -> do
        -- save the state
        TCState
    s <- IORef TCState -> IO TCState
    forall a. IORef a -> IO a
    readIORef IORef TCState
    r
        (Impossible -> Maybe b) -> IO a -> (b -> IO a) -> IO a
    forall (m :: * -> *) b a.
    CatchImpossible m =>
    (Impossible -> Maybe b) -> m a -> (b -> m a) -> m a
    catchImpossibleJust Impossible -> Maybe b
    f (TCM a -> IORef TCState -> TCEnv -> IO a
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM TCM a
    m IORef TCState
    r TCEnv
    e) ((b -> IO a) -> IO a) -> (b -> IO a) -> IO a
    forall a b. (a -> b) -> a -> b
    $ \ b
    err -> do
          IORef TCState -> TCState -> IO ()
    forall a. IORef a -> a -> IO ()
    writeIORef IORef TCState
    r TCState
    s
          TCM a -> IORef TCState -> TCEnv -> IO a
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM (b -> TCM a
    h b
    err) IORef TCState
    r TCEnv
    e

    instance MonadIO m => MonadReduce (TCMT m) where
      liftReduce :: forall a. ReduceM a -> TCMT m a
    liftReduce = TCM a -> TCMT m a
    forall (tcm :: * -> *) a. MonadTCM tcm => TCM a -> tcm a
    liftTCM (TCM a -> TCMT m a)
    -> (ReduceM a -> TCM a) -> ReduceM a -> TCMT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReduceM a -> TCM a
    forall a. ReduceM a -> TCM a
    runReduceM

    instance (IsString a, MonadIO m) => IsString (TCMT m a) where
      fromString :: String -> TCMT m a
    fromString String
    s = a -> TCMT m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (String -> a
    forall a. IsString a => String -> a
    fromString String
    s)

    -- | Strict (non-shortcut) semigroup.
    --
    --   Note that there might be a lazy alternative, e.g.,
    --   for TCM All we might want 'Agda.Utils.Monad.and2M' as concatenation,
    --   to shortcut conjunction in case we already have 'False'.
    --
    instance {-# OVERLAPPABLE #-} (MonadIO m, Semigroup a) => Semigroup (TCMT m a) where
      <> :: TCMT m a -> TCMT m a -> TCMT m a
    (<>) = (a -> a -> a) -> TCMT m a -> TCMT m a -> TCMT m a
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 a -> a -> a
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | Strict (non-shortcut) monoid.
    instance {-# OVERLAPPABLE #-} (MonadIO m, Semigroup a, Monoid a) => Monoid (TCMT m a) where
      mempty :: TCMT m a
    mempty  = a -> TCMT m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    forall a. Monoid a => a
    mempty
      mappend :: TCMT m a -> TCMT m a -> TCMT m a
    mappend = TCMT m a -> TCMT m a -> TCMT m a
    forall a. Semigroup a => a -> a -> a
    (<>)
      mconcat :: [TCMT m a] -> TCMT m a
    mconcat = [a] -> a
    forall a. Monoid a => [a] -> a
    mconcat ([a] -> a) -> ([TCMT m a] -> TCMT m [a]) -> [TCMT m a] -> TCMT m a
    forall (m :: * -> *) b c a.
    Functor m =>
    (b -> c) -> (a -> m b) -> a -> m c
    <.> [TCMT m a] -> TCMT m [a]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence

    instance {-# OVERLAPPABLE #-} (MonadIO m, Null a) => Null (TCMT m a) where
      empty :: TCMT m a
    empty = a -> TCMT m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    forall a. Null a => a
    empty
      null :: TCMT m a -> Bool
    null  = TCMT m a -> Bool
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    -- | Preserve the state of the failing computation.
    catchError_ :: TCM a -> (TCErr -> TCM a) -> TCM a
    catchError_ :: forall a. TCM a -> (TCErr -> TCM a) -> TCM a
    catchError_ TCM a
    m TCErr -> TCM a
    h = (IORef TCState -> TCEnv -> IO a) -> TCM a
    forall (m :: * -> *) a. (IORef TCState -> TCEnv -> m a) -> TCMT m a
    TCM ((IORef TCState -> TCEnv -> IO a) -> TCM a)
    -> (IORef TCState -> TCEnv -> IO a) -> TCM a
    forall a b. (a -> b) -> a -> b
    $ \IORef TCState
    r TCEnv
    e ->
      TCM a -> IORef TCState -> TCEnv -> IO a
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM TCM a
    m IORef TCState
    r TCEnv
    e
      IO a -> (TCErr -> IO a) -> IO a
    forall e a. Exception e => IO a -> (e -> IO a) -> IO a
    `E.catch` \TCErr
    err -> TCM a -> IORef TCState -> TCEnv -> IO a
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM (TCErr -> TCM a
    h TCErr
    err) IORef TCState
    r TCEnv
    e

    -- | Execute a finalizer even when an exception is thrown.
    --   Does not catch any errors.
    --   In case both the regular computation and the finalizer
    --   throw an exception, the one of the finalizer is propagated.
    finally_ :: TCM a -> TCM b -> TCM a
    finally_ :: forall a b. TCM a -> TCM b -> TCM a
    finally_ TCM a
    m TCM b
    f = do
        a
    x <- TCM a
    m TCM a -> (TCErr -> TCM a) -> TCM a
    forall a. TCM a -> (TCErr -> TCM a) -> TCM a
    `catchError_` \ TCErr
    err -> TCM b
    f TCM b -> TCM a -> TCM a
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> TCErr -> TCM a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError TCErr
    err
        b
    _ <- TCM b
    f
        a -> TCM a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    -- | Embedding a TCM computation.

    class ( Applicative tcm, MonadIO tcm
          , MonadTCEnv tcm
          , MonadTCState tcm
          , HasOptions tcm
          ) => MonadTCM tcm where
        liftTCM :: TCM a -> tcm a

        default liftTCM :: (MonadTCM m, MonadTrans t, tcm ~ t m) => TCM a -> tcm a
        liftTCM = m a -> t m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> t m a) -> (TCMT IO a -> m a) -> TCMT IO a -> t m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCMT IO a -> m a
    forall (tcm :: * -> *) a. MonadTCM tcm => TCM a -> tcm a
    liftTCM

    {-# RULES "liftTCM/id" liftTCM = id #-}
    instance MonadIO m => MonadTCM (TCMT m) where
        liftTCM :: forall a. TCM a -> TCMT m a
    liftTCM = (forall a. IO a -> m a) -> TCMT IO a -> TCMT m a
    forall (m :: * -> *) (n :: * -> *) a.
    (forall a. m a -> n a) -> TCMT m a -> TCMT n a
    mapTCMT forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO

    instance MonadTCM tcm => MonadTCM (ChangeT tcm)
    instance MonadTCM tcm => MonadTCM (ExceptT err tcm)
    instance MonadTCM tcm => MonadTCM (IdentityT tcm)
    instance MonadTCM tcm => MonadTCM (ListT tcm)
    instance MonadTCM tcm => MonadTCM (MaybeT tcm)
    instance MonadTCM tcm => MonadTCM (ReaderT r tcm)
    instance MonadTCM tcm => MonadTCM (StateT s tcm)
    instance (Monoid w, MonadTCM tcm) => MonadTCM (WriterT w tcm)

    -- | We store benchmark statistics in an IORef.
    --   This enables benchmarking pure computation, see
    --   "Agda.Benchmarking".
    instance MonadBench TCM where
      type BenchPhase TCM = Phase
      getBenchmark :: TCM (Benchmark (BenchPhase TCM))
    getBenchmark = IO Benchmark -> TCMT IO Benchmark
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Benchmark -> TCMT IO Benchmark)
    -> IO Benchmark -> TCMT IO Benchmark
    forall a b. (a -> b) -> a -> b
    $ IO Benchmark
    forall (m :: * -> *). MonadBench m => m (Benchmark (BenchPhase m))
    getBenchmark
      putBenchmark :: Benchmark (BenchPhase TCM) -> TCMT IO ()
    putBenchmark = IO () -> TCMT IO ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> TCMT IO ())
    -> (Benchmark -> IO ()) -> Benchmark -> TCMT IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Benchmark -> IO ()
    forall (m :: * -> *).
    MonadBench m =>
    Benchmark (BenchPhase m) -> m ()
    putBenchmark
      finally :: forall a b. TCM a -> TCM b -> TCM a
    finally = TCM b -> TCM c -> TCM b
    forall a b. TCM a -> TCM b -> TCM a
    finally_

    instance Null (TCM Doc) where
      empty :: TCM Doc
    empty = Doc -> TCM Doc
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc
    forall a. Null a => a
    empty
      null :: TCM Doc -> Bool
    null = TCM Doc -> Bool
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    internalError :: (HasCallStack, MonadTCM tcm) => String -> tcm a
    internalError :: forall (tcm :: * -> *) a.
    (HasCallStack, MonadTCM tcm) =>
    String -> tcm a
    internalError String
    s = (CallStack -> tcm a) -> tcm a
    forall b. HasCallStack => (CallStack -> b) -> b
    withCallerCallStack ((CallStack -> tcm a) -> tcm a) -> (CallStack -> tcm a) -> tcm a
    forall a b. (a -> b) -> a -> b
    $ \ CallStack
    loc ->
      TCM a -> tcm a
    forall (tcm :: * -> *) a. MonadTCM tcm => TCM a -> tcm a
    liftTCM (TCM a -> tcm a) -> TCM a -> tcm a
    forall a b. (a -> b) -> a -> b
    $ CallStack -> TypeError -> TCM a
    forall (m :: * -> *) a.
    MonadTCError m =>
    CallStack -> TypeError -> m a
    typeError' CallStack
    loc (TypeError -> TCM a) -> TypeError -> TCM a
    forall a b. (a -> b) -> a -> b
    $ String -> TypeError
    InternalError String
    s

    -- | The constraints needed for 'typeError' and similar.
    type MonadTCError m = (MonadTCEnv m, ReadTCState m, MonadError TCErr m)

    -- | Utility function for 1-arg constructed type errors.
    -- Note that the @HasCallStack@ constraint is on the *resulting* function.
    locatedTypeError :: MonadTCError m => (a -> TypeError) -> (HasCallStack => a -> m b)
    locatedTypeError :: forall (m :: * -> *) a b.
    MonadTCError m =>
    (a -> TypeError) -> HasCallStack => a -> m b
    locatedTypeError a -> TypeError
    f a
    e = (CallStack -> m b) -> m b
    forall b. HasCallStack => (CallStack -> b) -> b
    withCallerCallStack ((CallStack -> TypeError -> m b) -> TypeError -> CallStack -> m b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip CallStack -> TypeError -> m b
    forall (m :: * -> *) a.
    MonadTCError m =>
    CallStack -> TypeError -> m a
    typeError' (a -> TypeError
    f a
    e))

    genericError :: (HasCallStack, MonadTCError m) => String -> m a
    genericError :: forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    String -> m a
    genericError = (String -> TypeError) -> HasCallStack => String -> m a
    forall (m :: * -> *) a b.
    MonadTCError m =>
    (a -> TypeError) -> HasCallStack => a -> m b
    locatedTypeError String -> TypeError
    GenericError

    {-# SPECIALIZE genericDocError :: Doc -> TCM a #-}
    genericDocError :: (HasCallStack, MonadTCError m) => Doc -> m a
    genericDocError :: forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    Doc -> m a
    genericDocError = (Doc -> TypeError) -> HasCallStack => Doc -> m a
    forall (m :: * -> *) a b.
    MonadTCError m =>
    (a -> TypeError) -> HasCallStack => a -> m b
    locatedTypeError Doc -> TypeError
    GenericDocError

    {-# SPECIALIZE typeError' :: CallStack -> TypeError -> TCM a #-}
    typeError' :: MonadTCError m => CallStack -> TypeError -> m a
    typeError' :: forall (m :: * -> *) a.
    MonadTCError m =>
    CallStack -> TypeError -> m a
    typeError' CallStack
    loc TypeError
    err = TCErr -> m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (TCErr -> m a) -> m TCErr -> m a
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< CallStack -> TypeError -> m TCErr
    forall (m :: * -> *).
    (MonadTCEnv m, ReadTCState m) =>
    CallStack -> TypeError -> m TCErr
    typeError'_ CallStack
    loc TypeError
    err

    {-# SPECIALIZE typeError :: HasCallStack => TypeError -> TCM a #-}
    typeError :: (HasCallStack, MonadTCError m) => TypeError -> m a
    typeError :: forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError TypeError
    err = (CallStack -> m a) -> m a
    forall b. HasCallStack => (CallStack -> b) -> b
    withCallerCallStack ((CallStack -> m a) -> m a) -> (CallStack -> m a) -> m a
    forall a b. (a -> b) -> a -> b
    $ \CallStack
    loc -> TCErr -> m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (TCErr -> m a) -> m TCErr -> m a
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< CallStack -> TypeError -> m TCErr
    forall (m :: * -> *).
    (MonadTCEnv m, ReadTCState m) =>
    CallStack -> TypeError -> m TCErr
    typeError'_ CallStack
    loc TypeError
    err

    {-# SPECIALIZE typeError'_ :: CallStack -> TypeError -> TCM TCErr #-}
    typeError'_ :: (MonadTCEnv m, ReadTCState m) => CallStack -> TypeError -> m TCErr
    typeError'_ :: forall (m :: * -> *).
    (MonadTCEnv m, ReadTCState m) =>
    CallStack -> TypeError -> m TCErr
    typeError'_ CallStack
    loc TypeError
    err = CallStack -> TCState -> Closure TypeError -> TCErr
    TypeError CallStack
    loc (TCState -> Closure TypeError -> TCErr)
    -> m TCState -> m (Closure TypeError -> TCErr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m TCState
    forall (m :: * -> *). ReadTCState m => m TCState
    getTCState m (Closure TypeError -> TCErr) -> m (Closure TypeError) -> m TCErr
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> TypeError -> m (Closure TypeError)
    forall (m :: * -> *) a.
    (MonadTCEnv m, ReadTCState m) =>
    a -> m (Closure a)
    buildClosure TypeError
    err

    {-# SPECIALIZE typeError_ :: HasCallStack => TypeError -> TCM TCErr #-}
    typeError_ :: (HasCallStack, MonadTCEnv m, ReadTCState m) => TypeError -> m TCErr
    typeError_ :: forall (m :: * -> *).
    (HasCallStack, MonadTCEnv m, ReadTCState m) =>
    TypeError -> m TCErr
    typeError_ = (CallStack -> m TCErr) -> m TCErr
    forall b. HasCallStack => (CallStack -> b) -> b
    withCallerCallStack ((CallStack -> m TCErr) -> m TCErr)
    -> (TypeError -> CallStack -> m TCErr) -> TypeError -> m TCErr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (CallStack -> TypeError -> m TCErr)
    -> TypeError -> CallStack -> m TCErr
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip CallStack -> TypeError -> m TCErr
    forall (m :: * -> *).
    (MonadTCEnv m, ReadTCState m) =>
    CallStack -> TypeError -> m TCErr
    typeError'_

    -- | Running the type checking monad (most general form).
    {-# SPECIALIZE runTCM :: TCEnv -> TCState -> TCM a -> IO (a, TCState) #-}
    runTCM :: MonadIO m => TCEnv -> TCState -> TCMT m a -> m (a, TCState)
    runTCM :: forall (m :: * -> *) a.
    MonadIO m =>
    TCEnv -> TCState -> TCMT m a -> m (a, TCState)
    runTCM TCEnv
    e TCState
    s TCMT m a
    m = do
      IORef TCState
    r <- IO (IORef TCState) -> m (IORef TCState)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (IORef TCState) -> m (IORef TCState))
    -> IO (IORef TCState) -> m (IORef TCState)
    forall a b. (a -> b) -> a -> b
    $ TCState -> IO (IORef TCState)
    forall a. a -> IO (IORef a)
    newIORef TCState
    s
      a
    a <- TCMT m a -> IORef TCState -> TCEnv -> m a
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM TCMT m a
    m IORef TCState
    r TCEnv
    e
      TCState
    s <- IO TCState -> m TCState
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TCState -> m TCState) -> IO TCState -> m TCState
    forall a b. (a -> b) -> a -> b
    $ IORef TCState -> IO TCState
    forall a. IORef a -> IO a
    readIORef IORef TCState
    r
      (a, TCState) -> m (a, TCState)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    a, TCState
    s)

    -- | Running the type checking monad on toplevel (with initial state).
    runTCMTop :: TCM a -> IO (Either TCErr a)
    runTCMTop :: forall a. TCM a -> IO (Either TCErr a)
    runTCMTop TCM a
    m = (a -> Either TCErr a
    forall a b. b -> Either a b
    Right (a -> Either TCErr a) -> IO a -> IO (Either TCErr a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCM a -> IO a
    forall (m :: * -> *) a. MonadIO m => TCMT m a -> m a
    runTCMTop' TCM a
    m) IO (Either TCErr a)
    -> (TCErr -> IO (Either TCErr a)) -> IO (Either TCErr a)
    forall e a. Exception e => IO a -> (e -> IO a) -> IO a
    `E.catch` (Either TCErr a -> IO (Either TCErr a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Either TCErr a -> IO (Either TCErr a))
    -> (TCErr -> Either TCErr a) -> TCErr -> IO (Either TCErr a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TCErr -> Either TCErr a
    forall a b. a -> Either a b
    Left)

    runTCMTop' :: MonadIO m => TCMT m a -> m a
    runTCMTop' :: forall (m :: * -> *) a. MonadIO m => TCMT m a -> m a
    runTCMTop' TCMT m a
    m = do
      IORef TCState
    r <- IO (IORef TCState) -> m (IORef TCState)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (IORef TCState) -> m (IORef TCState))
    -> IO (IORef TCState) -> m (IORef TCState)
    forall a b. (a -> b) -> a -> b
    $ TCState -> IO (IORef TCState)
    forall a. a -> IO (IORef a)
    newIORef TCState
    initState
      TCMT m a -> IORef TCState -> TCEnv -> m a
    forall (m :: * -> *) a. TCMT m a -> IORef TCState -> TCEnv -> m a
    unTCM TCMT m a
    m IORef TCState
    r TCEnv
    initEnv

    -- | 'runSafeTCM' runs a safe 'TCM' action (a 'TCM' action which
    --   cannot fail, except that it might raise 'IOException's) in the
    --   initial environment.

    runSafeTCM :: TCM a -> TCState -> IO (a, TCState)
    runSafeTCM :: forall a. TCM a -> TCState -> IO (a, TCState)
    runSafeTCM TCM a
    m TCState
    st =
      TCEnv -> TCState -> TCM a -> IO (a, TCState)
    forall (m :: * -> *) a.
    MonadIO m =>
    TCEnv -> TCState -> TCMT m a -> m (a, TCState)
    runTCM TCEnv
    initEnv TCState
    st TCM a
    m IO (a, TCState) -> (TCErr -> IO (a, TCState)) -> IO (a, TCState)
    forall e a. Exception e => IO a -> (e -> IO a) -> IO a
    `E.catch` \(TCErr
    e :: TCErr) -> case TCErr
    e of
        IOException TCState
    _ Range
    _ IOException
    err -> IOException -> IO (a, TCState)
    forall e a. Exception e => e -> IO a
    E.throwIO IOException
    err
        TCErr
    _                   -> IO (a, TCState)
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    -- | Runs the given computation in a separate thread, with /a copy/ of
    -- the current state and environment.
    --
    -- Note that Agda sometimes uses actual, mutable state. If the
    -- computation given to @forkTCM@ tries to /modify/ this state, then
    -- bad things can happen, because accesses are not mutually exclusive.
    -- The @forkTCM@ function has been added mainly to allow the thread to
    -- /read/ (a snapshot of) the current state in a convenient way.
    --
    -- Note also that exceptions which are raised in the thread are not
    -- propagated to the parent, so the thread should not do anything
    -- important.

    forkTCM :: TCM a -> TCM ()
    forkTCM :: forall a. TCM a -> TCMT IO ()
    forkTCM TCM a
    m = do
      TCState
    s <- TCMT IO TCState
    forall (m :: * -> *). MonadTCState m => m TCState
    getTC
      TCEnv
    e <- TCMT IO TCEnv
    forall (m :: * -> *). MonadTCEnv m => m TCEnv
    askTC
      IO () -> TCMT IO ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> TCMT IO ()) -> IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ IO ThreadId -> IO ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (IO ThreadId -> IO ()) -> IO ThreadId -> IO ()
    forall a b. (a -> b) -> a -> b
    $ IO () -> IO ThreadId
    C.forkIO (IO () -> IO ThreadId) -> IO () -> IO ThreadId
    forall a b. (a -> b) -> a -> b
    $ IO (a, TCState) -> IO ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (IO (a, TCState) -> IO ()) -> IO (a, TCState) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ TCEnv -> TCState -> TCM a -> IO (a, TCState)
    forall (m :: * -> *) a.
    MonadIO m =>
    TCEnv -> TCState -> TCMT m a -> m (a, TCState)
    runTCM TCEnv
    e TCState
    s TCM a
    m

    ---------------------------------------------------------------------------
    -- * Names for generated definitions
    ---------------------------------------------------------------------------

    -- | Base name for patterns in telescopes
    patternInTeleName :: String
    patternInTeleName :: String
    patternInTeleName = String
    ".patternInTele"

    -- | Base name for extended lambda patterns
    extendedLambdaName :: String
    extendedLambdaName :: String
    extendedLambdaName = String
    ".extendedlambda"

    -- | Check whether we have an definition from an extended lambda.
    isExtendedLambdaName :: A.QName -> Bool
    isExtendedLambdaName :: QName -> Bool
    isExtendedLambdaName = (String
    extendedLambdaName String -> String -> Bool
    forall a. Eq a => [a] -> [a] -> Bool
    `List.isPrefixOf`) (String -> Bool) -> (QName -> String) -> QName -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> String
    forall a. Pretty a => a -> String
    prettyShow (Name -> String) -> (QName -> Name) -> QName -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> Name
    nameConcrete (Name -> Name) -> (QName -> Name) -> QName -> Name
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . QName -> Name
    qnameName

    -- | Name of absurdLambda definitions.
    absurdLambdaName :: String
    absurdLambdaName :: String
    absurdLambdaName = String
    ".absurdlambda"

    -- | Check whether we have an definition from an absurd lambda.
    isAbsurdLambdaName :: QName -> Bool
    isAbsurdLambdaName :: QName -> Bool
    isAbsurdLambdaName = (String
    absurdLambdaName String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) (String -> Bool) -> (QName -> String) -> QName -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> String
    forall a. Pretty a => a -> String
    prettyShow (Name -> String) -> (QName -> Name) -> QName -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . QName -> Name
    qnameName

    -- | Base name for generalized variable projections
    generalizedFieldName :: String
    generalizedFieldName :: String
    generalizedFieldName = String
    ".generalizedField-"

    -- | Check whether we have a generalized variable field
    getGeneralizedFieldName :: A.QName -> Maybe String
    getGeneralizedFieldName :: QName -> Maybe String
    getGeneralizedFieldName QName
    q
      | String
    generalizedFieldName String -> String -> Bool
    forall a. Eq a => [a] -> [a] -> Bool
    `List.isPrefixOf` String
    strName = String -> Maybe String
    forall a. a -> Maybe a
    Just (Int -> ShowS
    forall a. Int -> [a] -> [a]
    drop (String -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length String
    generalizedFieldName) String
    strName)
      | Bool
    otherwise                                      = Maybe String
    forall a. Maybe a
    Nothing
      where strName :: String
    strName = Name -> String
    forall a. Pretty a => a -> String
    prettyShow (Name -> String) -> Name -> String
    forall a b. (a -> b) -> a -> b
    $ Name -> Name
    nameConcrete (Name -> Name) -> Name -> Name
    forall a b. (a -> b) -> a -> b
    $ QName -> Name
    qnameName QName
    q

    ---------------------------------------------------------------------------
    -- * KillRange instances
    ---------------------------------------------------------------------------

    instance KillRange Signature where
      killRange :: KillRangeT Signature
    killRange (Sig Sections
    secs Definitions
    defs RewriteRuleMap
    rews) = (Sections -> Definitions -> RewriteRuleMap -> Signature)
    -> Sections -> Definitions -> RewriteRuleMap -> Signature
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 Sections -> Definitions -> RewriteRuleMap -> Signature
    Sig Sections
    secs Definitions
    defs RewriteRuleMap
    rews

    instance KillRange Sections where
      killRange :: KillRangeT Sections
    killRange = (Section -> Section) -> KillRangeT Sections
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Section -> Section
    forall a. KillRange a => KillRangeT a
    killRange

    instance KillRange Definitions where
      killRange :: KillRangeT Definitions
    killRange = (Definition -> Definition) -> KillRangeT Definitions
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Definition -> Definition
    forall a. KillRange a => KillRangeT a
    killRange

    instance KillRange RewriteRuleMap where
      killRange :: KillRangeT RewriteRuleMap
    killRange = ([RewriteRule] -> [RewriteRule]) -> KillRangeT RewriteRuleMap
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [RewriteRule] -> [RewriteRule]
    forall a. KillRange a => KillRangeT a
    killRange

    instance KillRange Section where
      killRange :: Section -> Section
    killRange (Section Telescope
    tel) = (Telescope -> Section) -> Telescope -> Section
    forall a b. KillRange a => (a -> b) -> a -> b
    killRange1 Telescope -> Section
    Section Telescope
    tel

    instance KillRange Definition where
      killRange :: Definition -> Definition
    killRange (Defn ArgInfo
    ai QName
    name Type
    t [Polarity]
    pols [Occurrence]
    occs NumGeneralizableArgs
    gens [Maybe Name]
    gpars [LocalDisplayForm]
    displ MutualId
    mut CompiledRepresentation
    compiled Maybe QName
    inst Bool
    copy Set QName
    ma Bool
    nc Bool
    inj Bool
    copat Blocked_
    blk Language
    lang Defn
    def) =
        (ArgInfo
     -> QName
     -> Type
     -> [Polarity]
     -> [Occurrence]
     -> NumGeneralizableArgs
     -> [Maybe Name]
     -> [LocalDisplayForm]
     -> MutualId
     -> CompiledRepresentation
     -> Maybe QName
     -> Bool
     -> Set QName
     -> Bool
     -> Bool
     -> Bool
     -> Blocked_
     -> Language
     -> Defn
     -> Definition)
    -> ArgInfo
    -> QName
    -> Type
    -> [Polarity]
    -> [Occurrence]
    -> NumGeneralizableArgs
    -> [Maybe Name]
    -> [LocalDisplayForm]
    -> MutualId
    -> CompiledRepresentation
    -> Maybe QName
    -> Bool
    -> Set QName
    -> Bool
    -> Bool
    -> Bool
    -> Blocked_
    -> Language
    -> Defn
    -> Definition
    forall a b c d e f g h i j k l m n o p q r s t.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n, KillRange o,
     KillRange p, KillRange q, KillRange r, KillRange s) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s
     -> t)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    -> p
    -> q
    -> r
    -> s
    -> t
    killRange19 ArgInfo
    -> QName
    -> Type
    -> [Polarity]
    -> [Occurrence]
    -> NumGeneralizableArgs
    -> [Maybe Name]
    -> [LocalDisplayForm]
    -> MutualId
    -> CompiledRepresentation
    -> Maybe QName
    -> Bool
    -> Set QName
    -> Bool
    -> Bool
    -> Bool
    -> Blocked_
    -> Language
    -> Defn
    -> Definition
    Defn ArgInfo
    ai QName
    name Type
    t [Polarity]
    pols [Occurrence]
    occs NumGeneralizableArgs
    gens [Maybe Name]
    gpars [LocalDisplayForm]
    displ MutualId
    mut CompiledRepresentation
    compiled Maybe QName
    inst Bool
    copy Set QName
    ma Bool
    nc Bool
    inj Bool
    copat Blocked_
    blk Language
    lang Defn
    def
        -- TODO clarify: Keep the range in the defName field?

    instance KillRange NumGeneralizableArgs where
      killRange :: NumGeneralizableArgs -> NumGeneralizableArgs
    killRange = NumGeneralizableArgs -> NumGeneralizableArgs
    forall a. a -> a
    id

    instance KillRange NLPat where
      killRange :: NLPat -> NLPat
    killRange (PVar Int
    x [Arg Int]
    y) = (Int -> [Arg Int] -> NLPat) -> Int -> [Arg Int] -> NLPat
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 Int -> [Arg Int] -> NLPat
    PVar Int
    x [Arg Int]
    y
      killRange (PDef QName
    x PElims
    y) = (QName -> PElims -> NLPat) -> QName -> PElims -> NLPat
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 QName -> PElims -> NLPat
    PDef QName
    x PElims
    y
      killRange (PLam ArgInfo
    x Abs NLPat
    y) = (ArgInfo -> Abs NLPat -> NLPat) -> ArgInfo -> Abs NLPat -> NLPat
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 ArgInfo -> Abs NLPat -> NLPat
    PLam ArgInfo
    x Abs NLPat
    y
      killRange (PPi Dom NLPType
    x Abs NLPType
    y)  = (Dom NLPType -> Abs NLPType -> NLPat)
    -> Dom NLPType -> Abs NLPType -> NLPat
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 Dom NLPType -> Abs NLPType -> NLPat
    PPi Dom NLPType
    x Abs NLPType
    y
      killRange (PSort NLPSort
    x)  = (NLPSort -> NLPat) -> NLPSort -> NLPat
    forall a b. KillRange a => (a -> b) -> a -> b
    killRange1 NLPSort -> NLPat
    PSort NLPSort
    x
      killRange (PBoundVar Int
    x PElims
    y) = (Int -> PElims -> NLPat) -> Int -> PElims -> NLPat
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 Int -> PElims -> NLPat
    PBoundVar Int
    x PElims
    y
      killRange (PTerm Term
    x)  = (Term -> NLPat) -> Term -> NLPat
    forall a b. KillRange a => (a -> b) -> a -> b
    killRange1 Term -> NLPat
    PTerm Term
    x

    instance KillRange NLPType where
      killRange :: NLPType -> NLPType
    killRange (NLPType NLPSort
    s NLPat
    a) = (NLPSort -> NLPat -> NLPType) -> NLPSort -> NLPat -> NLPType
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 NLPSort -> NLPat -> NLPType
    NLPType NLPSort
    s NLPat
    a

    instance KillRange NLPSort where
      killRange :: NLPSort -> NLPSort
    killRange (PType NLPat
    l) = (NLPat -> NLPSort) -> NLPat -> NLPSort
    forall a b. KillRange a => (a -> b) -> a -> b
    killRange1 NLPat -> NLPSort
    PType NLPat
    l
      killRange (PProp NLPat
    l) = (NLPat -> NLPSort) -> NLPat -> NLPSort
    forall a b. KillRange a => (a -> b) -> a -> b
    killRange1 NLPat -> NLPSort
    PProp NLPat
    l
      killRange s :: NLPSort
    s@(PInf IsFibrant
    f Integer
    n) = NLPSort
    s
      killRange NLPSort
    PSizeUniv = NLPSort
    PSizeUniv
      killRange NLPSort
    PLockUniv = NLPSort
    PLockUniv

    instance KillRange RewriteRule where
      killRange :: RewriteRule -> RewriteRule
    killRange (RewriteRule QName
    q Telescope
    gamma QName
    f PElims
    es Term
    rhs Type
    t Bool
    c) =
        (QName
     -> Telescope
     -> QName
     -> PElims
     -> Term
     -> Type
     -> Bool
     -> RewriteRule)
    -> QName
    -> Telescope
    -> QName
    -> PElims
    -> Term
    -> Type
    -> Bool
    -> RewriteRule
    forall a b c d e f g.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f) =>
    (a -> b -> c -> d -> e -> f -> g)
    -> a -> b -> c -> d -> e -> f -> g
    killRange6 QName
    -> Telescope
    -> QName
    -> PElims
    -> Term
    -> Type
    -> Bool
    -> RewriteRule
    RewriteRule QName
    q Telescope
    gamma QName
    f PElims
    es Term
    rhs Type
    t Bool
    c

    instance KillRange CompiledRepresentation where
      killRange :: KillRangeT CompiledRepresentation
    killRange = KillRangeT CompiledRepresentation
    forall a. a -> a
    id

    instance KillRange EtaEquality where
      killRange :: EtaEquality -> EtaEquality
    killRange = EtaEquality -> EtaEquality
    forall a. a -> a
    id

    instance KillRange System where
      killRange :: System -> System
    killRange (System Telescope
    tel [(Face, Term)]
    sys) = Telescope -> [(Face, Term)] -> System
    System (KillRangeT Telescope
    forall a. KillRange a => KillRangeT a
    killRange Telescope
    tel) (KillRangeT [(Face, Term)]
    forall a. KillRange a => KillRangeT a
    killRange [(Face, Term)]
    sys)

    instance KillRange ExtLamInfo where
      killRange :: ExtLamInfo -> ExtLamInfo
    killRange (ExtLamInfo ModuleName
    m Bool
    b Maybe System
    sys) = (ModuleName -> Bool -> Maybe System -> ExtLamInfo)
    -> ModuleName -> Bool -> Maybe System -> ExtLamInfo
    forall a b c d.
    (KillRange a, KillRange b, KillRange c) =>
    (a -> b -> c -> d) -> a -> b -> c -> d
    killRange3 ModuleName -> Bool -> Maybe System -> ExtLamInfo
    ExtLamInfo ModuleName
    m Bool
    b Maybe System
    sys

    instance KillRange FunctionFlag where
      killRange :: FunctionFlag -> FunctionFlag
    killRange = FunctionFlag -> FunctionFlag
    forall a. a -> a
    id

    instance KillRange CompKit where
      killRange :: CompKit -> CompKit
    killRange = CompKit -> CompKit
    forall a. a -> a
    id

    instance KillRange Defn where
      killRange :: Defn -> Defn
    killRange Defn
    def =
        case Defn
    def of
          Axiom Bool
    a -> Bool -> Defn
    Axiom Bool
    a
          DataOrRecSig Int
    n -> Int -> Defn
    DataOrRecSig Int
    n
          Defn
    GeneralizableVar -> Defn
    GeneralizableVar
          AbstractDefn{} -> Defn
    forall a. HasCallStack => a
    __IMPOSSIBLE__ -- only returned by 'getConstInfo'!
          Function [Clause]
    cls Maybe CompiledClauses
    comp Maybe SplitTree
    ct Maybe Compiled
    tt [Clause]
    covering FunctionInverse
    inv Maybe [QName]
    mut IsAbstract
    isAbs Delayed
    delayed Maybe Projection
    proj Set FunctionFlag
    flags Maybe Bool
    term Maybe ExtLamInfo
    extlam Maybe QName
    with ->
            ([Clause]
     -> Maybe CompiledClauses
     -> Maybe SplitTree
     -> Maybe Compiled
     -> [Clause]
     -> FunctionInverse
     -> Maybe [QName]
     -> IsAbstract
     -> Delayed
     -> Maybe Projection
     -> Set FunctionFlag
     -> Maybe Bool
     -> Maybe ExtLamInfo
     -> Maybe QName
     -> Defn)
    -> [Clause]
    -> Maybe CompiledClauses
    -> Maybe SplitTree
    -> Maybe Compiled
    -> [Clause]
    -> FunctionInverse
    -> Maybe [QName]
    -> IsAbstract
    -> Delayed
    -> Maybe Projection
    -> Set FunctionFlag
    -> Maybe Bool
    -> Maybe ExtLamInfo
    -> Maybe QName
    -> Defn
    forall a b c d e f g h i j k l m n o.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l, KillRange m, KillRange n) =>
    (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> i
    -> j
    -> k
    -> l
    -> m
    -> n
    -> o
    killRange14 [Clause]
    -> Maybe CompiledClauses
    -> Maybe SplitTree
    -> Maybe Compiled
    -> [Clause]
    -> FunctionInverse
    -> Maybe [QName]
    -> IsAbstract
    -> Delayed
    -> Maybe Projection
    -> Set FunctionFlag
    -> Maybe Bool
    -> Maybe ExtLamInfo
    -> Maybe QName
    -> Defn
    Function [Clause]
    cls Maybe CompiledClauses
    comp Maybe SplitTree
    ct Maybe Compiled
    tt [Clause]
    covering FunctionInverse
    inv Maybe [QName]
    mut IsAbstract
    isAbs Delayed
    delayed Maybe Projection
    proj Set FunctionFlag
    flags Maybe Bool
    term Maybe ExtLamInfo
    extlam Maybe QName
    with
          Datatype Int
    a Int
    b Maybe Clause
    c [QName]
    d Sort
    e Maybe [QName]
    f IsAbstract
    g [QName]
    h       -> (Int
     -> Int
     -> Maybe Clause
     -> [QName]
     -> Sort
     -> Maybe [QName]
     -> IsAbstract
     -> [QName]
     -> Defn)
    -> Int
    -> Int
    -> Maybe Clause
    -> [QName]
    -> Sort
    -> Maybe [QName]
    -> IsAbstract
    -> [QName]
    -> Defn
    forall a b c d e f g h.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g) =>
    (a -> b -> c -> d -> e -> f -> g -> h)
    -> a -> b -> c -> d -> e -> f -> g -> h
    killRange7 Int
    -> Int
    -> Maybe Clause
    -> [QName]
    -> Sort
    -> Maybe [QName]
    -> IsAbstract
    -> [QName]
    -> Defn
    Datatype Int
    a Int
    b Maybe Clause
    c [QName]
    d Sort
    e Maybe [QName]
    f IsAbstract
    g [QName]
    h
          Record Int
    a Maybe Clause
    b ConHead
    c Bool
    d [Dom QName]
    e Telescope
    f Maybe [QName]
    g EtaEquality
    h PatternOrCopattern
    i Maybe Induction
    j IsAbstract
    k CompKit
    l -> (Int
     -> Maybe Clause
     -> ConHead
     -> Bool
     -> [Dom QName]
     -> Telescope
     -> Maybe [QName]
     -> EtaEquality
     -> PatternOrCopattern
     -> Maybe Induction
     -> IsAbstract
     -> CompKit
     -> Defn)
    -> Int
    -> Maybe Clause
    -> ConHead
    -> Bool
    -> [Dom QName]
    -> Telescope
    -> Maybe [QName]
    -> EtaEquality
    -> PatternOrCopattern
    -> Maybe Induction
    -> IsAbstract
    -> CompKit
    -> Defn
    forall a b c d e f g h i j k l m.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j,
     KillRange k, KillRange l) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m
    killRange12 Int
    -> Maybe Clause
    -> ConHead
    -> Bool
    -> [Dom QName]
    -> Telescope
    -> Maybe [QName]
    -> EtaEquality
    -> PatternOrCopattern
    -> Maybe Induction
    -> IsAbstract
    -> CompKit
    -> Defn
    Record Int
    a Maybe Clause
    b ConHead
    c Bool
    d [Dom QName]
    e Telescope
    f Maybe [QName]
    g EtaEquality
    h PatternOrCopattern
    i Maybe Induction
    j IsAbstract
    k CompKit
    l
          Constructor Int
    a Int
    b ConHead
    c QName
    d IsAbstract
    e Induction
    f CompKit
    g Maybe [QName]
    h [IsForced]
    i Maybe [Bool]
    j-> (Int
     -> Int
     -> ConHead
     -> QName
     -> IsAbstract
     -> Induction
     -> CompKit
     -> Maybe [QName]
     -> [IsForced]
     -> Maybe [Bool]
     -> Defn)
    -> Int
    -> Int
    -> ConHead
    -> QName
    -> IsAbstract
    -> Induction
    -> CompKit
    -> Maybe [QName]
    -> [IsForced]
    -> Maybe [Bool]
    -> Defn
    forall a b c d e f g h i j k.
    (KillRange a, KillRange b, KillRange c, KillRange d, KillRange e,
     KillRange f, KillRange g, KillRange h, KillRange i, KillRange j) =>
    (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k)
    -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
    killRange10 Int
    -> Int
    -> ConHead
    -> QName
    -> IsAbstract
    -> Induction
    -> CompKit
    -> Maybe [QName]
    -> [IsForced]
    -> Maybe [Bool]
    -> Defn
    Constructor Int
    a Int
    b ConHead
    c QName
    d IsAbstract
    e Induction
    f CompKit
    g Maybe [QName]
    h [IsForced]
    i Maybe [Bool]
    j
          Primitive IsAbstract
    a String
    b [Clause]
    c FunctionInverse
    d Maybe CompiledClauses
    e            -> (IsAbstract
     -> String
     -> [Clause]
     -> FunctionInverse
     -> Maybe CompiledClauses
     -> Defn)
    -> IsAbstract
    -> String
    -> [Clause]
    -> FunctionInverse
    -> Maybe CompiledClauses
    -> Defn
    forall a b c d e f.
    (KillRange a, KillRange b, KillRange c, KillRange d,
     KillRange e) =>
    (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> f
    killRange5 IsAbstract
    -> String
    -> [Clause]
    -> FunctionInverse
    -> Maybe CompiledClauses
    -> Defn
    Primitive IsAbstract
    a String
    b [Clause]
    c FunctionInverse
    d Maybe CompiledClauses
    e
          PrimitiveSort String
    a Sort
    b              -> (String -> Sort -> Defn) -> String -> Sort -> Defn
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 String -> Sort -> Defn
    PrimitiveSort String
    a Sort
    b

    instance KillRange MutualId where
      killRange :: MutualId -> MutualId
    killRange = MutualId -> MutualId
    forall a. a -> a
    id

    instance KillRange c => KillRange (FunctionInverse' c) where
      killRange :: KillRangeT (FunctionInverse' c)
    killRange FunctionInverse' c
    NotInjective = FunctionInverse' c
    forall c. FunctionInverse' c
    NotInjective
      killRange (Inverse InversionMap c
    m)  = InversionMap c -> FunctionInverse' c
    forall c. InversionMap c -> FunctionInverse' c
    Inverse (InversionMap c -> FunctionInverse' c)
    -> InversionMap c -> FunctionInverse' c
    forall a b. (a -> b) -> a -> b
    $ KillRangeT (InversionMap c)
    forall k v. (KillRange k, KillRange v) => KillRangeT (Map k v)
    killRangeMap InversionMap c
    m

    instance KillRange TermHead where
      killRange :: TermHead -> TermHead
    killRange TermHead
    SortHead     = TermHead
    SortHead
      killRange TermHead
    PiHead       = TermHead
    PiHead
      killRange (ConsHead QName
    q) = QName -> TermHead
    ConsHead (QName -> TermHead) -> QName -> TermHead
    forall a b. (a -> b) -> a -> b
    $ KillRangeT QName
    forall a. KillRange a => KillRangeT a
    killRange QName
    q
      killRange h :: TermHead
    h@VarHead{}  = TermHead
    h
      killRange TermHead
    UnknownHead  = TermHead
    UnknownHead

    instance KillRange Projection where
      killRange :: Projection -> Projection
    killRange (Projection Maybe QName
    a QName
    b Arg QName
    c Int
    d ProjLams
    e) = (Maybe QName
     -> QName -> Arg QName -> Int -> ProjLams -> Projection)
    -> Maybe QName
    -> QName
    -> Arg QName
    -> Int
    -> ProjLams
    -> Projection
    forall a b c d e f.
    (KillRange a, KillRange b, KillRange c, KillRange d,
     KillRange e) =>
    (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> f
    killRange5 Maybe QName -> QName -> Arg QName -> Int -> ProjLams -> Projection
    Projection Maybe QName
    a QName
    b Arg QName
    c Int
    d ProjLams
    e

    instance KillRange ProjLams where
      killRange :: ProjLams -> ProjLams
    killRange = ProjLams -> ProjLams
    forall a. a -> a
    id

    instance KillRange a => KillRange (Open a) where
      killRange :: KillRangeT (Open a)
    killRange = (a -> a) -> KillRangeT (Open a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> a
    forall a. KillRange a => KillRangeT a
    killRange

    instance KillRange DisplayForm where
      killRange :: DisplayForm -> DisplayForm
    killRange (Display Int
    n [Elim]
    es DisplayTerm
    dt) = (Int -> [Elim] -> DisplayTerm -> DisplayForm)
    -> Int -> [Elim] -> DisplayTerm -> DisplayForm
    forall a b c d.
    (KillRange a, KillRange b, KillRange c) =>
    (a -> b -> c -> d) -> a -> b -> c -> d
    killRange3 Int -> [Elim] -> DisplayTerm -> DisplayForm
    Display Int
    n [Elim]
    es DisplayTerm
    dt

    instance KillRange Polarity where
      killRange :: Polarity -> Polarity
    killRange = Polarity -> Polarity
    forall a. a -> a
    id

    instance KillRange IsForced where
      killRange :: IsForced -> IsForced
    killRange = IsForced -> IsForced
    forall a. a -> a
    id

    instance KillRange DoGeneralize where
      killRange :: DoGeneralize -> DoGeneralize
    killRange = DoGeneralize -> DoGeneralize
    forall a. a -> a
    id

    instance KillRange DisplayTerm where
      killRange :: DisplayTerm -> DisplayTerm
    killRange DisplayTerm
    dt =
        case DisplayTerm
    dt of
          DWithApp DisplayTerm
    dt [DisplayTerm]
    dts [Elim]
    es -> (DisplayTerm -> [DisplayTerm] -> [Elim] -> DisplayTerm)
    -> DisplayTerm -> [DisplayTerm] -> [Elim] -> DisplayTerm
    forall a b c d.
    (KillRange a, KillRange b, KillRange c) =>
    (a -> b -> c -> d) -> a -> b -> c -> d
    killRange3 DisplayTerm -> [DisplayTerm] -> [Elim] -> DisplayTerm
    DWithApp DisplayTerm
    dt [DisplayTerm]
    dts [Elim]
    es
          DCon ConHead
    q ConInfo
    ci [Arg DisplayTerm]
    dts     -> (ConHead -> ConInfo -> [Arg DisplayTerm] -> DisplayTerm)
    -> ConHead -> ConInfo -> [Arg DisplayTerm] -> DisplayTerm
    forall a b c d.
    (KillRange a, KillRange b, KillRange c) =>
    (a -> b -> c -> d) -> a -> b -> c -> d
    killRange3 ConHead -> ConInfo -> [Arg DisplayTerm] -> DisplayTerm
    DCon ConHead
    q ConInfo
    ci [Arg DisplayTerm]
    dts
          DDef QName
    q [Elim' DisplayTerm]
    dts        -> (QName -> [Elim' DisplayTerm] -> DisplayTerm)
    -> QName -> [Elim' DisplayTerm] -> DisplayTerm
    forall a b c.
    (KillRange a, KillRange b) =>
    (a -> b -> c) -> a -> b -> c
    killRange2 QName -> [Elim' DisplayTerm] -> DisplayTerm
    DDef QName
    q [Elim' DisplayTerm]
    dts
          DDot Term
    v            -> (Term -> DisplayTerm) -> Term -> DisplayTerm
    forall a b. KillRange a => (a -> b) -> a -> b
    killRange1 Term -> DisplayTerm
    DDot Term
    v
          DTerm Term
    v           -> (Term -> DisplayTerm) -> Term -> DisplayTerm
    forall a b. KillRange a => (a -> b) -> a -> b
    killRange1 Term -> DisplayTerm
    DTerm Term
    v

    instance KillRange a => KillRange (Closure a) where
      killRange :: KillRangeT (Closure a)
    killRange = KillRangeT (Closure a)
    forall a. a -> a
    id

    ---------------------------------------------------------------------------
    -- NFData instances
    ---------------------------------------------------------------------------

    instance NFData NumGeneralizableArgs where
      rnf :: NumGeneralizableArgs -> ()
    rnf NumGeneralizableArgs
    NoGeneralizableArgs       = ()
      rnf (SomeGeneralizableArgs Int
    _) = ()

    instance NFData TCErr where
      rnf :: TCErr -> ()
    rnf (TypeError CallStack
    a TCState
    b Closure TypeError
    c)   = CallStack -> ()
    forall a. NFData a => a -> ()
    rnf CallStack
    a () -> () -> ()
    `seq` TCState -> ()
    forall a. NFData a => a -> ()
    rnf TCState
    b () -> () -> ()
    `seq` Closure TypeError -> ()
    forall a. NFData a => a -> ()
    rnf Closure TypeError
    c
      rnf (Exception Range
    a Doc
    b)     = Range -> ()
    forall a. NFData a => a -> ()
    rnf Range
    a () -> () -> ()
    `seq` Doc -> ()
    forall a. NFData a => a -> ()
    rnf Doc
    b
      rnf (IOException TCState
    a Range
    b IOException
    c) = TCState -> ()
    forall a. NFData a => a -> ()
    rnf TCState
    a () -> () -> ()
    `seq` Range -> ()
    forall a. NFData a => a -> ()
    rnf Range
    b () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf (IOException
    c IOException -> IOException -> Bool
    forall a. Eq a => a -> a -> Bool
    == IOException
    c)
                                -- At the time of writing there is no
                                -- NFData instance for E.IOException.
      rnf (PatternErr Blocker
    a)      = Blocker -> ()
    forall a. NFData a => a -> ()
    rnf Blocker
    a

    -- | This instance could be optimised, some things are guaranteed to
    -- be forced.

    instance NFData PreScopeState

    -- | This instance could be optimised, some things are guaranteed to
    -- be forced.

    instance NFData PostScopeState

    instance NFData TCState
    instance NFData DisambiguatedName
    instance NFData MutualBlock
    instance NFData PersistentTCState
    instance NFData LoadedFileCache
    instance NFData TypeCheckAction
    instance NFData ModuleCheckMode
    instance NFData ModuleInfo
    instance NFData ForeignCode
    instance NFData Interface
    instance NFData a => NFData (Closure a)
    instance NFData ProblemConstraint
    instance NFData Constraint
    instance NFData Signature
    instance NFData Comparison
    instance NFData CompareAs
    instance NFData a => NFData (Open a)
    instance NFData a => NFData (Judgement a)
    instance NFData DoGeneralize
    instance NFData GeneralizedValue
    instance NFData MetaVariable
    instance NFData Listener
    instance NFData MetaInstantiation
    instance NFData Frozen
    instance NFData PrincipalArgTypeMetas
    instance NFData TypeCheckingProblem
    instance NFData RunMetaOccursCheck
    instance NFData MetaInfo
    instance NFData InteractionPoint
    instance NFData InteractionPoints
    instance NFData Overapplied
    instance NFData t => NFData (IPBoundary' t)
    instance NFData IPClause
    instance NFData DisplayForm
    instance NFData DisplayTerm
    instance NFData NLPat
    instance NFData NLPType
    instance NFData NLPSort
    instance NFData RewriteRule
    instance NFData Definition
    instance NFData Polarity
    instance NFData IsForced
    instance NFData Projection
    instance NFData ProjLams
    instance NFData CompilerPragma
    instance NFData System
    instance NFData ExtLamInfo
    instance NFData EtaEquality
    instance NFData FunctionFlag
    instance NFData CompKit
    instance NFData Defn
    instance NFData Simplification
    instance NFData AllowedReduction
    instance NFData ReduceDefs
    instance NFData PrimFun
    instance NFData c => NFData (FunctionInverse' c)
    instance NFData TermHead
    instance NFData Call
    instance NFData pf => NFData (Builtin pf)
    instance NFData HighlightingLevel
    instance NFData HighlightingMethod
    instance NFData TCEnv
    instance NFData UnquoteFlags
    instance NFData AbstractMode
    instance NFData ExpandHidden
    instance NFData CandidateKind
    instance NFData Candidate
    instance NFData Warning
    instance NFData RecordFieldWarning
    instance NFData TCWarning
    instance NFData CallInfo
    instance NFData TerminationError
    instance NFData SplitError
    instance NFData NegativeUnification
    instance NFData UnificationFailure
    instance NFData UnquoteError
    instance NFData TypeError
    instance NFData LHSOrPatSyn