{-# 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.Except
import Control.Monad.State
import Control.Monad.Reader
import Control.Monad.Writer hiding ((<>))
import Control.Monad.Trans          ( MonadTrans(..), lift )
import Control.Monad.Trans.Control  ( MonadTransControl(..), liftThrough )
import Control.Monad.Trans.Identity
import Control.Monad.Trans.Maybe

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)) -> m b -> m 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)) -> m b -> m b)
-> ((a -> a) -> n (StT t b) -> n (StT t b))
-> (a -> a)
-> m b
-> m 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
  { 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
  { 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
  { 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
  { 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 -> TCMT IO (a, ConcreteNames)) -> TCMT IO a
forall (m :: * -> *) a r.
MonadTCState m =>
Lens' a TCState -> (a -> m (r, a)) -> m r
stateTCLensM Lens' ConcreteNames TCState
stConcreteNames ((ConcreteNames -> TCMT IO (a, ConcreteNames)) -> TCMT IO a)
-> (ConcreteNames -> TCMT IO (a, ConcreteNames)) -> TCMT IO a
forall a b. (a -> b) -> a -> b
$ StateT ConcreteNames TCM a
-> ConcreteNames -> TCMT IO (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)

---------------------------------------------------------------------------
-- ** 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
  | 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
      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
      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 this meta will be equated to @m@ when the latter is unblocked. See @blockedTermOnProblem@.
                }
  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) = FreeM a c -> FreeM a c
forall a b c (m :: * -> *) z.
MonadReader (FreeEnv' a b c) m =>
m z -> m z
underBinder ([Elim] -> FreeM a c
forall t a c. (Free t, IsVarSet a c) => t -> FreeM a c
freeVars' [Elim]
ps) FreeM a c -> FreeM a c -> FreeM a c
forall a. Monoid a => a -> a -> a
`mappend` Int -> FreeM a c -> FreeM a c
forall a b c (m :: * -> *) z.
MonadReader (FreeEnv' a b c) m =>
Int -> m z -> m z
underBinder' Int
n (DisplayTerm -> FreeM a 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
  { 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
  { 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?
          }
    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 { 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
                }

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
  { _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 }

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 }

---------------------------------------------------------------------------
-- ** 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 -> m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n a -> m a) -> (ReduceM a -> n a) -> ReduceM a -> m 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)) -> m a -> m 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)) -> m a -> m a)
-> ((TCEnv -> TCEnv) -> n (StT t a) -> n (StT t a))
-> (TCEnv -> TCEnv)
-> m a
-> m 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 () -> m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n () -> m ()) -> (TCState -> n ()) -> TCState -> m ()
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 () -> m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n () -> m ())
-> ((TCState -> TCState) -> n ()) -> (TCState -> TCState) -> m ()
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 -> m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (n a -> m a) -> (Blocker -> n a) -> Blocker -> m 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 :: MonadIO m => a -> TCMT m a
returnTCMT :: forall (m :: * -> *) a. MonadIO 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 (m :: * -> *) a. Monad m => a -> m a
return a
x
{-# INLINE returnTCMT #-}

bindTCMT :: MonadIO m => TCMT m a -> (a -> TCMT m b) -> TCMT m b
bindTCMT :: forall (m :: * -> *) a b.
MonadIO 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 :: MonadIO m => TCMT m a -> TCMT m b -> TCMT m b
thenTCMT :: forall (m :: * -> *) a b.
MonadIO 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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> IORef TCState -> TCEnv -> m b
m2 IORef TCState
r TCEnv
e
{-# INLINE thenTCMT #-}

instance MonadIO 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.
MonadIO m =>
(a -> b) -> TCMT m a -> TCMT m b
fmapTCMT

fmapTCMT :: MonadIO m => (a -> b) -> TCMT m a -> TCMT m b
fmapTCMT :: forall (m :: * -> *) a b.
MonadIO 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 MonadIO m => Applicative (TCMT m) where
  pure :: forall a. a -> TCMT m a
pure  = a -> TCMT m a
forall (m :: * -> *) a. MonadIO 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.
MonadIO m =>
TCMT m (a -> b) -> TCMT m a -> TCMT m b
apTCMT

apTCMT :: MonadIO m => TCMT m (a -> b) -> TCMT m a -> TCMT m b
apTCMT :: forall (m :: * -> *) a b.
MonadIO 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 -> m (a -> b) -> m a -> m b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap (IORef TCState -> TCEnv -> m (a -> b)
mf IORef TCState
r TCEnv
e) (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.
instance MonadIO m => Monad (TCMT m) where
    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.
MonadIO 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 -> tcm a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> tcm a) -> (TCM a -> m a) -> TCM a -> tcm a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TCM 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 (BenchPhase TCM)) -> TCM (Benchmark (BenchPhase TCM))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Benchmark (BenchPhase TCM))
 -> TCM (Benchmark (BenchPhase TCM)))
-> IO (Benchmark (BenchPhase TCM))
-> TCM (Benchmark (BenchPhase TCM))
forall a b. (a -> b) -> a -> b
$ IO (Benchmark (BenchPhase TCM))
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