Agda-2.6.2.2: A dependently typed functional programming language and proof assistant

Safe Haskell | Safe-Inferred
Language | Haskell2010

Agda.Compiler.Backend

Description

Interface for compiler backend writers.

Synopsis

- data Backend where
  - Backend :: NFData opts => Backend' opts env menv mod def -> Backend
- data Backend' opts env menv mod def = Backend' {
  - backendName :: String
  - backendVersion :: Maybe String
  - options :: opts
  - commandLineFlags :: [OptDescr (Flag opts)]
  - isEnabled :: opts -> Bool
  - preCompile :: opts -> TCM env
  - postCompile :: env -> IsMain -> Map ModuleName mod -> TCM ()
  - preModule :: env -> IsMain -> ModuleName -> Maybe FilePath -> TCM (Recompile menv mod)
  - postModule :: env -> menv -> IsMain -> ModuleName -> [def] -> TCM mod
  - compileDef :: env -> menv -> IsMain -> Definition -> TCM def
  - scopeCheckingSuffices :: Bool
  - mayEraseType :: QName -> TCM Bool
  }
- data Recompile menv mod
  - = Recompile menv
  - | Skip mod
- data IsMain
  - = IsMain
  - | NotMain
- type Flag opts = opts -> OptM opts
- toTreeless :: EvaluationStrategy -> QName -> TCM (Maybe TTerm)
- module Agda.Syntax.Treeless
- class (Functor m, Applicative m, Monad m) => MonadDebug m where
  - formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> m String
  - traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> m a -> m a
  - verboseBracket :: VerboseKey -> VerboseLevel -> String -> m a -> m a
  - getVerbosity :: m Verbosity
  - isDebugPrinting :: m Bool
  - nowDebugPrinting :: m a -> m a
- data Polarity
  - = Covariant
  - | Contravariant
  - | Invariant
  - | Nonvariant
- data Comparison
  - = CmpEq
  - | CmpLeq
- type BackendName = String
- type ModuleToSource = Map TopLevelModuleName AbsolutePath
- type TCM = TCMT IO
- newtype TCMT m a = TCM {
  - unTCM :: IORef TCState -> TCEnv -> m a
  }
- data TCState = TCSt {
  - stPreScopeState :: !PreScopeState
  - stPostScopeState :: !PostScopeState
  - stPersistentState :: !PersistentTCState
  }
- data TCEnv = TCEnv {
  - envContext :: Context
  - envLetBindings :: LetBindings
  - envCurrentModule :: ModuleName
  - envCurrentPath :: Maybe AbsolutePath
  - envAnonymousModules :: [(ModuleName, Nat)]
  - envImportPath :: [TopLevelModuleName]
  - envMutualBlock :: Maybe MutualId
  - envTerminationCheck :: TerminationCheck ()
  - envCoverageCheck :: CoverageCheck
  - envMakeCase :: Bool
  - envSolvingConstraints :: Bool
  - envCheckingWhere :: Bool
  - envWorkingOnTypes :: Bool
  - envAssignMetas :: Bool
  - envActiveProblems :: Set ProblemId
  - envAbstractMode :: AbstractMode
  - envModality :: Modality
  - envSplitOnStrict :: Bool
  - envDisplayFormsEnabled :: Bool
  - envRange :: Range
  - envHighlightingRange :: Range
  - envClause :: IPClause
  - envCall :: Maybe (Closure Call)
  - envHighlightingLevel :: HighlightingLevel
  - envHighlightingMethod :: HighlightingMethod
  - envExpandLast :: ExpandHidden
  - envAppDef :: Maybe QName
  - envSimplification :: Simplification
  - envAllowedReductions :: AllowedReductions
  - envReduceDefs :: ReduceDefs
  - envReconstructed :: Bool
  - envInjectivityDepth :: Int
  - envCompareBlocked :: Bool
  - envPrintDomainFreePi :: Bool
  - envPrintMetasBare :: Bool
  - envInsideDotPattern :: Bool
  - envUnquoteFlags :: UnquoteFlags
  - envInstanceDepth :: !Int
  - envIsDebugPrinting :: Bool
  - envPrintingPatternLambdas :: [QName]
  - envCallByNeed :: Bool
  - envCurrentCheckpoint :: CheckpointId
  - envCheckpoints :: Map CheckpointId Substitution
  - envGeneralizeMetas :: DoGeneralize
  - envGeneralizedVars :: Map QName GeneralizedValue
  - envActiveBackendName :: Maybe BackendName
  - envConflComputingOverlap :: Bool
  - envCurrentlyElaborating :: Bool
  }
- data HighlightingLevel
  - = None
  - | NonInteractive
  - | Interactive
- data HighlightingMethod
  - = Direct
  - | Indirect
- data NamedMeta = NamedMeta {
  - nmSuggestion :: MetaNameSuggestion
  - nmid :: MetaId
  }
- data TCWarning = TCWarning {
  - tcWarningLocation :: CallStack
  - tcWarningRange :: Range
  - tcWarning :: Warning
  - tcWarningPrintedWarning :: Doc
  - tcWarningCached :: Bool
  }
- data TCErr
  - = TypeError {
    - tcErrLocation :: CallStack
    - tcErrState :: TCState
    - tcErrClosErr :: Closure TypeError
    }
  - | Exception Range Doc
  - | IOException TCState Range IOException
  - | PatternErr Blocker
- data Warning
  - = NicifierIssue DeclarationWarning
  - | TerminationIssue [TerminationError]
  - | UnreachableClauses QName [Range]
  - | CoverageIssue QName [(Telescope, [NamedArg DeBruijnPattern])]
  - | CoverageNoExactSplit QName [Clause]
  - | NotStrictlyPositive QName (Seq OccursWhere)
  - | UnsolvedMetaVariables [Range]
  - | UnsolvedInteractionMetas [Range]
  - | UnsolvedConstraints Constraints
  - | CantGeneralizeOverSorts [MetaId]
  - | AbsurdPatternRequiresNoRHS [NamedArg DeBruijnPattern]
  - | OldBuiltin String String
  - | EmptyRewritePragma
  - | EmptyWhere
  - | IllformedAsClause String
  - | ClashesViaRenaming NameOrModule [Name]
  - | UselessPatternDeclarationForRecord String
  - | UselessPublic
  - | UselessHiding [ImportedName]
  - | UselessInline QName
  - | WrongInstanceDeclaration
  - | InstanceWithExplicitArg QName
  - | InstanceNoOutputTypeName Doc
  - | InstanceArgWithExplicitArg Doc
  - | InversionDepthReached QName
  - | NoGuardednessFlag QName
  - | GenericWarning Doc
  - | GenericNonFatalError Doc
  - | GenericUseless Range Doc
  - | SafeFlagPostulate Name
  - | SafeFlagPragma [String]
  - | SafeFlagNonTerminating
  - | SafeFlagTerminating
  - | SafeFlagWithoutKFlagPrimEraseEquality
  - | WithoutKFlagPrimEraseEquality
  - | SafeFlagNoPositivityCheck
  - | SafeFlagPolarity
  - | SafeFlagNoUniverseCheck
  - | SafeFlagNoCoverageCheck
  - | SafeFlagInjective
  - | SafeFlagEta
  - | ParseWarning ParseWarning
  - | LibraryWarning LibWarning
  - | DeprecationWarning String String String
  - | UserWarning Text
  - | DuplicateUsing (List1 ImportedName)
  - | FixityInRenamingModule (List1 Range)
  - | ModuleDoesntExport QName [Name] [Name] [ImportedName]
  - | InfectiveImport String ModuleName
  - | CoInfectiveImport String ModuleName
  - | RewriteNonConfluent Term Term Term Doc
  - | RewriteMaybeNonConfluent Term Term [Doc]
  - | RewriteAmbiguousRules Term Term Term
  - | RewriteMissingRule Term Term Term
  - | PragmaCompileErased BackendName QName
  - | NotInScopeW [QName]
  - | AsPatternShadowsConstructorOrPatternSynonym Bool
  - | RecordFieldWarning RecordFieldWarning
- builtinNat :: String
- builtinSuc :: String
- builtinZero :: String
- builtinNatPlus :: String
- builtinNatMinus :: String
- builtinNatTimes :: String
- builtinNatDivSucAux :: String
- builtinNatModSucAux :: String
- builtinNatEquals :: String
- builtinNatLess :: String
- builtinWord64 :: String
- builtinInteger :: String
- builtinIntegerPos :: String
- builtinIntegerNegSuc :: String
- builtinFloat :: String
- builtinChar :: String
- builtinString :: String
- builtinUnit :: String
- builtinUnitUnit :: String
- builtinSigma :: String
- builtinBool :: String
- builtinTrue :: String
- builtinFalse :: String
- builtinList :: String
- builtinNil :: String
- builtinCons :: String
- builtinMaybe :: String
- builtinNothing :: String
- builtinJust :: String
- builtinIO :: String
- builtinId :: String
- builtinConId :: String
- builtinIdElim :: String
- builtinPath :: String
- builtinPathP :: String
- builtinInterval :: String
- builtinIMin :: String
- builtinIMax :: String
- builtinINeg :: String
- builtinIZero :: String
- builtinIOne :: String
- builtinPartial :: String
- builtinPartialP :: String
- builtinIsOne :: String
- builtinItIsOne :: String
- builtinEquiv :: String
- builtinEquivFun :: String
- builtinEquivProof :: String
- builtinTranspProof :: String
- builtinGlue :: String
- builtin_glue :: String
- builtin_unglue :: String
- builtin_glueU :: String
- builtin_unglueU :: String
- builtinFaceForall :: String
- builtinIsOne1 :: String
- builtinIsOne2 :: String
- builtinIsOneEmpty :: String
- builtinComp :: String
- builtinPOr :: String
- builtinTrans :: String
- builtinHComp :: String
- builtinSub :: String
- builtinSubIn :: String
- builtinSubOut :: String
- builtinSizeUniv :: String
- builtinSize :: String
- builtinSizeLt :: String
- builtinSizeSuc :: String
- builtinSizeInf :: String
- builtinSizeMax :: String
- builtinInf :: String
- builtinSharp :: String
- builtinFlat :: String
- builtinEquality :: String
- builtinRefl :: String
- builtinRewrite :: String
- builtinLevelMax :: String
- builtinLevel :: String
- builtinLevelZero :: String
- builtinLevelSuc :: String
- builtinSet :: String
- builtinProp :: String
- builtinSetOmega :: String
- builtinLockUniv :: String
- builtinSSetOmega :: String
- builtinStrictSet :: String
- builtinFromNat :: String
- builtinFromNeg :: String
- builtinFromString :: String
- builtinQName :: String
- builtinAgdaSort :: String
- builtinAgdaSortSet :: String
- builtinAgdaSortLit :: String
- builtinAgdaSortProp :: String
- builtinAgdaSortPropLit :: String
- builtinAgdaSortInf :: String
- builtinAgdaSortUnsupported :: String
- builtinHiding :: String
- builtinHidden :: String
- builtinInstance :: String
- builtinVisible :: String
- builtinRelevance :: String
- builtinRelevant :: String
- builtinIrrelevant :: String
- builtinQuantity :: String
- builtinQuantity0 :: String
- builtinQuantityω :: String
- builtinModality :: String
- builtinModalityConstructor :: String
- builtinAssoc :: String
- builtinAssocLeft :: String
- builtinAssocRight :: String
- builtinAssocNon :: String
- builtinPrecedence :: String
- builtinPrecRelated :: String
- builtinPrecUnrelated :: String
- builtinFixity :: String
- builtinFixityFixity :: String
- builtinArg :: String
- builtinArgInfo :: String
- builtinArgArgInfo :: String
- builtinArgArg :: String
- builtinAbs :: String
- builtinAbsAbs :: String
- builtinAgdaTerm :: String
- builtinAgdaTermVar :: String
- builtinAgdaTermLam :: String
- builtinAgdaTermExtLam :: String
- builtinAgdaTermDef :: String
- builtinAgdaTermCon :: String
- builtinAgdaTermPi :: String
- builtinAgdaTermSort :: String
- builtinAgdaTermLit :: String
- builtinAgdaTermUnsupported :: String
- builtinAgdaTermMeta :: String
- builtinAgdaErrorPart :: String
- builtinAgdaErrorPartString :: String
- builtinAgdaErrorPartTerm :: String
- builtinAgdaErrorPartName :: String
- builtinAgdaLiteral :: String
- builtinAgdaLitNat :: String
- builtinAgdaLitWord64 :: String
- builtinAgdaLitFloat :: String
- builtinAgdaLitChar :: String
- builtinAgdaLitString :: String
- builtinAgdaLitQName :: String
- builtinAgdaLitMeta :: String
- builtinAgdaClause :: String
- builtinAgdaClauseClause :: String
- builtinAgdaClauseAbsurd :: String
- builtinAgdaPattern :: String
- builtinAgdaPatVar :: String
- builtinAgdaPatCon :: String
- builtinAgdaPatDot :: String
- builtinAgdaPatLit :: String
- builtinAgdaPatProj :: String
- builtinAgdaPatAbsurd :: String
- builtinAgdaDefinitionFunDef :: String
- builtinAgdaDefinitionDataDef :: String
- builtinAgdaDefinitionRecordDef :: String
- builtinAgdaDefinitionDataConstructor :: String
- builtinAgdaDefinitionPostulate :: String
- builtinAgdaDefinitionPrimitive :: String
- builtinAgdaDefinition :: String
- builtinAgdaMeta :: String
- builtinAgdaTCM :: String
- builtinAgdaTCMReturn :: String
- builtinAgdaTCMBind :: String
- builtinAgdaTCMUnify :: String
- builtinAgdaTCMTypeError :: String
- builtinAgdaTCMInferType :: String
- builtinAgdaTCMCheckType :: String
- builtinAgdaTCMNormalise :: String
- builtinAgdaTCMReduce :: String
- builtinAgdaTCMCatchError :: String
- builtinAgdaTCMGetContext :: String
- builtinAgdaTCMExtendContext :: String
- builtinAgdaTCMInContext :: String
- builtinAgdaTCMFreshName :: String
- builtinAgdaTCMDeclareDef :: String
- builtinAgdaTCMDeclarePostulate :: String
- builtinAgdaTCMDefineFun :: String
- builtinAgdaTCMGetType :: String
- builtinAgdaTCMGetDefinition :: String
- builtinAgdaTCMBlockOnMeta :: String
- builtinAgdaTCMCommit :: String
- builtinAgdaTCMQuoteTerm :: String
- builtinAgdaTCMUnquoteTerm :: String
- builtinAgdaTCMQuoteOmegaTerm :: String
- builtinAgdaTCMIsMacro :: String
- builtinAgdaTCMWithNormalisation :: String
- builtinAgdaTCMWithReconsParams :: String
- builtinAgdaTCMDebugPrint :: String
- builtinAgdaTCMOnlyReduceDefs :: String
- builtinAgdaTCMDontReduceDefs :: String
- builtinAgdaTCMNoConstraints :: String
- builtinAgdaTCMRunSpeculative :: String
- builtinAgdaTCMExec :: String
- isBuiltinNoDef :: String -> Bool
- builtinsNoDef :: [String]
- sizeBuiltins :: [String]
- type Verbosity = Trie VerboseKey VerboseLevel
- type VerboseLevel = Int
- type VerboseKey = String
- class (Functor m, Applicative m, Monad m) => HasOptions m where
  - pragmaOptions :: m PragmaOptions
  - commandLineOptions :: m CommandLineOptions
- type MonadTCError m = (MonadTCEnv m, ReadTCState m, MonadError TCErr m)
- class (Applicative tcm, MonadIO tcm, MonadTCEnv tcm, MonadTCState tcm, HasOptions tcm) => MonadTCM tcm where
  - liftTCM :: TCM a -> tcm a
- newtype BlockT m a = BlockT {
  - unBlockT :: ExceptT Blocker m a
  }
- class Monad m => MonadBlock m where
  - patternViolation :: Blocker -> m a
  - catchPatternErr :: (Blocker -> m a) -> m a -> m a
- class Monad m => MonadTCState m where
  - getTC :: m TCState
  - putTC :: TCState -> m ()
  - modifyTC :: (TCState -> TCState) -> m ()
- class Monad m => MonadTCEnv m where
  - askTC :: m TCEnv
  - localTC :: (TCEnv -> TCEnv) -> m a -> m a
- class (Applicative m, MonadTCEnv m, ReadTCState m, HasOptions m) => MonadReduce m where
  - liftReduce :: ReduceM a -> m a
- newtype ReduceM a = ReduceM {
  - unReduceM :: ReduceEnv -> a
  }
- data ReduceEnv = ReduceEnv {
  - redEnv :: TCEnv
  - redSt :: TCState
  }
- data LHSOrPatSyn
  - = IsLHS
  - | IsPatSyn
- data TypeError
  - = InternalError String
  - | NotImplemented String
  - | NotSupported String
  - | CompilationError String
  - | PropMustBeSingleton
  - | DataMustEndInSort Term
  - | ShouldEndInApplicationOfTheDatatype Type
  - | ShouldBeAppliedToTheDatatypeParameters Term Term
  - | ShouldBeApplicationOf Type QName
  - | ConstructorPatternInWrongDatatype QName QName
  - | CantResolveOverloadedConstructorsTargetingSameDatatype QName (List1 QName)
  - | DoesNotConstructAnElementOf QName Type
  - | WrongHidingInLHS
  - | WrongHidingInLambda Type
  - | WrongHidingInApplication Type
  - | WrongNamedArgument (NamedArg Expr) [NamedName]
  - | WrongIrrelevanceInLambda
  - | WrongQuantityInLambda
  - | WrongCohesionInLambda
  - | QuantityMismatch Quantity Quantity
  - | HidingMismatch Hiding Hiding
  - | RelevanceMismatch Relevance Relevance
  - | UninstantiatedDotPattern Expr
  - | ForcedConstructorNotInstantiated Pattern
  - | IllformedProjectionPattern Pattern
  - | CannotEliminateWithPattern (Maybe Blocker) (NamedArg Pattern) Type
  - | WrongNumberOfConstructorArguments QName Nat Nat
  - | ShouldBeEmpty Type [DeBruijnPattern]
  - | ShouldBeASort Type
  - | ShouldBePi Type
  - | ShouldBePath Type
  - | ShouldBeRecordType Type
  - | ShouldBeRecordPattern DeBruijnPattern
  - | NotAProjectionPattern (NamedArg Pattern)
  - | NotAProperTerm
  - | InvalidTypeSort Sort
  - | InvalidType Term
  - | FunctionTypeInSizeUniv Term
  - | SplitOnIrrelevant (Dom Type)
  - | SplitOnUnusableCohesion (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
  - | UnequalRelevance Comparison Term Term
  - | UnequalQuantity Comparison Term Term
  - | UnequalCohesion Comparison Term Term
  - | UnequalHiding Term Term
  - | UnequalSorts Sort Sort
  - | UnequalBecauseOfUniverseConflict Comparison Term Term
  - | NotLeqSort Sort Sort
  - | MetaCannotDependOn MetaId Nat
  - | MetaOccursInItself MetaId
  - | MetaIrrelevantSolution MetaId Term
  - | MetaErasedSolution MetaId Term
  - | GenericError String
  - | GenericDocError Doc
  - | SortOfSplitVarError (Maybe Blocker) Doc
  - | BuiltinMustBeConstructor String Expr
  - | NoSuchBuiltinName String
  - | DuplicateBuiltinBinding String Term Term
  - | NoBindingForBuiltin String
  - | NoSuchPrimitiveFunction String
  - | DuplicatePrimitiveBinding String QName QName
  - | WrongModalityForPrimitive String ArgInfo ArgInfo
  - | ShadowedModule Name [ModuleName]
  - | BuiltinInParameterisedModule String
  - | IllegalLetInTelescope TypedBinding
  - | IllegalPatternInTelescope Binder
  - | NoRHSRequiresAbsurdPattern [NamedArg Pattern]
  - | TooManyFields QName [Name] [Name]
  - | DuplicateFields [Name]
  - | DuplicateConstructors [Name]
  - | WithOnFreeVariable Expr Term
  - | UnexpectedWithPatterns [Pattern]
  - | WithClausePatternMismatch Pattern (NamedArg DeBruijnPattern)
  - | FieldOutsideRecord
  - | ModuleArityMismatch ModuleName Telescope [NamedArg Expr]
  - | GeneralizeCyclicDependency
  - | GeneralizeUnsolvedMeta
  - | SplitError SplitError
  - | ImpossibleConstructor QName NegativeUnification
  - | TooManyPolarities QName Int
  - | LocalVsImportedModuleClash ModuleName
  - | SolvedButOpenHoles
  - | CyclicModuleDependency [TopLevelModuleName]
  - | FileNotFound TopLevelModuleName [AbsolutePath]
  - | OverlappingProjects AbsolutePath TopLevelModuleName TopLevelModuleName
  - | AmbiguousTopLevelModuleName TopLevelModuleName [AbsolutePath]
  - | ModuleNameUnexpected TopLevelModuleName TopLevelModuleName
  - | ModuleNameDoesntMatchFileName TopLevelModuleName [AbsolutePath]
  - | ClashingFileNamesFor ModuleName [AbsolutePath]
  - | ModuleDefinedInOtherFile TopLevelModuleName AbsolutePath AbsolutePath
  - | BothWithAndRHS
  - | AbstractConstructorNotInScope QName
  - | NotInScope [QName]
  - | NoSuchModule QName
  - | AmbiguousName QName (List1 QName)
  - | AmbiguousModule QName (List1 ModuleName)
  - | ClashingDefinition QName QName (Maybe NiceDeclaration)
  - | ClashingModule ModuleName ModuleName
  - | ClashingImport Name QName
  - | ClashingModuleImport Name ModuleName
  - | PatternShadowsConstructor Name QName
  - | DuplicateImports QName [ImportedName]
  - | InvalidPattern Pattern
  - | RepeatedVariablesInPattern [Name]
  - | GeneralizeNotSupportedHere QName
  - | MultipleFixityDecls [(Name, [Fixity'])]
  - | MultiplePolarityPragmas [Name]
  - | NotAModuleExpr Expr
  - | NotAnExpression Expr
  - | NotAValidLetBinding NiceDeclaration
  - | NotValidBeforeField NiceDeclaration
  - | NothingAppliedToHiddenArg Expr
  - | NothingAppliedToInstanceArg Expr
  - | BadArgumentsToPatternSynonym AmbiguousQName
  - | TooFewArgumentsToPatternSynonym AmbiguousQName
  - | CannotResolveAmbiguousPatternSynonym (List1 (QName, PatternSynDefn))
  - | UnusedVariableInPatternSynonym
  - | NoParseForApplication (List2 Expr)
  - | AmbiguousParseForApplication (List2 Expr) (List1 Expr)
  - | NoParseForLHS LHSOrPatSyn [Pattern] Pattern
  - | AmbiguousParseForLHS LHSOrPatSyn Pattern [Pattern]
  - | OperatorInformation [NotationSection] TypeError
  - | InstanceNoCandidate Type [(Term, TCErr)]
  - | UnquoteFailed UnquoteError
  - | DeBruijnIndexOutOfScope Nat Telescope [Name]
  - | NeedOptionCopatterns
  - | NeedOptionRewriting
  - | NeedOptionProp
  - | NeedOptionTwoLevel
  - | NonFatalErrors [TCWarning]
  - | InstanceSearchDepthExhausted Term Type Int
  - | TriedToCopyConstrainedPrim QName
- data UnquoteError
  - = BadVisibility String (Arg Term)
  - | ConInsteadOfDef QName String String
  - | DefInsteadOfCon QName String String
  - | NonCanonical String Term
  - | BlockedOnMeta TCState Blocker
  - | UnquotePanic String
- data UnificationFailure
  - = UnifyIndicesNotVars Telescope Type Term Term Args
  - | UnifyRecursiveEq Telescope Type Int Term
  - | UnifyReflexiveEq Telescope Type Term
  - | UnifyUnusableModality Telescope Type Int Term Modality
- data NegativeUnification
  - = UnifyConflict Telescope Term Term
  - | UnifyCycle Telescope Int Term
- data SplitError
  - = NotADatatype (Closure Type)
  - | BlockedType Blocker (Closure Type)
  - | ErasedDatatype Bool (Closure Type)
  - | CoinductiveDatatype (Closure Type)
  - | UnificationStuck {
    - cantSplitBlocker :: Maybe Blocker
    - cantSplitConName :: QName
    - cantSplitTel :: Telescope
    - cantSplitConIdx :: Args
    - cantSplitGivenIdx :: Args
    - cantSplitFailures :: [UnificationFailure]
    }
  - | CosplitCatchall
  - | CosplitNoTarget
  - | CosplitNoRecordType (Closure Type)
  - | CannotCreateMissingClause QName (Telescope, [NamedArg DeBruijnPattern]) Doc (Closure (Abs Type))
  - | GenericSplitError String
- data TerminationError = TerminationError {
  - termErrFunctions :: [QName]
  - termErrCalls :: [CallInfo]
  }
- data CallInfo = CallInfo {
  - callInfoTarget :: QName
  - callInfoRange :: Range
  - callInfoCall :: Closure Term
  }
- data RecordFieldWarning
  - = DuplicateFieldsWarning [(Name, Range)]
  - | TooManyFieldsWarning QName [Name] [(Name, Range)]
- data ArgsCheckState a = ACState {
  - acRanges :: [Maybe Range]
  - acElims :: Elims
  - acConstraints :: [Maybe (Abs Constraint)]
  - acType :: Type
  - acData :: a
  }
- data Candidate = Candidate {
  - candidateKind :: CandidateKind
  - candidateTerm :: Term
  - candidateType :: Type
  - candidateOverlappable :: Bool
  }
- data CandidateKind
  - = LocalCandidate
  - | GlobalCandidate QName
- data ExpandHidden
  - = ExpandLast
  - | DontExpandLast
  - | ReallyDontExpandLast
- data AbstractMode
  - = AbstractMode
  - | ConcreteMode
  - | IgnoreAbstractMode
- type LetBindings = Map Name (Open (Term, Dom Type))
- type ContextEntry = Dom (Name, Type)
- type Context = [ContextEntry]
- data UnquoteFlags = UnquoteFlags {
  - _unquoteNormalise :: Bool
  }
- class LensTCEnv a where
  - lensTCEnv :: Lens' TCEnv a
- data Builtin pf
  - = Builtin Term
  - | Prim pf
- type BuiltinThings pf = Map String (Builtin pf)
- data BuiltinInfo = BuiltinInfo {
  - builtinName :: String
  - builtinDesc :: BuiltinDescriptor
  }
- 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 ())
- type TempInstanceTable = (InstanceTable, Set QName)
- type InstanceTable = Map QName (Set QName)
- data Call
  - = CheckClause Type SpineClause
  - | CheckLHS SpineLHS
  - | CheckPattern Pattern Telescope Type
  - | CheckPatternLinearityType Name
  - | CheckPatternLinearityValue Name
  - | CheckLetBinding LetBinding
  - | InferExpr Expr
  - | CheckExprCall Comparison Expr Type
  - | CheckDotPattern Expr Term
  - | CheckProjection Range QName Type
  - | IsTypeCall Comparison Expr Sort
  - | IsType_ Expr
  - | InferVar Name
  - | InferDef QName
  - | CheckArguments Range [NamedArg Expr] Type (Maybe Type)
  - | CheckMetaSolution Range MetaId Type Term
  - | CheckTargetType Range Type Type
  - | CheckDataDef Range QName [LamBinding] [Constructor]
  - | CheckRecDef Range QName [LamBinding] [Constructor]
  - | CheckConstructor QName Telescope Sort Constructor
  - | CheckConstructorFitsIn QName Type Sort
  - | CheckFunDefCall Range QName [Clause] Bool
  - | CheckPragma Range Pragma
  - | CheckPrimitive Range QName Expr
  - | CheckIsEmpty Range Type
  - | CheckConfluence QName QName
  - | CheckWithFunctionType Type
  - | CheckSectionApplication Range ModuleName ModuleApplication
  - | CheckNamedWhere ModuleName
  - | ScopeCheckExpr Expr
  - | ScopeCheckDeclaration NiceDeclaration
  - | ScopeCheckLHS QName Pattern
  - | NoHighlighting
  - | ModuleContents
  - | SetRange Range
- type Statistics = Map String Integer
- newtype MutualId = MutId Int32
- data TermHead
  - = SortHead
  - | PiHead
  - | ConsHead QName
  - | VarHead Nat
  - | UnknownHead
- data FunctionInverse' c
  - = NotInjective
  - | Inverse (InversionMap c)
- type InversionMap c = Map TermHead [c]
- type FunctionInverse = FunctionInverse' Clause
- data PrimFun = PrimFun {
  - primFunName :: QName
  - primFunArity :: Arity
  - primFunImplementation :: [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term)
  }
- data PrimitiveImpl = PrimImpl Type PrimFun
- data ReduceDefs
  - = OnlyReduceDefs (Set QName)
  - | DontReduceDefs (Set QName)
- type AllowedReductions = SmallSet AllowedReduction
- data AllowedReduction
  - = ProjectionReductions
  - | InlineReductions
  - | CopatternReductions
  - | FunctionReductions
  - | RecursiveReductions
  - | LevelReductions
  - | TypeLevelReductions
  - | UnconfirmedReductions
  - | NonTerminatingReductions
- type MaybeReducedElims = [MaybeReduced Elim]
- type MaybeReducedArgs = [MaybeReduced (Arg Term)]
- data MaybeReduced a = MaybeRed {
  - isReduced :: IsReduced
  - ignoreReduced :: a
  }
- data IsReduced
  - = NotReduced
  - | Reduced (Blocked ())
- data Reduced no yes
  - = NoReduction no
  - | YesReduction Simplification yes
- data Simplification
  - = YesSimplification
  - | NoSimplification
- newtype Fields = Fields [(Name, Type)]
- data Defn
  - = Axiom {
    - axiomConstTransp :: Bool
    }
  - | DataOrRecSig {
    - datarecPars :: Int
    }
  - | GeneralizableVar
  - | AbstractDefn Defn
  - | Function {
    - funClauses :: [Clause]
    - funCompiled :: Maybe CompiledClauses
    - funSplitTree :: Maybe SplitTree
    - funTreeless :: Maybe Compiled
    - funCovering :: [Clause]
    - funInv :: FunctionInverse
    - funMutual :: Maybe [QName]
    - funAbstr :: IsAbstract
    - funDelayed :: Delayed
    - funProjection :: Maybe Projection
    - funFlags :: Set FunctionFlag
    - funTerminates :: Maybe Bool
    - funExtLam :: Maybe ExtLamInfo
    - funWith :: Maybe QName
    }
  - | Datatype {
    - dataPars :: Nat
    - dataIxs :: Nat
    - dataClause :: Maybe Clause
    - dataCons :: [QName]
    - dataSort :: Sort
    - dataMutual :: Maybe [QName]
    - dataAbstr :: IsAbstract
    - dataPathCons :: [QName]
    }
  - | Record {
    - recPars :: Nat
    - recClause :: Maybe Clause
    - recConHead :: ConHead
    - recNamedCon :: Bool
    - recFields :: [Dom QName]
    - recTel :: Telescope
    - recMutual :: Maybe [QName]
    - recEtaEquality' :: EtaEquality
    - recPatternMatching :: PatternOrCopattern
    - recInduction :: Maybe Induction
    - recAbstr :: IsAbstract
    - recComp :: CompKit
    }
  - | Constructor {
    - conPars :: Int
    - conArity :: Int
    - conSrcCon :: ConHead
    - conData :: QName
    - conAbstr :: IsAbstract
    - conInd :: Induction
    - conComp :: CompKit
    - conProj :: Maybe [QName]
    - conForced :: [IsForced]
    - conErased :: Maybe [Bool]
    }
  - | Primitive {
    - primAbstr :: IsAbstract
    - primName :: String
    - primClauses :: [Clause]
    - primInv :: FunctionInverse
    - primCompiled :: Maybe CompiledClauses
    }
  - | PrimitiveSort {
    - primName :: String
    - primSort :: Sort
    }
- data CompKit = CompKit {
  - nameOfHComp :: Maybe QName
  - nameOfTransp :: Maybe QName
  }
- data FunctionFlag
  - = FunStatic
  - | FunInline
  - | FunMacro
- data EtaEquality
  - = Specified {
    - theEtaEquality :: !HasEta
    }
  - | Inferred {
    - theEtaEquality :: !HasEta
    }
- newtype ProjLams = ProjLams {
  - getProjLams :: [Arg ArgName]
  }
- data Projection = Projection {
  - projProper :: Maybe QName
  - projOrig :: QName
  - projFromType :: Arg QName
  - projIndex :: Int
  - projLams :: ProjLams
  }
- data ExtLamInfo = ExtLamInfo {
  - extLamModule :: ModuleName
  - extLamAbsurd :: Bool
  - extLamSys :: !(Maybe System)
  }
- data System = System {
  - systemTel :: Telescope
  - systemClauses :: [(Face, Term)]
  }
- type Face = [(Term, Bool)]
- type CompiledRepresentation = Map BackendName [CompilerPragma]
- data CompilerPragma = CompilerPragma Range String
- data IsForced
  - = Forced
  - | NotForced
- data NumGeneralizableArgs
  - = NoGeneralizableArgs
  - | SomeGeneralizableArgs !Int
- data Definition = Defn {
  - defArgInfo :: ArgInfo
  - defName :: QName
  - defType :: Type
  - defPolarity :: [Polarity]
  - defArgOccurrences :: [Occurrence]
  - defArgGeneralizable :: NumGeneralizableArgs
  - defGeneralizedParams :: [Maybe Name]
  - defDisplay :: [LocalDisplayForm]
  - defMutual :: MutualId
  - defCompiledRep :: CompiledRepresentation
  - defInstance :: Maybe QName
  - defCopy :: Bool
  - defMatchable :: Set QName
  - defNoCompilation :: Bool
  - defInjective :: Bool
  - defCopatternLHS :: Bool
  - defBlocked :: Blocked_
  - defLanguage :: !Language
  - theDef :: Defn
  }
- data RewriteRule = RewriteRule {
  - rewName :: QName
  - rewContext :: Telescope
  - rewHead :: QName
  - rewPats :: PElims
  - rewRHS :: Term
  - rewType :: Type
  - rewFromClause :: Bool
  }
- type RewriteRules = [RewriteRule]
- data NLPSort
  - = PType NLPat
  - | PProp NLPat
  - | PInf IsFibrant Integer
  - | PSizeUniv
  - | PLockUniv
- data NLPType = NLPType {
  - nlpTypeSort :: NLPSort
  - nlpTypeUnEl :: NLPat
  }
- type PElims = [Elim' NLPat]
- data NLPat
  - = PVar !Int [Arg Int]
  - | PDef QName PElims
  - | PLam ArgInfo (Abs NLPat)
  - | PPi (Dom NLPType) (Abs NLPType)
  - | PSort NLPSort
  - | PBoundVar !Int PElims
  - | PTerm Term
- data DisplayTerm
  - = DWithApp DisplayTerm [DisplayTerm] Elims
  - | DCon ConHead ConInfo [Arg DisplayTerm]
  - | DDef QName [Elim' DisplayTerm]
  - | DDot Term
  - | DTerm Term
- type LocalDisplayForm = Open DisplayForm
- data DisplayForm = Display {
  - dfPatternVars :: Nat
  - dfPats :: Elims
  - dfRHS :: DisplayTerm
  }
- newtype Section = Section {
  - _secTelescope :: Telescope
  }
- type DisplayForms = HashMap QName [LocalDisplayForm]
- type RewriteRuleMap = HashMap QName RewriteRules
- type Definitions = HashMap QName Definition
- type Sections = Map ModuleName Section
- data Signature = Sig {
  - _sigSections :: Sections
  - _sigDefinitions :: Definitions
  - _sigRewriteRules :: RewriteRuleMap
  }
- data IPClause
  - = IPClause {
    - ipcQName :: QName
    - ipcClauseNo :: Int
    - ipcType :: Type
    - ipcWithSub :: Maybe Substitution
    - ipcClause :: SpineClause
    - ipcClosure :: Closure ()
    - ipcBoundary :: [Closure IPBoundary]
    }
  - | IPNoClause
- type IPBoundary = IPBoundary' Term
- data IPBoundary' t = IPBoundary {
  - ipbEquations :: [(t, t)]
  - ipbValue :: t
  - ipbMetaApp :: t
  - ipbOverapplied :: Overapplied
  }
- data Overapplied
  - = Overapplied
  - | NotOverapplied
- type InteractionPoints = BiMap InteractionId InteractionPoint
- data InteractionPoint = InteractionPoint {
  - ipRange :: Range
  - ipMeta :: Maybe MetaId
  - ipSolved :: Bool
  - ipClause :: IPClause
  }
- type MetaStore = IntMap MetaVariable
- type MetaNameSuggestion = String
- data MetaInfo = MetaInfo {
  - miClosRange :: Closure Range
  - miModality :: Modality
  - miMetaOccursCheck :: RunMetaOccursCheck
  - miNameSuggestion :: MetaNameSuggestion
  - miGeneralizable :: Arg DoGeneralize
  }
- data RunMetaOccursCheck
  - = RunMetaOccursCheck
  - | DontRunMetaOccursCheck
- newtype MetaPriority = MetaPriority Int
- data TypeCheckingProblem
  - = CheckExpr Comparison Expr Type
  - | CheckArgs Comparison ExpandHidden Range [NamedArg Expr] Type Type (ArgsCheckState CheckedTarget -> TCM Term)
  - | CheckProjAppToKnownPrincipalArg Comparison Expr ProjOrigin (List1 QName) Args Type Int Term Type PrincipalArgTypeMetas
  - | CheckLambda Comparison (Arg (List1 (WithHiding Name), Maybe Type)) Expr Type
  - | DoQuoteTerm Comparison Term Type
- data PrincipalArgTypeMetas = PrincipalArgTypeMetas {
  - patmMetas :: Args
  - patmRemainder :: Type
  }
- data CheckedTarget
  - = CheckedTarget (Maybe ProblemId)
  - | NotCheckedTarget
- data MetaInstantiation
  - = InstV [Arg String] Term
  - | Open
  - | OpenInstance
  - | BlockedConst Term
  - | PostponedTypeCheckingProblem (Closure TypeCheckingProblem)
- data Frozen
  - = Frozen
  - | Instantiable
- data Listener
  - = EtaExpand MetaId
  - | CheckConstraint Nat ProblemConstraint
- data MetaVariable = MetaVar {
  - mvInfo :: MetaInfo
  - mvPriority :: MetaPriority
  - mvPermutation :: Permutation
  - mvJudgement :: Judgement MetaId
  - mvInstantiation :: MetaInstantiation
  - mvListeners :: Set Listener
  - mvFrozen :: Frozen
  - mvTwin :: Maybe MetaId
  }
- data GeneralizedValue = GeneralizedValue {
  - genvalCheckpoint :: CheckpointId
  - genvalTerm :: Term
  - genvalType :: Type
  }
- data DoGeneralize
  - = YesGeneralizeVar
  - | YesGeneralizeMeta
  - | NoGeneralize
- data Judgement a
  - = HasType {
    - jMetaId :: a
    - jComparison :: Comparison
    - jMetaType :: Type
    }
  - | IsSort {
    - jMetaId :: a
    - jMetaType :: Type
    }
- data Open a = OpenThing {
  - openThingCheckpoint :: CheckpointId
  - openThingCheckpointMap :: Map CheckpointId Substitution
  - openThingModule :: ModuleNameHash
  - openThing :: a
  }
- data CompareAs
  - = AsTermsOf Type
  - | AsSizes
  - | AsTypes
- data CompareDirection
  - = DirEq
  - | DirLeq
  - | DirGeq
- 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
  - | HasBiggerSort Sort
  - | HasPTSRule (Dom Type) (Abs Sort)
  - | CheckMetaInst MetaId
  - | CheckType Type
  - | UnBlock MetaId
  - | IsEmpty Range Type
  - | CheckSizeLtSat Term
  - | FindInstance MetaId (Maybe [Candidate])
  - | CheckFunDef Delayed DefInfo QName [Clause] TCErr
  - | UnquoteTactic Term Term Type
  - | CheckLockedVars Term Type (Arg Term) Type
  - | UsableAtModality Modality Term
- data ProblemConstraint = PConstr {
  - constraintProblems :: Set ProblemId
  - constraintUnblocker :: Blocker
  - theConstraint :: Closure Constraint
  }
- type Constraints = [ProblemConstraint]
- class LensClosure a b | b -> a where
  - lensClosure :: Lens' (Closure a) b
- data Closure a = Closure {
  - clSignature :: Signature
  - clEnv :: TCEnv
  - clScope :: ScopeInfo
  - clModuleCheckpoints :: Map ModuleName CheckpointId
  - clValue :: a
  }
- data Interface = Interface {
  - iSourceHash :: Hash
  - iSource :: Text
  - iFileType :: FileType
  - iImportedModules :: [(ModuleName, Hash)]
  - iModuleName :: ModuleName
  - iScope :: Map ModuleName Scope
  - iInsideScope :: ScopeInfo
  - iSignature :: Signature
  - iDisplayForms :: DisplayForms
  - iUserWarnings :: Map QName Text
  - iImportWarning :: Maybe Text
  - iBuiltin :: BuiltinThings (String, QName)
  - iForeignCode :: Map BackendName [ForeignCode]
  - iHighlighting :: HighlightingInfo
  - iDefaultPragmaOptions :: [OptionsPragma]
  - iFilePragmaOptions :: [OptionsPragma]
  - iOptionsUsed :: PragmaOptions
  - iPatternSyns :: PatternSynDefns
  - iWarnings :: [TCWarning]
  - iPartialDefs :: Set QName
  }
- data ForeignCode = ForeignCode Range String
- type DecodedModules = Map TopLevelModuleName ModuleInfo
- type VisitedModules = Map TopLevelModuleName ModuleInfo
- data ModuleInfo = ModuleInfo {
  - miInterface :: Interface
  - miWarnings :: [TCWarning]
  - miPrimitive :: Bool
  - miMode :: ModuleCheckMode
  }
- data ModuleCheckMode
  - = ModuleScopeChecked
  - | ModuleTypeChecked
- class Monad m => MonadStConcreteNames m where
  - runStConcreteNames :: StateT ConcreteNames m a -> m a
  - useConcreteNames :: m ConcreteNames
  - modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> m ()
- type SourceToModule = Map AbsolutePath TopLevelModuleName
- class FreshName a where
  - freshName_ :: MonadFresh NameId m => a -> m Name
- newtype CheckpointId = CheckpointId Int
- class Monad m => MonadFresh i m where
  - fresh :: m i
- class Enum i => HasFresh i where
  - freshLens :: Lens' i TCState
  - nextFresh' :: i -> i
- data TypeCheckAction
  - = EnterSection !ModuleName !Telescope
  - | LeaveSection !ModuleName
  - | Decl !Declaration
  - | Pragmas !PragmaOptions
- type CurrentTypeCheckLog = [(TypeCheckAction, PostScopeState)]
- type CachedTypeCheckLog = [(TypeCheckAction, PostScopeState)]
- data LoadedFileCache = LoadedFileCache {
  - lfcCached :: !CachedTypeCheckLog
  - lfcCurrent :: !CurrentTypeCheckLog
  }
- data PersistentTCState = PersistentTCSt {
  - stDecodedModules :: !DecodedModules
  - stPersistentOptions :: CommandLineOptions
  - stInteractionOutputCallback :: InteractionOutputCallback
  - stBenchmark :: !Benchmark
  - stAccumStatistics :: !Statistics
  - stPersistLoadedFileCache :: !(Maybe LoadedFileCache)
  - stPersistBackends :: [Backend]
  }
- data MutualBlock = MutualBlock {
  - mutualInfo :: MutualInfo
  - mutualNames :: Set QName
  }
- data PostScopeState = PostScopeState {
  - stPostSyntaxInfo :: !HighlightingInfo
  - stPostDisambiguatedNames :: !DisambiguatedNames
  - stPostMetaStore :: !MetaStore
  - stPostInteractionPoints :: !InteractionPoints
  - stPostAwakeConstraints :: !Constraints
  - stPostSleepingConstraints :: !Constraints
  - stPostDirty :: !Bool
  - stPostOccursCheckDefs :: !(Set QName)
  - stPostSignature :: !Signature
  - stPostModuleCheckpoints :: !(Map ModuleName CheckpointId)
  - stPostImportsDisplayForms :: !DisplayForms
  - stPostCurrentModule :: !(Maybe ModuleName)
  - stPostInstanceDefs :: !TempInstanceTable
  - stPostConcreteNames :: !ConcreteNames
  - stPostUsedNames :: !(Map RawName [RawName])
  - stPostShadowingNames :: !(Map Name [RawName])
  - stPostStatistics :: !Statistics
  - stPostTCWarnings :: ![TCWarning]
  - stPostMutualBlocks :: !(Map MutualId MutualBlock)
  - stPostLocalBuiltins :: !(BuiltinThings PrimFun)
  - stPostFreshMetaId :: !MetaId
  - stPostFreshMutualId :: !MutualId
  - stPostFreshProblemId :: !ProblemId
  - stPostFreshCheckpointId :: !CheckpointId
  - stPostFreshInt :: !Int
  - stPostFreshNameId :: !NameId
  - stPostAreWeCaching :: !Bool
  - stPostPostponeInstanceSearch :: !Bool
  - stPostConsideringInstance :: !Bool
  - stPostInstantiateBlocking :: !Bool
  - stPostLocalPartialDefs :: !(Set QName)
  }
- type ConcreteNames = Map Name [Name]
- type DisambiguatedNames = IntMap DisambiguatedName
- data DisambiguatedName = DisambiguatedName NameKind QName
- data PreScopeState = PreScopeState {
  - stPreTokens :: !HighlightingInfo
  - stPreImports :: !Signature
  - stPreImportedModules :: !(Set ModuleName)
  - stPreModuleToSource :: !ModuleToSource
  - stPreVisitedModules :: !VisitedModules
  - stPreScope :: !ScopeInfo
  - stPrePatternSyns :: !PatternSynDefns
  - stPrePatternSynImports :: !PatternSynDefns
  - stPreGeneralizedVars :: !(Maybe (Set QName))
  - stPrePragmaOptions :: !PragmaOptions
  - stPreImportedBuiltins :: !(BuiltinThings PrimFun)
  - stPreImportedDisplayForms :: !DisplayForms
  - stPreImportedInstanceDefs :: !InstanceTable
  - stPreForeignCode :: !(Map BackendName [ForeignCode])
  - stPreFreshInteractionId :: !InteractionId
  - stPreImportedUserWarnings :: !(Map QName Text)
  - stPreLocalUserWarnings :: !(Map QName Text)
  - stPreWarningOnImport :: !(Maybe Text)
  - stPreImportedPartialDefs :: !(Set QName)
  - stPreProjectConfigs :: !(Map FilePath ProjectConfig)
  - stPreAgdaLibFiles :: !(Map FilePath AgdaLibFile)
  }
- 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
- initPersistentState :: PersistentTCState
- initPreScopeState :: PreScopeState
- initPostScopeState :: PostScopeState
- initState :: TCState
- stTokens :: Lens' HighlightingInfo TCState
- stImports :: Lens' Signature TCState
- stImportedModules :: Lens' (Set ModuleName) TCState
- stModuleToSource :: Lens' ModuleToSource TCState
- stVisitedModules :: Lens' VisitedModules TCState
- stScope :: Lens' ScopeInfo TCState
- stPatternSyns :: Lens' PatternSynDefns TCState
- stPatternSynImports :: Lens' PatternSynDefns TCState
- stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState
- stPragmaOptions :: Lens' PragmaOptions TCState
- stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState
- stForeignCode :: Lens' (Map BackendName [ForeignCode]) TCState
- stFreshInteractionId :: Lens' InteractionId TCState
- stImportedUserWarnings :: Lens' (Map QName Text) TCState
- stLocalUserWarnings :: Lens' (Map QName Text) TCState
- getUserWarnings :: ReadTCState m => m (Map QName Text)
- stWarningOnImport :: Lens' (Maybe Text) TCState
- stImportedPartialDefs :: Lens' (Set QName) TCState
- stLocalPartialDefs :: Lens' (Set QName) TCState
- getPartialDefs :: ReadTCState m => m (Set QName)
- stLoadedFileCache :: Lens' (Maybe LoadedFileCache) TCState
- stBackends :: Lens' [Backend] TCState
- stProjectConfigs :: Lens' (Map FilePath ProjectConfig) TCState
- stAgdaLibFiles :: Lens' (Map FilePath AgdaLibFile) TCState
- stFreshNameId :: Lens' NameId TCState
- stSyntaxInfo :: Lens' HighlightingInfo TCState
- stDisambiguatedNames :: Lens' DisambiguatedNames TCState
- stMetaStore :: Lens' MetaStore TCState
- stInteractionPoints :: Lens' InteractionPoints TCState
- stAwakeConstraints :: Lens' Constraints TCState
- stSleepingConstraints :: Lens' Constraints TCState
- stDirty :: Lens' Bool TCState
- stOccursCheckDefs :: Lens' (Set QName) TCState
- stSignature :: Lens' Signature TCState
- stModuleCheckpoints :: Lens' (Map ModuleName CheckpointId) TCState
- stImportsDisplayForms :: Lens' DisplayForms TCState
- stImportedDisplayForms :: Lens' DisplayForms TCState
- stCurrentModule :: Lens' (Maybe ModuleName) TCState
- stImportedInstanceDefs :: Lens' InstanceTable TCState
- stInstanceDefs :: Lens' TempInstanceTable TCState
- stConcreteNames :: Lens' ConcreteNames TCState
- stUsedNames :: Lens' (Map RawName [RawName]) TCState
- stShadowingNames :: Lens' (Map Name [RawName]) TCState
- stStatistics :: Lens' Statistics TCState
- stTCWarnings :: Lens' [TCWarning] TCState
- stMutualBlocks :: Lens' (Map MutualId MutualBlock) TCState
- stLocalBuiltins :: Lens' (BuiltinThings PrimFun) TCState
- stFreshMetaId :: Lens' MetaId TCState
- stFreshMutualId :: Lens' MutualId TCState
- stFreshProblemId :: Lens' ProblemId TCState
- stFreshCheckpointId :: Lens' CheckpointId TCState
- stFreshInt :: Lens' Int TCState
- stAreWeCaching :: Lens' Bool TCState
- stPostponeInstanceSearch :: Lens' Bool TCState
- stConsideringInstance :: Lens' Bool TCState
- stInstantiateBlocking :: Lens' Bool TCState
- stBuiltinThings :: TCState -> BuiltinThings PrimFun
- nextFresh :: HasFresh i => TCState -> (i, TCState)
- freshName :: MonadFresh NameId m => Range -> String -> m Name
- freshNoName :: MonadFresh NameId m => Range -> m Name
- freshNoName_ :: MonadFresh NameId m => m Name
- freshRecordName :: MonadFresh NameId m => m Name
- sourceToModule :: TCM SourceToModule
- lookupModuleFromSource :: ReadTCState m => AbsolutePath -> m (Maybe TopLevelModuleName)
- iFullHash :: Interface -> Hash
- intSignature :: Lens' Signature Interface
- buildClosure :: (MonadTCEnv m, ReadTCState m) => a -> m (Closure a)
- fromCmp :: Comparison -> CompareDirection
- flipCmp :: CompareDirection -> CompareDirection
- dirToCmp :: (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c
- normalMetaPriority :: MetaPriority
- lowMetaPriority :: MetaPriority
- highMetaPriority :: MetaPriority
- getMetaInfo :: MetaVariable -> Closure Range
- getMetaScope :: MetaVariable -> ScopeInfo
- getMetaEnv :: MetaVariable -> TCEnv
- getMetaSig :: MetaVariable -> Signature
- getMetaRelevance :: MetaVariable -> Relevance
- getMetaModality :: MetaVariable -> Modality
- metaFrozen :: Lens' Frozen MetaVariable
- _mvInfo :: Lens' MetaInfo MetaVariable
- sigSections :: Lens' Sections Signature
- sigDefinitions :: Lens' Definitions Signature
- sigRewriteRules :: Lens' RewriteRuleMap Signature
- secTelescope :: Lens' Telescope Section
- emptySignature :: Signature
- defaultDisplayForm :: QName -> [LocalDisplayForm]
- theDefLens :: Lens' Defn Definition
- defaultDefn :: ArgInfo -> QName -> Type -> Language -> Defn -> Definition
- jsBackendName :: BackendName
- ghcBackendName :: BackendName
- noCompiledRep :: CompiledRepresentation
- modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo
- projDropPars :: Projection -> ProjOrigin -> Term
- projArgInfo :: Projection -> ArgInfo
- setEtaEquality :: EtaEquality -> HasEta -> EtaEquality
- emptyCompKit :: CompKit
- defaultAxiom :: Defn
- constTranspAxiom :: Defn
- recRecursive :: Defn -> Bool
- recEtaEquality :: Defn -> HasEta
- emptyFunction :: Defn
- funFlag :: FunctionFlag -> Lens' Bool Defn
- funStatic :: Lens' Bool Defn
- funInline :: Lens' Bool Defn
- funMacro :: Lens' Bool Defn
- isMacro :: Defn -> Bool
- isEmptyFunction :: Defn -> Bool
- isCopatternLHS :: [Clause] -> Bool
- recCon :: Defn -> QName
- defIsRecord :: Defn -> Bool
- defIsDataOrRecord :: Defn -> Bool
- defConstructors :: Defn -> [QName]
- redReturn :: a -> ReduceM (Reduced a' a)
- redBind :: ReduceM (Reduced a a') -> (a -> b) -> (a' -> ReduceM (Reduced b b')) -> ReduceM (Reduced b b')
- notReduced :: a -> MaybeReduced a
- reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term)
- allReductions :: AllowedReductions
- reallyAllReductions :: AllowedReductions
- reduceAllDefs :: ReduceDefs
- locallyReduceDefs :: MonadTCEnv m => ReduceDefs -> m a -> m a
- locallyReduceAllDefs :: MonadTCEnv m => m a -> m a
- shouldReduceDef :: MonadTCEnv m => QName -> m Bool
- locallyReconstructed :: MonadTCEnv m => m a -> m a
- isReconstructed :: MonadTCEnv m => m Bool
- primFun :: QName -> Arity -> ([Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun
- defClauses :: Definition -> [Clause]
- defCompiled :: Definition -> Maybe CompiledClauses
- defParameters :: Definition -> Maybe Nat
- defInverse :: Definition -> FunctionInverse
- defCompilerPragmas :: BackendName -> Definition -> [CompilerPragma]
- defDelayed :: Definition -> Delayed
- defNonterminating :: Definition -> Bool
- defTerminationUnconfirmed :: Definition -> Bool
- defAbstract :: Definition -> IsAbstract
- defForced :: Definition -> [IsForced]
- ifTopLevelAndHighlightingLevelIsOr :: MonadTCEnv tcm => HighlightingLevel -> Bool -> tcm () -> tcm ()
- ifTopLevelAndHighlightingLevelIs :: MonadTCEnv tcm => HighlightingLevel -> tcm () -> tcm ()
- initEnv :: TCEnv
- defaultUnquoteFlags :: UnquoteFlags
- unquoteNormalise :: Lens' Bool UnquoteFlags
- eUnquoteNormalise :: Lens' Bool TCEnv
- eContext :: Lens' Context TCEnv
- eLetBindings :: Lens' LetBindings TCEnv
- eCurrentModule :: Lens' ModuleName TCEnv
- eCurrentPath :: Lens' (Maybe AbsolutePath) TCEnv
- eAnonymousModules :: Lens' [(ModuleName, Nat)] TCEnv
- eImportPath :: Lens' [TopLevelModuleName] TCEnv
- eMutualBlock :: Lens' (Maybe MutualId) TCEnv
- eTerminationCheck :: Lens' (TerminationCheck ()) TCEnv
- eCoverageCheck :: Lens' CoverageCheck TCEnv
- eMakeCase :: Lens' Bool TCEnv
- eSolvingConstraints :: Lens' Bool TCEnv
- eCheckingWhere :: Lens' Bool TCEnv
- eWorkingOnTypes :: Lens' Bool TCEnv
- eAssignMetas :: Lens' Bool TCEnv
- eActiveProblems :: Lens' (Set ProblemId) TCEnv
- eAbstractMode :: Lens' AbstractMode TCEnv
- eModality :: Lens' Modality TCEnv
- eRelevance :: Lens' Relevance TCEnv
- eQuantity :: Lens' Quantity TCEnv
- eSplitOnStrict :: Lens' Bool TCEnv
- eDisplayFormsEnabled :: Lens' Bool TCEnv
- eRange :: Lens' Range TCEnv
- eHighlightingRange :: Lens' Range TCEnv
- eCall :: Lens' (Maybe (Closure Call)) TCEnv
- eHighlightingLevel :: Lens' HighlightingLevel TCEnv
- eHighlightingMethod :: Lens' HighlightingMethod TCEnv
- eExpandLast :: Lens' ExpandHidden TCEnv
- eAppDef :: Lens' (Maybe QName) TCEnv
- eSimplification :: Lens' Simplification TCEnv
- eAllowedReductions :: Lens' AllowedReductions TCEnv
- eReduceDefs :: Lens' ReduceDefs TCEnv
- eReconstructed :: Lens' Bool TCEnv
- eInjectivityDepth :: Lens' Int TCEnv
- eCompareBlocked :: Lens' Bool TCEnv
- ePrintDomainFreePi :: Lens' Bool TCEnv
- ePrintMetasBare :: Lens' Bool TCEnv
- eInsideDotPattern :: Lens' Bool TCEnv
- eUnquoteFlags :: Lens' UnquoteFlags TCEnv
- eInstanceDepth :: Lens' Int TCEnv
- eIsDebugPrinting :: Lens' Bool TCEnv
- ePrintingPatternLambdas :: Lens' [QName] TCEnv
- eCallByNeed :: Lens' Bool TCEnv
- eCurrentCheckpoint :: Lens' CheckpointId TCEnv
- eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv
- eGeneralizeMetas :: Lens' DoGeneralize TCEnv
- eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv
- eActiveBackendName :: Lens' (Maybe BackendName) TCEnv
- eConflComputingOverlap :: Lens' Bool TCEnv
- eCurrentlyElaborating :: Lens' Bool TCEnv
- aDefToMode :: IsAbstract -> AbstractMode
- aModeToDef :: AbstractMode -> Maybe IsAbstract
- isDontExpandLast :: ExpandHidden -> Bool
- recordFieldWarningToError :: RecordFieldWarning -> TypeError
- warningName :: Warning -> WarningName
- tcWarningOrigin :: TCWarning -> SrcFile
- sizedTypesOption :: HasOptions m => m Bool
- guardednessOption :: HasOptions m => m Bool
- withoutKOption :: HasOptions m => m Bool
- enableCaching :: HasOptions m => m Bool
- mapRedEnv :: (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv
- mapRedSt :: (TCState -> TCState) -> ReduceEnv -> ReduceEnv
- mapRedEnvSt :: (TCEnv -> TCEnv) -> (TCState -> TCState) -> ReduceEnv -> ReduceEnv
- reduceEnv :: Lens' TCEnv ReduceEnv
- reduceSt :: Lens' TCState ReduceEnv
- onReduceEnv :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
- fmapReduce :: (a -> b) -> ReduceM a -> ReduceM b
- apReduce :: ReduceM (a -> b) -> ReduceM a -> ReduceM b
- thenReduce :: ReduceM a -> ReduceM b -> ReduceM b
- beforeReduce :: ReduceM a -> ReduceM b -> ReduceM a
- bindReduce :: ReduceM a -> (a -> ReduceM b) -> ReduceM b
- runReduceM :: ReduceM a -> TCM a
- runReduceF :: (a -> ReduceM b) -> TCM (a -> b)
- useR :: ReadTCState m => Lens' a TCState -> m a
- askR :: ReduceM ReduceEnv
- localR :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a
- asksTC :: MonadTCEnv m => (TCEnv -> a) -> m a
- viewTC :: MonadTCEnv m => Lens' a TCEnv -> m a
- locallyTC :: MonadTCEnv m => Lens' a TCEnv -> (a -> a) -> m b -> m b
- getsTC :: ReadTCState m => (TCState -> a) -> m a
- modifyTC' :: MonadTCState m => (TCState -> TCState) -> m ()
- useTC :: ReadTCState m => Lens' a TCState -> m a
- setTCLens :: MonadTCState m => Lens' a TCState -> a -> m ()
- modifyTCLens :: MonadTCState m => Lens' a TCState -> (a -> a) -> m ()
- modifyTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m a) -> m ()
- stateTCLens :: MonadTCState m => Lens' a TCState -> (a -> (r, a)) -> m r
- stateTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m (r, a)) -> m r
- runBlocked :: Monad m => BlockT m a -> m (Either Blocker a)
- mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a
- pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a
- returnTCMT :: Applicative m => a -> TCMT m a
- bindTCMT :: Monad m => TCMT m a -> (a -> TCMT m b) -> TCMT m b
- thenTCMT :: Applicative m => TCMT m a -> TCMT m b -> TCMT m b
- fmapTCMT :: Functor m => (a -> b) -> TCMT m a -> TCMT m b
- apTCMT :: Applicative m => TCMT m (a -> b) -> TCMT m a -> TCMT m b
- catchError_ :: TCM a -> (TCErr -> TCM a) -> TCM a
- finally_ :: TCM a -> TCM b -> TCM a
- internalError :: (HasCallStack, MonadTCM tcm) => String -> tcm a
- locatedTypeError :: MonadTCError m => (a -> TypeError) -> HasCallStack => a -> m b
- genericError :: (HasCallStack, MonadTCError m) => String -> m a
- genericDocError :: (HasCallStack, MonadTCError m) => Doc -> m a
- typeError' :: MonadTCError m => CallStack -> TypeError -> m a
- typeError :: (HasCallStack, MonadTCError m) => TypeError -> m a
- typeError'_ :: (MonadTCEnv m, ReadTCState m) => CallStack -> TypeError -> m TCErr
- typeError_ :: (HasCallStack, MonadTCEnv m, ReadTCState m) => TypeError -> m TCErr
- runTCM :: MonadIO m => TCEnv -> TCState -> TCMT m a -> m (a, TCState)
- runTCMTop :: TCM a -> IO (Either TCErr a)
- runTCMTop' :: MonadIO m => TCMT m a -> m a
- runSafeTCM :: TCM a -> TCState -> IO (a, TCState)
- forkTCM :: TCM a -> TCM ()
- patternInTeleName :: String
- extendedLambdaName :: String
- isExtendedLambdaName :: QName -> Bool
- absurdLambdaName :: String
- isAbsurdLambdaName :: QName -> Bool
- generalizedFieldName :: String
- getGeneralizedFieldName :: QName -> Maybe String
- getIncludeDirs :: HasOptions m => m [AbsolutePath]
- libToTCM :: LibM a -> TCM a
- class (MonadTCEnv m, ReadTCState m) => MonadInteractionPoints m where
  - freshInteractionId :: m InteractionId
  - modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> m ()
- addImport :: ModuleName -> TCM ()
- addImportCycleCheck :: TopLevelModuleName -> TCM a -> TCM a
- getImports :: TCM (Set ModuleName)
- isImported :: ModuleName -> TCM Bool
- getImportPath :: TCM [TopLevelModuleName]
- visitModule :: ModuleInfo -> TCM ()
- setVisitedModules :: VisitedModules -> TCM ()
- getVisitedModules :: ReadTCState m => m VisitedModules
- getPrettyVisitedModules :: ReadTCState m => m Doc
- getVisitedModule :: ReadTCState m => TopLevelModuleName -> m (Maybe ModuleInfo)
- getDecodedModules :: TCM DecodedModules
- setDecodedModules :: DecodedModules -> TCM ()
- getDecodedModule :: TopLevelModuleName -> TCM (Maybe ModuleInfo)
- storeDecodedModule :: ModuleInfo -> TCM ()
- dropDecodedModule :: TopLevelModuleName -> TCM ()
- withImportPath :: [TopLevelModuleName] -> TCM a -> TCM a
- checkForImportCycle :: TCM ()
- currentModule :: MonadTCEnv m => m ModuleName
- withCurrentModule :: MonadTCEnv m => ModuleName -> m a -> m a
- getCurrentPath :: MonadTCEnv m => m AbsolutePath
- getAnonymousVariables :: MonadTCEnv m => ModuleName -> m Nat
- withAnonymousModule :: ModuleName -> Nat -> TCM a -> TCM a
- withEnv :: MonadTCEnv m => TCEnv -> m a -> m a
- getEnv :: TCM TCEnv
- withHighlightingLevel :: HighlightingLevel -> TCM a -> TCM a
- doExpandLast :: TCM a -> TCM a
- dontExpandLast :: TCM a -> TCM a
- reallyDontExpandLast :: TCM a -> TCM a
- performedSimplification :: MonadTCEnv m => m a -> m a
- performedSimplification' :: MonadTCEnv m => Simplification -> m a -> m a
- getSimplification :: MonadTCEnv m => m Simplification
- updateAllowedReductions :: (AllowedReductions -> AllowedReductions) -> TCEnv -> TCEnv
- modifyAllowedReductions :: MonadTCEnv m => (AllowedReductions -> AllowedReductions) -> m a -> m a
- putAllowedReductions :: MonadTCEnv m => AllowedReductions -> m a -> m a
- onlyReduceProjections :: MonadTCEnv m => m a -> m a
- allowAllReductions :: MonadTCEnv m => m a -> m a
- allowNonTerminatingReductions :: MonadTCEnv m => m a -> m a
- onlyReduceTypes :: MonadTCEnv m => m a -> m a
- typeLevelReductions :: MonadTCEnv m => m a -> m a
- insideDotPattern :: TCM a -> TCM a
- isInsideDotPattern :: TCM Bool
- callByName :: TCM a -> TCM a
- class MonadTCEnv m => MonadAddContext m where
  - addCtx :: Name -> Dom Type -> m a -> m a
  - addLetBinding' :: Name -> Term -> Dom Type -> m a -> m a
  - updateContext :: Substitution -> (Context -> Context) -> m a -> m a
  - withFreshName :: Range -> ArgName -> (Name -> m a) -> m a
- checkpointSubstitution :: MonadTCEnv tcm => CheckpointId -> tcm Substitution
- class (Functor m, Applicative m, MonadFail m) => HasBuiltins m where
  - getBuiltinThing :: String -> m (Maybe (Builtin PrimFun))
- class TraceS a where
  - traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> a -> m c -> m c
- class ReportS a where
  - reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> a -> m ()
- defaultGetVerbosity :: HasOptions m => m Verbosity
- defaultIsDebugPrinting :: MonadTCEnv m => m Bool
- defaultNowDebugPrinting :: MonadTCEnv m => m a -> m a
- displayDebugMessage :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m ()
- catchAndPrintImpossible :: (CatchImpossible m, Monad m) => VerboseKey -> VerboseLevel -> m String -> m String
- reportSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m ()
- __IMPOSSIBLE_VERBOSE__ :: (HasCallStack, MonadDebug m) => String -> m a
- reportSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m ()
- reportResult :: MonadDebug m => VerboseKey -> VerboseLevel -> (a -> TCM Doc) -> m a -> m a
- unlessDebugPrinting :: MonadDebug m => m () -> m ()
- traceSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a
- traceSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m a -> m a
- openVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m ()
- closeVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> m ()
- closeVerboseBracketException :: MonadDebug m => VerboseKey -> VerboseLevel -> m ()
- parseVerboseKey :: VerboseKey -> [String]
- hasVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool
- hasExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool
- whenExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m ()
- __CRASH_WHEN__ :: (HasCallStack, MonadTCM m, MonadDebug m) => VerboseKey -> VerboseLevel -> m ()
- verboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m ()
- applyWhenVerboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> (m a -> m a) -> m a -> m a
- verbosity :: VerboseKey -> Lens' VerboseLevel TCState
- class ReadTCState m => MonadStatistics m where
  - modifyCounter :: String -> (Integer -> Integer) -> m ()
- getStatistics :: ReadTCState m => m Statistics
- modifyStatistics :: (Statistics -> Statistics) -> TCM ()
- tick :: MonadStatistics m => String -> m ()
- tickN :: MonadStatistics m => String -> Integer -> m ()
- tickMax :: MonadStatistics m => String -> Integer -> m ()
- printStatistics :: (MonadDebug m, MonadTCEnv m, HasOptions m) => Int -> Maybe TopLevelModuleName -> Statistics -> m ()
- class (Functor m, Applicative m, MonadFail m, HasOptions m, MonadDebug m, MonadTCEnv m) => HasConstInfo m where
  - getConstInfo :: QName -> m Definition
  - getConstInfo' :: QName -> m (Either SigError Definition)
  - getRewriteRulesFor :: QName -> m RewriteRules
- data SigError
  - = SigUnknown String
  - | SigAbstract
- lookupSection :: (Functor m, ReadTCState m) => ModuleName -> m Telescope
- inFreshModuleIfFreeParams :: TCM a -> TCM a
- class (HasBuiltins m, HasConstInfo m, MonadAddContext m, MonadDebug m, MonadReduce m, MonadTCEnv m, ReadTCState m) => PureTCM m
- cachingStarts :: (MonadDebug m, MonadTCState m, ReadTCState m) => m ()
- areWeCaching :: ReadTCState m => m Bool
- writeToCurrentLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => TypeCheckAction -> m ()
- restorePostScopeState :: (MonadDebug m, MonadTCState m) => PostScopeState -> m ()
- localCache :: (MonadTCState m, ReadTCState m) => m a -> m a
- withoutCache :: (MonadTCState m, ReadTCState m) => m a -> m a
- readFromCachedLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => m (Maybe (TypeCheckAction, PostScopeState))
- cleanCachedLog :: (MonadDebug m, MonadTCState m) => m ()
- activateLoadedFileCache :: (HasOptions m, MonadDebug m, MonadTCState m) => m ()
- cacheCurrentLog :: (MonadDebug m, MonadTCState m) => m ()
- data SpeculateResult
  - = SpeculateAbort
  - | SpeculateCommit
- resetState :: TCM ()
- resetAllState :: TCM ()
- localTCState :: TCM a -> TCM a
- localTCStateSaving :: TCM a -> TCM (a, TCState)
- localTCStateSavingWarnings :: TCM a -> TCM a
- speculateTCState :: TCM (a, SpeculateResult) -> TCM a
- speculateTCState_ :: TCM SpeculateResult -> TCM ()
- freshTCM :: TCM a -> TCM (Either TCErr a)
- lensPersistentState :: Lens' PersistentTCState TCState
- updatePersistentState :: (PersistentTCState -> PersistentTCState) -> TCState -> TCState
- modifyPersistentState :: (PersistentTCState -> PersistentTCState) -> TCM ()
- lensAccumStatisticsP :: Lens' Statistics PersistentTCState
- lensAccumStatistics :: Lens' Statistics TCState
- getScope :: ReadTCState m => m ScopeInfo
- setScope :: ScopeInfo -> TCM ()
- modifyScope_ :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m ()
- modifyScope :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m ()
- useScope :: ReadTCState m => Lens' a ScopeInfo -> m a
- locallyScope :: ReadTCState m => Lens' a ScopeInfo -> (a -> a) -> m b -> m b
- withScope :: ReadTCState m => ScopeInfo -> m a -> m (a, ScopeInfo)
- withScope_ :: ReadTCState m => ScopeInfo -> m a -> m a
- localScope :: TCM a -> TCM a
- notInScopeError :: QName -> TCM a
- notInScopeWarning :: QName -> TCM ()
- printScope :: String -> Int -> String -> TCM ()
- modifySignature :: MonadTCState m => (Signature -> Signature) -> m ()
- modifyImportedSignature :: MonadTCState m => (Signature -> Signature) -> m ()
- getSignature :: ReadTCState m => m Signature
- modifyGlobalDefinition :: MonadTCState m => QName -> (Definition -> Definition) -> m ()
- setSignature :: MonadTCState m => Signature -> m ()
- withSignature :: (ReadTCState m, MonadTCState m) => Signature -> m a -> m a
- addRewriteRulesFor :: QName -> RewriteRules -> [QName] -> Signature -> Signature
- setMatchableSymbols :: QName -> [QName] -> Signature -> Signature
- lookupDefinition :: QName -> Signature -> Maybe Definition
- updateDefinitions :: (Definitions -> Definitions) -> Signature -> Signature
- updateDefinition :: QName -> (Definition -> Definition) -> Signature -> Signature
- updateTheDef :: (Defn -> Defn) -> Definition -> Definition
- updateDefType :: (Type -> Type) -> Definition -> Definition
- updateDefArgOccurrences :: ([Occurrence] -> [Occurrence]) -> Definition -> Definition
- updateDefPolarity :: ([Polarity] -> [Polarity]) -> Definition -> Definition
- updateDefCompiledRep :: (CompiledRepresentation -> CompiledRepresentation) -> Definition -> Definition
- addCompilerPragma :: BackendName -> CompilerPragma -> Definition -> Definition
- updateFunClauses :: ([Clause] -> [Clause]) -> Defn -> Defn
- updateCovering :: ([Clause] -> [Clause]) -> Defn -> Defn
- updateCompiledClauses :: (Maybe CompiledClauses -> Maybe CompiledClauses) -> Defn -> Defn
- updateDefCopatternLHS :: (Bool -> Bool) -> Definition -> Definition
- updateDefBlocked :: (Blocked_ -> Blocked_) -> Definition -> Definition
- setTopLevelModule :: QName -> TCM ()
- withTopLevelModule :: QName -> TCM a -> TCM a
- currentModuleNameHash :: ReadTCState m => m ModuleNameHash
- addForeignCode :: BackendName -> String -> TCM ()
- getInteractionOutputCallback :: ReadTCState m => m InteractionOutputCallback
- appInteractionOutputCallback :: Response -> TCM ()
- setInteractionOutputCallback :: InteractionOutputCallback -> TCM ()
- getPatternSyns :: ReadTCState m => m PatternSynDefns
- setPatternSyns :: PatternSynDefns -> TCM ()
- modifyPatternSyns :: (PatternSynDefns -> PatternSynDefns) -> TCM ()
- getPatternSynImports :: ReadTCState m => m PatternSynDefns
- getAllPatternSyns :: ReadTCState m => m PatternSynDefns
- lookupPatternSyn :: AmbiguousQName -> TCM PatternSynDefn
- lookupSinglePatternSyn :: QName -> TCM PatternSynDefn
- theBenchmark :: TCState -> Benchmark
- updateBenchmark :: (Benchmark -> Benchmark) -> TCState -> TCState
- modifyBenchmark :: (Benchmark -> Benchmark) -> TCM ()
- addImportedInstances :: Signature -> TCM ()
- updateInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCState -> TCState
- modifyInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCM ()
- getAllInstanceDefs :: TCM TempInstanceTable
- getAnonInstanceDefs :: TCM (Set QName)
- clearAnonInstanceDefs :: TCM ()
- addUnknownInstance :: QName -> TCM ()
- addNamedInstance :: QName -> QName -> TCM ()
- class (MonadTCEnv m, ReadTCState m) => MonadTrace m where
  - traceCall :: Call -> m a -> m a
  - traceCallM :: m Call -> m a -> m a
  - traceCallCPS :: Call -> ((a -> m b) -> m b) -> (a -> m b) -> m b
  - traceClosureCall :: Closure Call -> m a -> m a
  - printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> m ()
- interestingCall :: Call -> Bool
- getCurrentRange :: MonadTCEnv m => m Range
- setCurrentRange :: (MonadTrace m, HasRange x) => x -> m a -> m a
- highlightAsTypeChecked :: MonadTrace m => Range -> Range -> m a -> m a
- noMutualBlock :: TCM a -> TCM a
- inMutualBlock :: (MutualId -> TCM a) -> TCM a
- setMutualBlockInfo :: MutualId -> MutualInfo -> TCM ()
- insertMutualBlockInfo :: MutualId -> MutualInfo -> TCM ()
- setMutualBlock :: MutualId -> QName -> TCM ()
- currentOrFreshMutualBlock :: TCM MutualId
- lookupMutualBlock :: MutualId -> TCM MutualBlock
- mutualBlockOf :: QName -> TCM MutualId
- enterClosure :: (MonadTCEnv m, ReadTCState m, LensClosure a c) => c -> (a -> m b) -> m b
- withClosure :: (MonadTCEnv m, ReadTCState m) => Closure a -> (a -> m b) -> m (Closure b)
- mapClosure :: (MonadTCEnv m, ReadTCState m) => (a -> m b) -> Closure a -> m (Closure b)
- class (MonadTCEnv m, ReadTCState m, MonadError TCErr m, MonadBlock m, HasOptions m, MonadDebug m) => MonadConstraint m where
  - addConstraint :: Blocker -> Constraint -> m ()
  - addAwakeConstraint :: Blocker -> Constraint -> m ()
  - solveConstraint :: Constraint -> m ()
  - solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> m ()
  - wakeConstraints :: (ProblemConstraint -> WakeUp) -> m ()
  - stealConstraints :: ProblemId -> m ()
  - modifyAwakeConstraints :: (Constraints -> Constraints) -> m ()
  - modifySleepingConstraints :: (Constraints -> Constraints) -> m ()
- data ConstraintStatus
  - = AwakeConstraint
  - | SleepingConstraint
- solvingProblem :: MonadConstraint m => ProblemId -> m a -> m a
- solvingProblems :: MonadConstraint m => Set ProblemId -> m a -> m a
- isProblemSolved :: (MonadTCEnv m, ReadTCState m) => ProblemId -> m Bool
- getConstraintsForProblem :: ReadTCState m => ProblemId -> m Constraints
- getAwakeConstraints :: ReadTCState m => m Constraints
- dropConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m ()
- takeConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m Constraints
- putConstraintsToSleep :: MonadConstraint m => (ProblemConstraint -> Bool) -> m ()
- putAllConstraintsToSleep :: MonadConstraint m => m ()
- holdConstraints :: (ConstraintStatus -> ProblemConstraint -> Bool) -> TCM a -> TCM a
- takeAwakeConstraint :: MonadConstraint m => m (Maybe ProblemConstraint)
- takeAwakeConstraint' :: MonadConstraint m => (ProblemConstraint -> Bool) -> m (Maybe ProblemConstraint)
- getAllConstraints :: ReadTCState m => m Constraints
- withConstraint :: MonadConstraint m => (Constraint -> m a) -> ProblemConstraint -> m a
- buildProblemConstraint :: (MonadTCEnv m, ReadTCState m) => Set ProblemId -> Blocker -> Constraint -> m ProblemConstraint
- buildProblemConstraint_ :: (MonadTCEnv m, ReadTCState m) => Blocker -> Constraint -> m ProblemConstraint
- buildConstraint :: Blocker -> Constraint -> TCM ProblemConstraint
- addAndUnblocker :: MonadBlock m => Blocker -> m a -> m a
- addOrUnblocker :: MonadBlock m => Blocker -> m a -> m a
- addConstraint' :: Blocker -> Constraint -> TCM ()
- addAwakeConstraint' :: Blocker -> Constraint -> TCM ()
- addConstraintTo :: Lens' Constraints TCState -> Blocker -> Constraint -> TCM ()
- nowSolvingConstraints :: MonadTCEnv m => m a -> m a
- isSolvingConstraints :: MonadTCEnv m => m Bool
- catchConstraint :: MonadConstraint m => Constraint -> m () -> m ()
- mapAwakeConstraints :: (Constraints -> Constraints) -> TCState -> TCState
- mapSleepingConstraints :: (Constraints -> Constraints) -> TCState -> TCState
- setPragmaOptions :: PragmaOptions -> TCM ()
- setCommandLineOptions :: CommandLineOptions -> TCM ()
- setCommandLineOptions' :: AbsolutePath -> CommandLineOptions -> TCM ()
- getAgdaLibFiles :: FilePath -> TCM [AgdaLibFile]
- getLibraryOptions :: FilePath -> TCM [OptionsPragma]
- setLibraryPaths :: AbsolutePath -> CommandLineOptions -> TCM CommandLineOptions
- setLibraryIncludes :: CommandLineOptions -> TCM CommandLineOptions
- addDefaultLibraries :: AbsolutePath -> CommandLineOptions -> TCM CommandLineOptions
- addTrustedExecutables :: CommandLineOptions -> TCM CommandLineOptions
- setOptionsFromPragma :: OptionsPragma -> TCM ()
- enableDisplayForms :: MonadTCEnv m => m a -> m a
- disableDisplayForms :: MonadTCEnv m => m a -> m a
- displayFormsEnabled :: MonadTCEnv m => m Bool
- setIncludeDirs :: [FilePath] -> AbsolutePath -> TCM ()
- isPropEnabled :: HasOptions m => m Bool
- isTwoLevelEnabled :: HasOptions m => m Bool
- hasUniversePolymorphism :: HasOptions m => m Bool
- showImplicitArguments :: HasOptions m => m Bool
- showIrrelevantArguments :: HasOptions m => m Bool
- showIdentitySubstitutions :: HasOptions m => m Bool
- withShowAllArguments :: ReadTCState m => m a -> m a
- withShowAllArguments' :: ReadTCState m => Bool -> m a -> m a
- withPragmaOptions :: ReadTCState m => (PragmaOptions -> PragmaOptions) -> m a -> m a
- positivityCheckEnabled :: HasOptions m => m Bool
- typeInType :: HasOptions m => m Bool
- etaEnabled :: HasOptions m => m Bool
- maxInstanceSearchDepth :: HasOptions m => m Int
- maxInversionDepth :: HasOptions m => m Int
- getLanguage :: HasOptions m => m Language
- makeOpen :: (ReadTCState m, MonadTCEnv m) => a -> m (Open a)
- getOpen :: (TermSubst a, MonadTCEnv m) => Open a -> m a
- tryGetOpen :: (TermSubst a, ReadTCState m, MonadTCEnv m) => (Substitution -> a -> Maybe a) -> Open a -> m (Maybe a)
- isClosed :: Open a -> Bool
- newtype KeepNames a = KeepNames a
- class AddContext b where
  - addContext :: MonadAddContext m => b -> m a -> m a
  - contextSize :: b -> Nat
- unsafeModifyContext :: MonadTCEnv tcm => (Context -> Context) -> tcm a -> tcm a
- modifyContextInfo :: MonadTCEnv tcm => (forall e. Dom e -> Dom e) -> tcm a -> tcm a
- inTopContext :: (MonadTCEnv tcm, ReadTCState tcm) => tcm a -> tcm a
- unsafeInTopContext :: (MonadTCEnv m, ReadTCState m) => m a -> m a
- unsafeEscapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a
- escapeContext :: MonadAddContext m => Impossible -> Int -> m a -> m a
- checkpoint :: (MonadDebug tcm, MonadTCM tcm, MonadFresh CheckpointId tcm, ReadTCState tcm) => Substitution -> tcm a -> tcm a
- checkpointSubstitution' :: MonadTCEnv tcm => CheckpointId -> tcm (Maybe Substitution)
- getModuleParameterSub :: (MonadTCEnv m, ReadTCState m) => ModuleName -> m (Maybe Substitution)
- defaultAddCtx :: MonadAddContext m => Name -> Dom Type -> m a -> m a
- withFreshName_ :: MonadAddContext m => ArgName -> (Name -> m a) -> m a
- withShadowingNameTCM :: Name -> TCM b -> TCM b
- addRecordNameContext :: (MonadAddContext m, MonadFresh NameId m) => Dom Type -> m b -> m b
- underAbstraction :: (Subst a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b
- underAbstraction' :: (Subst a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b
- underAbstractionAbs :: (Subst a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b
- underAbstractionAbs' :: (Subst a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b
- underAbstraction_ :: (Subst a, MonadAddContext m) => Abs a -> (a -> m b) -> m b
- mapAbstraction :: (Subst a, Subst b, MonadAddContext m) => Dom Type -> (a -> m b) -> Abs a -> m (Abs b)
- getLetBindings :: MonadTCM tcm => tcm [(Name, (Term, Dom Type))]
- defaultAddLetBinding' :: (ReadTCState m, MonadTCEnv m) => Name -> Term -> Dom Type -> m a -> m a
- addLetBinding :: MonadAddContext m => ArgInfo -> Name -> Term -> Type -> m a -> m a
- getContext :: MonadTCEnv m => m [Dom (Name, Type)]
- getContextSize :: (Applicative m, MonadTCEnv m) => m Nat
- getContextArgs :: (Applicative m, MonadTCEnv m) => m Args
- getContextTerms :: (Applicative m, MonadTCEnv m) => m [Term]
- getContextTelescope :: (Applicative m, MonadTCEnv m) => m Telescope
- getContextNames :: (Applicative m, MonadTCEnv m) => m [Name]
- lookupBV' :: MonadTCEnv m => Nat -> m (Maybe (Dom (Name, Type)))
- lookupBV :: (MonadFail m, MonadTCEnv m) => Nat -> m (Dom (Name, Type))
- domOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m (Dom Type)
- typeOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m Type
- nameOfBV' :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m (Maybe Name)
- nameOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m Name
- getVarInfo :: (MonadFail m, MonadTCEnv m) => Name -> m (Term, Dom Type)
- data SortKit = SortKit {
  - nameOfSet :: QName
  - nameOfProp :: QName
  - nameOfSSet :: QName
  - nameOfSetOmega :: IsFibrant -> QName
  }
- data CoinductionKit = CoinductionKit {
  - nameOfInf :: QName
  - nameOfSharp :: QName
  - nameOfFlat :: QName
  }
- litType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => Literal -> m Type
- setBuiltinThings :: BuiltinThings PrimFun -> TCM ()
- bindBuiltinName :: String -> Term -> TCM ()
- bindPrimitive :: String -> PrimFun -> TCM ()
- getBuiltin :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => String -> m Term
- getBuiltin' :: HasBuiltins m => String -> m (Maybe Term)
- getPrimitive' :: HasBuiltins m => String -> m (Maybe PrimFun)
- getPrimitive :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => String -> m PrimFun
- getPrimitiveTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => String -> m Term
- getPrimitiveTerm' :: HasBuiltins m => String -> m (Maybe Term)
- getTerm' :: HasBuiltins m => String -> m (Maybe Term)
- getName' :: HasBuiltins m => String -> m (Maybe QName)
- getTerm :: HasBuiltins m => String -> String -> m Term
- constructorForm :: HasBuiltins m => Term -> m Term
- constructorForm' :: Applicative m => m Term -> m Term -> Term -> m Term
- primInteger :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIntegerPos :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIntegerNegSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFloat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primChar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primBool :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSigma :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primUnit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primUnitUnit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primTrue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFalse :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primList :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNil :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primCons :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primMaybe :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNothing :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primJust :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIO :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primId :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primConId :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIdElim :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primPath :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primPathP :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primInterval :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIZero :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIOne :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIMin :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primINeg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primPartial :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primPartialP :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIsOne :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primItIsOne :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primTrans :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primHComp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primEquiv :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primEquivFun :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primEquivProof :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primTranspProof :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- prim_glueU :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- prim_unglueU :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primGlue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- prim_glue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- prim_unglue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFaceForall :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIsOne1 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIsOne2 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIsOneEmpty :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSub :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSubIn :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSubOut :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primZero :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNatPlus :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNatMinus :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNatTimes :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNatDivSucAux :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNatModSucAux :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNatEquality :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primNatLess :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primWord64 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSizeUniv :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSize :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSizeLt :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSizeSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSizeInf :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSizeMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primInf :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSharp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFlat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primEquality :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primRefl :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primRewrite :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primLevel :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primLevelZero :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primLevelSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primLevelMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primProp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSetOmega :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primLockUniv :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primSSetOmega :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primStrictSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFromNat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFromNeg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFromString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primQName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primArg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primArgArg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAbs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAbsAbs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaSort :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primHiding :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primHidden :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primInstance :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primVisible :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primRelevance :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primRelevant :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primIrrelevant :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primQuantity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primQuantity0 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primQuantityω :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primModality :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primModalityConstructor :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAssoc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAssocLeft :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAssocRight :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAssocNon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primPrecedence :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primPrecRelated :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primPrecUnrelated :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFixity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primFixityFixity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primArgInfo :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primArgArgInfo :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaSortSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaSortLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaSortProp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaSortPropLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaSortInf :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaSortUnsupported :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermVar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermLam :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermExtLam :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermCon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermPi :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermSort :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermUnsupported :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTermMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaErrorPart :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaErrorPartString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaErrorPartTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaErrorPartName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaLiteral :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaLitNat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaLitWord64 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaLitFloat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaLitChar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaLitString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaLitQName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaLitMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaPattern :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaPatCon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaPatVar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaPatDot :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaPatLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaPatProj :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaPatAbsurd :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaClause :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaClauseClause :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaClauseAbsurd :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaDefinitionFunDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaDefinitionDataDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaDefinitionRecordDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaDefinitionDataConstructor :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaDefinitionPostulate :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaDefinitionPrimitive :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaDefinition :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCM :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMReturn :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMBind :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMUnify :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMTypeError :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMInferType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMCheckType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMNormalise :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMReduce :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMCatchError :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMGetContext :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMExtendContext :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMInContext :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMFreshName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMDeclareDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMDeclarePostulate :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMDefineFun :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMGetType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMGetDefinition :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMQuoteTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMQuoteOmegaTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMUnquoteTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMBlockOnMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMCommit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMIsMacro :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMWithNormalisation :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMWithReconsParams :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMDebugPrint :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMOnlyReduceDefs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMDontReduceDefs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMNoConstraints :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMRunSpeculative :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- primAgdaTCMExec :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term
- coinductionKit' :: TCM CoinductionKit
- coinductionKit :: TCM (Maybe CoinductionKit)
- sortKit :: HasBuiltins m => m SortKit
- getPrimName :: Term -> QName
- getBuiltinName' :: HasBuiltins m => String -> m (Maybe QName)
- getPrimitiveName' :: HasBuiltins m => String -> m (Maybe QName)
- isPrimitive :: HasBuiltins m => String -> QName -> m Bool
- intervalView' :: HasBuiltins m => m (Term -> IntervalView)
- intervalView :: HasBuiltins m => Term -> m IntervalView
- intervalUnview :: HasBuiltins m => IntervalView -> m Term
- intervalUnview' :: HasBuiltins m => m (IntervalView -> Term)
- pathView :: HasBuiltins m => Type -> m PathView
- pathView' :: HasBuiltins m => m (Type -> PathView)
- idViewAsPath :: HasBuiltins m => Type -> m PathView
- boldPathView :: Type -> PathView
- pathUnview :: PathView -> Type
- primEqualityName :: TCM QName
- equalityView :: Type -> TCM EqualityView
- equalityUnview :: EqualityView -> Type
- constrainedPrims :: [String]
- getNameOfConstrained :: HasBuiltins m => String -> m (Maybe QName)
- type SizeMaxView' = [DeepSizeView]
- type SizeMaxView = NonEmpty DeepSizeView
- data SizeViewComparable a
  - = NotComparable
  - | YesAbove DeepSizeView a
  - | YesBelow DeepSizeView a
- data DeepSizeView
  - = DSizeInf
  - | DSizeVar ProjectedVar Offset
  - | DSizeMeta MetaId Elims Offset
  - | DOtherSize Term
- type Offset = Nat
- data ProjectedVar = ProjectedVar {
  - pvIndex :: Int
  - prProjs :: [(ProjOrigin, QName)]
  }
- data SizeView
  - = SizeInf
  - | SizeSuc Term
  - | OtherSize Term
- class IsSizeType a where
  - isSizeType :: (HasOptions m, HasBuiltins m) => a -> m (Maybe BoundedSize)
- data BoundedSize
  - = BoundedLt Term
  - | BoundedNo
- isSizeTypeTest :: (HasOptions m, HasBuiltins m) => m (Term -> Maybe BoundedSize)
- getBuiltinDefName :: HasBuiltins m => String -> m (Maybe QName)
- getBuiltinSize :: HasBuiltins m => m (Maybe QName, Maybe QName)
- isSizeNameTest :: (HasOptions m, HasBuiltins m) => m (QName -> Bool)
- isSizeNameTestRaw :: (HasOptions m, HasBuiltins m) => m (QName -> Bool)
- haveSizedTypes :: TCM Bool
- haveSizeLt :: TCM Bool
- builtinSizeHook :: String -> QName -> Type -> TCM ()
- sizeSort :: Sort
- sizeUniv :: Type
- sizeType_ :: QName -> Type
- sizeType :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => m Type
- sizeSucName :: (HasBuiltins m, HasOptions m) => m (Maybe QName)
- sizeSuc :: HasBuiltins m => Nat -> Term -> m Term
- sizeSuc_ :: QName -> Term -> Term
- sizeMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => NonEmpty Term -> m Term
- sizeView :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => Term -> m SizeView
- viewProjectedVar :: Term -> Maybe ProjectedVar
- unviewProjectedVar :: ProjectedVar -> Term
- sizeViewComparable :: DeepSizeView -> DeepSizeView -> SizeViewComparable ()
- sizeViewSuc_ :: QName -> DeepSizeView -> DeepSizeView
- sizeViewPred :: Nat -> DeepSizeView -> DeepSizeView
- sizeViewOffset :: DeepSizeView -> Maybe Offset
- removeSucs :: (DeepSizeView, DeepSizeView) -> (DeepSizeView, DeepSizeView)
- unSizeView :: SizeView -> TCM Term
- unDeepSizeView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => DeepSizeView -> m Term
- maxViewMax :: SizeMaxView -> SizeMaxView -> SizeMaxView
- maxViewCons :: DeepSizeView -> SizeMaxView -> SizeMaxView
- sizeViewComparableWithMax :: DeepSizeView -> SizeMaxView -> SizeViewComparable SizeMaxView'
- maxViewSuc_ :: QName -> SizeMaxView -> SizeMaxView
- unMaxView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => SizeMaxView -> m Term
- addConstant :: QName -> Definition -> TCM ()
- addConstant' :: QName -> ArgInfo -> QName -> Type -> Defn -> TCM ()
- setTerminates :: QName -> Bool -> TCM ()
- setCompiledClauses :: QName -> CompiledClauses -> TCM ()
- setSplitTree :: QName -> SplitTree -> TCM ()
- modifyFunClauses :: QName -> ([Clause] -> [Clause]) -> TCM ()
- addClauses :: QName -> [Clause] -> TCM ()
- mkPragma :: String -> TCM CompilerPragma
- addPragma :: BackendName -> QName -> String -> TCM ()
- getUniqueCompilerPragma :: BackendName -> QName -> TCM (Maybe CompilerPragma)
- setFunctionFlag :: FunctionFlag -> Bool -> QName -> TCM ()
- markStatic :: QName -> TCM ()
- markInline :: Bool -> QName -> TCM ()
- markInjective :: QName -> TCM ()
- unionSignatures :: [Signature] -> Signature
- addSection :: ModuleName -> TCM ()
- setModuleCheckpoint :: ModuleName -> TCM ()
- getSection :: (Functor m, ReadTCState m) => ModuleName -> m (Maybe Section)
- addDisplayForms :: QName -> TCM ()
- applySection :: ModuleName -> Telescope -> ModuleName -> Args -> ScopeCopyInfo -> TCM ()
- applySection' :: ModuleName -> Telescope -> ModuleName -> Args -> ScopeCopyInfo -> TCM ()
- addDisplayForm :: QName -> DisplayForm -> TCM ()
- isLocal :: ReadTCState m => QName -> m Bool
- getDisplayForms :: (HasConstInfo m, ReadTCState m) => QName -> m [LocalDisplayForm]
- chaseDisplayForms :: QName -> TCM (Set QName)
- hasLoopingDisplayForm :: QName -> TCM Bool
- canonicalName :: HasConstInfo m => QName -> m QName
- sameDef :: HasConstInfo m => QName -> QName -> m (Maybe QName)
- whatInduction :: MonadTCM tcm => QName -> tcm Induction
- singleConstructorType :: QName -> TCM Bool
- sigError :: (String -> a) -> a -> SigError -> a
- getOriginalConstInfo :: (ReadTCState m, HasConstInfo m) => QName -> m Definition
- defaultGetRewriteRulesFor :: (ReadTCState m, MonadTCEnv m) => QName -> m RewriteRules
- getOriginalProjection :: HasConstInfo m => QName -> m QName
- defaultGetConstInfo :: (HasOptions m, MonadDebug m, MonadTCEnv m) => TCState -> TCEnv -> QName -> m (Either SigError Definition)
- getConInfo :: HasConstInfo m => ConHead -> m Definition
- getPolarity :: HasConstInfo m => QName -> m [Polarity]
- getPolarity' :: HasConstInfo m => Comparison -> QName -> m [Polarity]
- setPolarity :: (MonadTCState m, MonadDebug m) => QName -> [Polarity] -> m ()
- getForcedArgs :: HasConstInfo m => QName -> m [IsForced]
- getArgOccurrence :: QName -> Nat -> TCM Occurrence
- setArgOccurrences :: MonadTCState m => QName -> [Occurrence] -> m ()
- modifyArgOccurrences :: MonadTCState m => QName -> ([Occurrence] -> [Occurrence]) -> m ()
- setTreeless :: QName -> TTerm -> TCM ()
- setCompiledArgUse :: QName -> [ArgUsage] -> TCM ()
- getCompiled :: HasConstInfo m => QName -> m (Maybe Compiled)
- getErasedConArgs :: HasConstInfo m => QName -> m [Bool]
- setErasedConArgs :: QName -> [Bool] -> TCM ()
- getTreeless :: HasConstInfo m => QName -> m (Maybe TTerm)
- getCompiledArgUse :: HasConstInfo m => QName -> m (Maybe [ArgUsage])
- addDataCons :: QName -> [QName] -> TCM ()
- getMutual :: QName -> TCM (Maybe [QName])
- getMutual_ :: Defn -> Maybe [QName]
- setMutual :: QName -> [QName] -> TCM ()
- mutuallyRecursive :: QName -> QName -> TCM Bool
- definitelyNonRecursive_ :: Defn -> Bool
- getCurrentModuleFreeVars :: TCM Nat
- getDefModule :: HasConstInfo m => QName -> m (Either SigError ModuleName)
- getDefFreeVars :: (Functor m, Applicative m, ReadTCState m, MonadTCEnv m) => QName -> m Nat
- freeVarsToApply :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => QName -> m Args
- getModuleFreeVars :: (Functor m, Applicative m, MonadTCEnv m, ReadTCState m) => ModuleName -> m Nat
- moduleParamsToApply :: (Functor m, Applicative m, HasOptions m, MonadTCEnv m, ReadTCState m, MonadDebug m) => ModuleName -> m Args
- instantiateDef :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => Definition -> m Definition
- instantiateRewriteRule :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRule -> m RewriteRule
- instantiateRewriteRules :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRules -> m RewriteRules
- makeAbstract :: Definition -> Maybe Definition
- inAbstractMode :: MonadTCEnv m => m a -> m a
- inConcreteMode :: MonadTCEnv m => m a -> m a
- ignoreAbstractMode :: MonadTCEnv m => m a -> m a
- inConcreteOrAbstractMode :: (MonadTCEnv m, HasConstInfo m) => QName -> (Definition -> m a) -> m a
- treatAbstractly :: MonadTCEnv m => QName -> m Bool
- treatAbstractly' :: QName -> TCEnv -> Bool
- typeOfConst :: (HasConstInfo m, ReadTCState m) => QName -> m Type
- relOfConst :: HasConstInfo m => QName -> m Relevance
- modalityOfConst :: HasConstInfo m => QName -> m Modality
- droppedPars :: Definition -> Int
- isProjection :: HasConstInfo m => QName -> m (Maybe Projection)
- isProjection_ :: Defn -> Maybe Projection
- isRelevantProjection :: HasConstInfo m => QName -> m (Maybe Projection)
- isRelevantProjection_ :: Definition -> Maybe Projection
- isStaticFun :: Defn -> Bool
- isInlineFun :: Defn -> Bool
- isProperProjection :: Defn -> Bool
- projectionArgs :: Definition -> Int
- usesCopatterns :: HasConstInfo m => QName -> m Bool
- applyDef :: HasConstInfo m => ProjOrigin -> QName -> Arg Term -> m Term
- class UnFreezeMeta a where
  - unfreezeMeta :: MonadMetaSolver m => a -> m ()
- class IsInstantiatedMeta a where
  - isInstantiatedMeta :: (MonadFail m, ReadTCState m) => a -> m Bool
- class (MonadConstraint m, MonadReduce m, MonadAddContext m, MonadTCEnv m, ReadTCState m, HasBuiltins m, HasConstInfo m, MonadDebug m) => MonadMetaSolver m where
  - newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId
  - assignV :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> m ()
  - assignTerm' :: MonadMetaSolver m => MetaId -> [Arg ArgName] -> Term -> m ()
  - etaExpandMeta :: [MetaKind] -> MetaId -> m ()
  - updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> m ()
  - speculateMetas :: m () -> m KeepMetas -> m ()
- data KeepMetas
  - = KeepMetas
  - | RollBackMetas
- data MetaKind
  - = Records
  - | SingletonRecords
  - | Levels
- allMetaKinds :: [MetaKind]
- dontAssignMetas :: (MonadTCEnv m, HasOptions m, MonadDebug m) => m a -> m a
- getMetaStore :: ReadTCState m => m MetaStore
- modifyMetaStore :: (MetaStore -> MetaStore) -> TCM ()
- metasCreatedBy :: ReadTCState m => m a -> m (a, MetaStore)
- lookupMeta' :: ReadTCState m => MetaId -> m (Maybe MetaVariable)
- lookupMeta :: (MonadFail m, ReadTCState m) => MetaId -> m MetaVariable
- metaType :: (MonadFail m, ReadTCState m) => MetaId -> m Type
- updateMetaVarTCM :: MetaId -> (MetaVariable -> MetaVariable) -> TCM ()
- insertMetaVar :: MetaId -> MetaVariable -> TCM ()
- getMetaPriority :: (MonadFail m, ReadTCState m) => MetaId -> m MetaPriority
- isSortMeta :: (MonadFail m, ReadTCState m) => MetaId -> m Bool
- isSortMeta_ :: MetaVariable -> Bool
- getMetaType :: (MonadFail m, ReadTCState m) => MetaId -> m Type
- getMetaContextArgs :: MonadTCEnv m => MetaVariable -> m Args
- getMetaTypeInContext :: (MonadFail m, MonadTCEnv m, ReadTCState m, MonadReduce m, HasBuiltins m) => MetaId -> m Type
- isGeneralizableMeta :: (ReadTCState m, MonadFail m) => MetaId -> m DoGeneralize
- isInstantiatedMeta' :: (MonadFail m, ReadTCState m) => MetaId -> m (Maybe Term)
- constraintMetas :: Constraint -> TCM (Set MetaId)
- createMetaInfo :: (MonadTCEnv m, ReadTCState m) => m MetaInfo
- createMetaInfo' :: (MonadTCEnv m, ReadTCState m) => RunMetaOccursCheck -> m MetaInfo
- setValueMetaName :: MonadMetaSolver m => Term -> MetaNameSuggestion -> m ()
- getMetaNameSuggestion :: (MonadFail m, ReadTCState m) => MetaId -> m MetaNameSuggestion
- setMetaNameSuggestion :: MonadMetaSolver m => MetaId -> MetaNameSuggestion -> m ()
- setMetaGeneralizableArgInfo :: MonadMetaSolver m => MetaId -> ArgInfo -> m ()
- updateMetaVarRange :: MonadMetaSolver m => MetaId -> Range -> m ()
- setMetaOccursCheck :: MonadMetaSolver m => MetaId -> RunMetaOccursCheck -> m ()
- registerInteractionPoint :: forall m. MonadInteractionPoints m => Bool -> Range -> Maybe Nat -> m InteractionId
- findInteractionPoint_ :: Range -> InteractionPoints -> Maybe InteractionId
- connectInteractionPoint :: MonadInteractionPoints m => InteractionId -> MetaId -> m ()
- removeInteractionPoint :: MonadInteractionPoints m => InteractionId -> m ()
- getInteractionPoints :: ReadTCState m => m [InteractionId]
- getInteractionMetas :: ReadTCState m => m [MetaId]
- getUniqueMetasRanges :: (MonadFail m, ReadTCState m) => [MetaId] -> m [Range]
- getUnsolvedMetas :: (MonadFail m, ReadTCState m) => m [Range]
- getUnsolvedInteractionMetas :: (MonadFail m, ReadTCState m) => m [Range]
- getInteractionIdsAndMetas :: ReadTCState m => m [(InteractionId, MetaId)]
- isInteractionMeta :: ReadTCState m => MetaId -> m (Maybe InteractionId)
- lookupInteractionPoint :: (MonadFail m, ReadTCState m, MonadError TCErr m) => InteractionId -> m InteractionPoint
- lookupInteractionId :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m MetaId
- lookupInteractionMeta :: ReadTCState m => InteractionId -> m (Maybe MetaId)
- lookupInteractionMeta_ :: InteractionId -> InteractionPoints -> Maybe MetaId
- newMeta :: MonadMetaSolver m => Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId
- newMetaTCM' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId
- getInteractionRange :: (MonadInteractionPoints m, MonadFail m, MonadError TCErr m) => InteractionId -> m Range
- getMetaRange :: (MonadFail m, ReadTCState m) => MetaId -> m Range
- getInteractionScope :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m ScopeInfo
- withMetaInfo' :: (MonadTCEnv m, ReadTCState m, MonadTrace m) => MetaVariable -> m a -> m a
- withMetaInfo :: (MonadTCEnv m, ReadTCState m, MonadTrace m) => Closure Range -> m a -> m a
- withInteractionId :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m, MonadTrace m) => InteractionId -> m a -> m a
- withMetaId :: (MonadFail m, MonadTCEnv m, ReadTCState m, MonadTrace m) => MetaId -> m a -> m a
- getMetaVariables :: ReadTCState m => (MetaVariable -> Bool) -> m [MetaId]
- getOpenMetas :: ReadTCState m => m [MetaId]
- isOpenMeta :: MetaInstantiation -> Bool
- listenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m ()
- unlistenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m ()
- getMetaListeners :: (MonadFail m, ReadTCState m) => MetaId -> m [Listener]
- clearMetaListeners :: MonadMetaSolver m => MetaId -> m ()
- freezeMetas :: MetaStore -> TCM IntSet
- unfreezeMetas :: TCM ()
- isFrozen :: (MonadFail m, ReadTCState m) => MetaId -> m Bool
- data CheckResult where
  - pattern CheckResult :: Interface -> [TCWarning] -> ModuleCheckMode -> Source -> CheckResult
- crInterface :: CheckResult -> Interface
- crWarnings :: CheckResult -> [TCWarning]
- crMode :: CheckResult -> ModuleCheckMode
- activeBackendMayEraseType :: QName -> TCM Bool
- backendInteraction :: AbsolutePath -> [Backend] -> TCM () -> (AbsolutePath -> TCM CheckResult) -> TCM ()
- parseBackendOptions :: [Backend] -> [String] -> CommandLineOptions -> OptM ([Backend], CommandLineOptions)
- callBackend :: String -> IsMain -> CheckResult -> TCM ()
- lookupBackend :: BackendName -> TCM (Maybe Backend)
- activeBackend :: TCM (Maybe Backend)

# Documentation

data Backend where Source #

Constructors

Backend :: NFData opts => Backend' opts env menv mod def -> Backend |

#### Instances

Instances details

NFData Backend Source # |
Instance details Defined in Agda.Compiler.Backend Methods rnf :: Backend -> () Source #

data Backend' opts env menv mod def Source #

Constructors

Backend' |

Fields

- backendName :: String
- backendVersion :: Maybe String

  Optional version information to be printed with `--version`.

- options :: opts

  Default options

- commandLineFlags :: [OptDescr (Flag opts)]

  Backend-specific command-line flags. Should at minimum contain a flag to enable the backend.

- isEnabled :: opts -> Bool

  Unless the backend has been enabled, `runAgda` will fall back to vanilla Agda behaviour.

- preCompile :: opts -> TCM env

  Called after type checking completes, but before compilation starts.

- postCompile :: env -> IsMain -> Map ModuleName mod -> TCM ()

  Called after module compilation has completed. The `IsMain` argument is `NotMain` if the `--no-main` flag is present.

- preModule :: env -> IsMain -> ModuleName -> Maybe FilePath -> TCM (Recompile menv mod)

  Called before compilation of each module. Gets the path to the `.agdai` file to allow up-to-date checking of previously written compilation results. Should return `Skip m` if compilation is not required. Will be `Nothing` if only scope checking.

- postModule :: env -> menv -> IsMain -> ModuleName -> [def] -> TCM mod

  Called after all definitions of a module have been compiled.

- compileDef :: env -> menv -> IsMain -> Definition -> TCM def

  Compile a single definition.

- scopeCheckingSuffices :: Bool

  True if the backend works if `--only-scope-checking` is used.

- mayEraseType :: QName -> TCM Bool

  The treeless compiler may ask the Backend if elements of the given type maybe possibly erased. The answer should be `False` if the compilation of the type is used by a third party, e.g. in a FFI binding.

#### Instances

Instances details

Generic (Backend' opts env menv mod def) Source # |
Instance details Defined in Agda.Compiler.Backend Associated Types type Rep (Backend' opts env menv mod def) :: Type -> Type Source # Methods from :: Backend' opts env menv mod def -> Rep (Backend' opts env menv mod def) x Source # to :: Rep (Backend' opts env menv mod def) x -> Backend' opts env menv mod def Source #
NFData opts => NFData (Backend' opts env menv mod def) Source # |
Instance details Defined in Agda.Compiler.Backend Methods rnf :: Backend' opts env menv mod def -> () Source #
type Rep (Backend' opts env menv mod def) Source # |

Instance details

Defined in Agda.Compiler.Backend

type Rep (Backend' opts env menv mod def) = D1 ('MetaData "Backend'" "Agda.Compiler.Backend" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Backend'" 'PrefixI 'True) (((S1 ('MetaSel ('Just "backendName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Just "backendVersion") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe String)) :*: S1 ('MetaSel ('Just "options") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 opts))) :*: (S1 ('MetaSel ('Just "commandLineFlags") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [OptDescr (Flag opts)]) :*: (S1 ('MetaSel ('Just "isEnabled") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (opts -> Bool)) :*: S1 ('MetaSel ('Just "preCompile") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (opts -> TCM env))))) :*: ((S1 ('MetaSel ('Just "postCompile") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (env -> IsMain -> Map ModuleName mod -> TCM ())) :*: (S1 ('MetaSel ('Just "preModule") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (env -> IsMain -> ModuleName -> Maybe FilePath -> TCM (Recompile menv mod))) :*: S1 ('MetaSel ('Just "postModule") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (env -> menv -> IsMain -> ModuleName -> [def] -> TCM mod)))) :*: (S1 ('MetaSel ('Just "compileDef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (env -> menv -> IsMain -> Definition -> TCM def)) :*: (S1 ('MetaSel ('Just "scopeCheckingSuffices") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "mayEraseType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName -> TCM Bool)))))))

data Recompile menv mod Source #

Constructors

Recompile menv |
Skip mod |

data IsMain Source #

Constructors

IsMain |
NotMain |

#### Instances

Instances details

Monoid IsMain Source # |
Instance details Defined in Agda.Compiler.Common Methods mempty :: IsMain Source # mappend :: IsMain -> IsMain -> IsMain Source # mconcat :: [IsMain] -> IsMain Source #
Semigroup IsMain Source # | Conjunctive semigroup (`NotMain` is absorbing).
Instance details Defined in Agda.Compiler.Common Methods (<>) :: IsMain -> IsMain -> IsMain Source # sconcat :: NonEmpty IsMain -> IsMain Source # stimes :: Integral b => b -> IsMain -> IsMain Source #
Show IsMain Source # |
Instance details Defined in Agda.Compiler.Common Methods showsPrec :: Int -> IsMain -> ShowS Source # show :: IsMain -> String Source # showList :: [IsMain] -> ShowS Source #
Eq IsMain Source # |
Instance details Defined in Agda.Compiler.Common Methods (==) :: IsMain -> IsMain -> Bool Source # (/=) :: IsMain -> IsMain -> Bool Source #

type Flag opts = opts -> OptM opts Source #

`f :: Flag opts` is an action on the option record that results from parsing an option. `f opts` produces either an error message or an updated options record

toTreeless :: EvaluationStrategy -> QName -> TCM (Maybe TTerm) Source #

Converts compiled clauses to treeless syntax.

Note: Do not use any of the concrete names in the returned term for identification purposes! If you wish to do so, first apply the Agda.Compiler.Treeless.NormalizeNames transformation.

module Agda.Syntax.Treeless

class (Functor m, Applicative m, Monad m) => MonadDebug m where Source #

Minimal complete definition

Nothing

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> m String Source #

default formatDebugMessage :: (MonadTrans t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> TCM Doc -> m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> m a -> m a Source #

default traceDebugMessage :: (MonadTransControl t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> String -> m a -> m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> m a -> m a Source #

Print brackets around debug messages issued by a computation.

default verboseBracket :: (MonadTransControl t, MonadDebug n, m ~ t n) => VerboseKey -> VerboseLevel -> String -> m a -> m a Source #

getVerbosity :: m Verbosity Source #

default getVerbosity :: (MonadTrans t, MonadDebug n, m ~ t n) => m Verbosity Source #

isDebugPrinting :: m Bool Source #

Check whether we are currently debug printing.

default isDebugPrinting :: (MonadTrans t, MonadDebug n, m ~ t n) => m Bool Source #

nowDebugPrinting :: m a -> m a Source #

Flag in a computation that we are currently debug printing.

default nowDebugPrinting :: (MonadTransControl t, MonadDebug n, m ~ t n) => m a -> m a Source #

#### Instances

Instances details

MonadDebug AbsToCon Source # |

Instance details

Defined in Agda.Syntax.Translation.AbstractToConcrete

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> AbsToCon String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> AbsToCon a -> AbsToCon a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> AbsToCon a -> AbsToCon a Source #

getVerbosity :: AbsToCon Verbosity Source #

isDebugPrinting :: AbsToCon Bool Source #

nowDebugPrinting :: AbsToCon a -> AbsToCon a Source #

MonadDebug TerM Source # |

Instance details

Defined in Agda.Termination.Monad

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> TerM String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> TerM a -> TerM a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> TerM a -> TerM a Source #

getVerbosity :: TerM Verbosity Source #

isDebugPrinting :: TerM Bool Source #

nowDebugPrinting :: TerM a -> TerM a Source #

MonadDebug ReduceM Source # |

Instance details

Defined in Agda.TypeChecking.Reduce.Monad

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> ReduceM String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> ReduceM a -> ReduceM a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> ReduceM a -> ReduceM a Source #

getVerbosity :: ReduceM Verbosity Source #

isDebugPrinting :: ReduceM Bool Source #

nowDebugPrinting :: ReduceM a -> ReduceM a Source #

MonadDebug TCM Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> TCM String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> TCM a -> TCM a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> TCM a -> TCM a Source #

getVerbosity :: TCM Verbosity Source #

isDebugPrinting :: TCM Bool Source #

nowDebugPrinting :: TCM a -> TCM a Source #

MonadDebug NLM Source # |

Instance details

Defined in Agda.TypeChecking.Rewriting.NonLinMatch

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> NLM String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> NLM a -> NLM a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> NLM a -> NLM a Source #

getVerbosity :: NLM Verbosity Source #

isDebugPrinting :: NLM Bool Source #

nowDebugPrinting :: NLM a -> NLM a Source #

MonadDebug m => MonadDebug (PureConversionT m) Source # |

Instance details

Defined in Agda.TypeChecking.Conversion.Pure

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> PureConversionT m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> PureConversionT m a -> PureConversionT m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> PureConversionT m a -> PureConversionT m a Source #

getVerbosity :: PureConversionT m Verbosity Source #

isDebugPrinting :: PureConversionT m Bool Source #

nowDebugPrinting :: PureConversionT m a -> PureConversionT m a Source #

MonadDebug m => MonadDebug (BlockT m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> BlockT m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> BlockT m a -> BlockT m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> BlockT m a -> BlockT m a Source #

getVerbosity :: BlockT m Verbosity Source #

isDebugPrinting :: BlockT m Bool Source #

nowDebugPrinting :: BlockT m a -> BlockT m a Source #

MonadDebug m => MonadDebug (NamesT m) Source # |

Instance details

Defined in Agda.TypeChecking.Names

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> NamesT m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> NamesT m a -> NamesT m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> NamesT m a -> NamesT m a Source #

getVerbosity :: NamesT m Verbosity Source #

isDebugPrinting :: NamesT m Bool Source #

nowDebugPrinting :: NamesT m a -> NamesT m a Source #

MonadDebug m => MonadDebug (ListT m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> ListT m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> ListT m a -> ListT m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> ListT m a -> ListT m a Source #

getVerbosity :: ListT m Verbosity Source #

isDebugPrinting :: ListT m Bool Source #

nowDebugPrinting :: ListT m a -> ListT m a Source #

MonadDebug m => MonadDebug (ChangeT m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> ChangeT m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> ChangeT m a -> ChangeT m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> ChangeT m a -> ChangeT m a Source #

getVerbosity :: ChangeT m Verbosity Source #

isDebugPrinting :: ChangeT m Bool Source #

nowDebugPrinting :: ChangeT m a -> ChangeT m a Source #

MonadDebug m => MonadDebug (MaybeT m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> MaybeT m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> MaybeT m a -> MaybeT m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> MaybeT m a -> MaybeT m a Source #

getVerbosity :: MaybeT m Verbosity Source #

isDebugPrinting :: MaybeT m Bool Source #

nowDebugPrinting :: MaybeT m a -> MaybeT m a Source #

MonadDebug m => MonadDebug (ExceptT e m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> ExceptT e m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> ExceptT e m a -> ExceptT e m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> ExceptT e m a -> ExceptT e m a Source #

getVerbosity :: ExceptT e m Verbosity Source #

isDebugPrinting :: ExceptT e m Bool Source #

nowDebugPrinting :: ExceptT e m a -> ExceptT e m a Source #

MonadDebug m => MonadDebug (IdentityT m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> IdentityT m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> IdentityT m a -> IdentityT m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> IdentityT m a -> IdentityT m a Source #

getVerbosity :: IdentityT m Verbosity Source #

isDebugPrinting :: IdentityT m Bool Source #

nowDebugPrinting :: IdentityT m a -> IdentityT m a Source #

MonadDebug m => MonadDebug (ReaderT r m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> ReaderT r m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> ReaderT r m a -> ReaderT r m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> ReaderT r m a -> ReaderT r m a Source #

getVerbosity :: ReaderT r m Verbosity Source #

isDebugPrinting :: ReaderT r m Bool Source #

nowDebugPrinting :: ReaderT r m a -> ReaderT r m a Source #

MonadDebug m => MonadDebug (StateT s m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> StateT s m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> StateT s m a -> StateT s m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> StateT s m a -> StateT s m a Source #

getVerbosity :: StateT s m Verbosity Source #

isDebugPrinting :: StateT s m Bool Source #

nowDebugPrinting :: StateT s m a -> StateT s m a Source #

(MonadDebug m, Monoid w) => MonadDebug (WriterT w m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> WriterT w m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> WriterT w m a -> WriterT w m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> WriterT w m a -> WriterT w m a Source #

getVerbosity :: WriterT w m Verbosity Source #

isDebugPrinting :: WriterT w m Bool Source #

nowDebugPrinting :: WriterT w m a -> WriterT w m a Source #

data Polarity Source #

Polarity for equality and subtype checking.

Constructors

Covariant | monotone
Contravariant | antitone
Invariant | no information (mixed variance)
Nonvariant | constant

#### Instances

Instances details

KillRange Polarity Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT Polarity Source #
PrettyTCM Polarity Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => Polarity -> m Doc Source #
EmbPrj Polarity Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: Polarity -> S Int32 Source # icod_ :: Polarity -> S Int32 Source # value :: Int32 -> R Polarity Source #
Pretty Polarity Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Polarity -> Doc Source # prettyPrec :: Int -> Polarity -> Doc Source # prettyList :: [Polarity] -> Doc Source #
Data Polarity Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Polarity -> c Polarity Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Polarity Source #

toConstr :: Polarity -> Constr Source #

dataTypeOf :: Polarity -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Polarity) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Polarity) Source #

gmapT :: (forall b. Data b => b -> b) -> Polarity -> Polarity Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Polarity -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Polarity -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Polarity -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Polarity -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Polarity -> m Polarity Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Polarity -> m Polarity Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Polarity -> m Polarity Source #

Generic Polarity Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Polarity :: Type -> Type Source # Methods from :: Polarity -> Rep Polarity x Source # to :: Rep Polarity x -> Polarity Source #
Show Polarity Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Polarity -> ShowS Source # show :: Polarity -> String Source # showList :: [Polarity] -> ShowS Source #
NFData Polarity Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Polarity -> () Source #
Eq Polarity Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: Polarity -> Polarity -> Bool Source # (/=) :: Polarity -> Polarity -> Bool Source #
Abstract [Polarity] Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> [Polarity] -> [Polarity] Source #
Apply [Polarity] Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: [Polarity] -> Args -> [Polarity] Source # applyE :: [Polarity] -> Elims -> [Polarity] Source #
type Rep Polarity Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Polarity = D1 ('MetaData "Polarity" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "Covariant" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Contravariant" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Invariant" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Nonvariant" 'PrefixI 'False) (U1 :: Type -> Type)))

data Comparison Source #

Constructors

CmpEq |
CmpLeq |

#### Instances

Instances details

PrettyTCM Comparison Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => Comparison -> m Doc Source #
Pretty Comparison Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Comparison -> Doc Source # prettyPrec :: Int -> Comparison -> Doc Source # prettyList :: [Comparison] -> Doc Source #
Data Comparison Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Comparison -> c Comparison Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Comparison Source #

toConstr :: Comparison -> Constr Source #

dataTypeOf :: Comparison -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Comparison) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comparison) Source #

gmapT :: (forall b. Data b => b -> b) -> Comparison -> Comparison Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Comparison -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Comparison -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Comparison -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Comparison -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Comparison -> m Comparison Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Comparison -> m Comparison Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Comparison -> m Comparison Source #

Generic Comparison Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Comparison :: Type -> Type Source # Methods from :: Comparison -> Rep Comparison x Source # to :: Rep Comparison x -> Comparison Source #
Show Comparison Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Comparison -> ShowS Source # show :: Comparison -> String Source # showList :: [Comparison] -> ShowS Source #
NFData Comparison Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Comparison -> () Source #
Eq Comparison Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: Comparison -> Comparison -> Bool Source # (/=) :: Comparison -> Comparison -> Bool Source #
type Rep Comparison Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep Comparison = D1 ('MetaData "Comparison" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "CmpEq" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CmpLeq" 'PrefixI 'False) (U1 :: Type -> Type))

type BackendName = String Source #

type ModuleToSource = Map TopLevelModuleName AbsolutePath Source #

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

type TCM = TCMT IO Source #

Type checking monad.

newtype TCMT m a Source #

The type checking monad transformer. Adds readonly `TCEnv` and mutable `TCState`.

Constructors

TCM |

Fields

- unTCM :: IORef TCState -> TCEnv -> m a

#### Instances

Instances details

MonadFixityError ScopeM Source # |

Instance details

Defined in Agda.Syntax.Scope.Monad

Methods

throwMultipleFixityDecls :: [(Name, [Fixity'])] -> ScopeM a Source #

throwMultiplePolarityPragmas :: [Name] -> ScopeM a Source #

warnUnknownNamesInFixityDecl :: [Name] -> ScopeM () Source #

warnUnknownNamesInPolarityPragmas :: [Name] -> ScopeM () Source #

warnUnknownFixityInMixfixDecl :: [Name] -> ScopeM () Source #

warnPolarityPragmasButNotPostulates :: [Name] -> ScopeM () Source #

MonadBlock TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternViolation :: Blocker -> TCM a Source # catchPatternErr :: (Blocker -> TCM a) -> TCM a -> TCM a Source #
MonadStConcreteNames TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods runStConcreteNames :: StateT ConcreteNames TCM a -> TCM a Source # useConcreteNames :: TCM ConcreteNames Source # modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> TCM () Source #
MonadConstraint TCM Source # |

Instance details

Defined in Agda.TypeChecking.Constraints

Methods

addConstraint :: Blocker -> Constraint -> TCM () Source #

addAwakeConstraint :: Blocker -> Constraint -> TCM () Source #

solveConstraint :: Constraint -> TCM () Source #

solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> TCM () Source #

wakeConstraints :: (ProblemConstraint -> WakeUp) -> TCM () Source #

stealConstraints :: ProblemId -> TCM () Source #

modifyAwakeConstraints :: (Constraints -> Constraints) -> TCM () Source #

modifySleepingConstraints :: (Constraints -> Constraints) -> TCM () Source #

MonadAddContext TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addCtx :: Name -> Dom Type -> TCM a -> TCM a Source # addLetBinding' :: Name -> Term -> Dom Type -> TCM a -> TCM a Source # updateContext :: Substitution -> (Context -> Context) -> TCM a -> TCM a Source # withFreshName :: Range -> ArgName -> (Name -> TCM a) -> TCM a Source #
MonadDebug TCM Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> TCM String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> TCM a -> TCM a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> TCM a -> TCM a Source #

getVerbosity :: TCM Verbosity Source #

isDebugPrinting :: TCM Bool Source #

nowDebugPrinting :: TCM a -> TCM a Source #

MonadInteractionPoints TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods freshInteractionId :: TCM InteractionId Source # modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> TCM () Source #
MonadMetaSolver TCM Source # |

Instance details

Defined in Agda.TypeChecking.MetaVars

Methods

newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId Source #

assignV :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> TCM () Source #

assignTerm' :: MetaId -> [Arg ArgName] -> Term -> TCM () Source #

etaExpandMeta :: [MetaKind] -> MetaId -> TCM () Source #

updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> TCM () Source #

speculateMetas :: TCM () -> TCM KeepMetas -> TCM () Source #

PureTCM TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
MonadStatistics TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Statistics Methods modifyCounter :: String -> (Integer -> Integer) -> TCM () Source #
MonadTrace TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Trace Methods traceCall :: Call -> TCM a -> TCM a Source # traceCallM :: TCM Call -> TCM a -> TCM a Source # traceCallCPS :: Call -> ((a -> TCM b) -> TCM b) -> (a -> TCM b) -> TCM b Source # traceClosureCall :: Closure Call -> TCM a -> TCM a Source # printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> TCM () Source #
MonadWarning TCM Source # |
Instance details Defined in Agda.TypeChecking.Warnings Methods addWarning :: TCWarning -> TCM () Source #
MonadBench TCM Source # | We store benchmark statistics in an IORef. This enables benchmarking pure computation, see Agda.Benchmarking.
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type BenchPhase TCM Source # Methods getBenchmark :: TCM (Benchmark (BenchPhase TCM)) Source # putBenchmark :: Benchmark (BenchPhase TCM) -> TCM () Source # modifyBenchmark :: (Benchmark (BenchPhase TCM) -> Benchmark (BenchPhase TCM)) -> TCM () Source # finally :: TCM b -> TCM c -> TCM b Source #
CatchImpossible TCM Source # | 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 details Defined in Agda.TypeChecking.Monad.Base Methods catchImpossible :: TCM a -> (Impossible -> TCM a) -> TCM a Source # catchImpossibleJust :: (Impossible -> Maybe b) -> TCM a -> (b -> TCM a) -> TCM a Source # handleImpossible :: (Impossible -> TCM a) -> TCM a -> TCM a Source # handleImpossibleJust :: (Impossible -> Maybe b) -> (b -> TCM a) -> TCM a -> TCM a Source #
MonadTrans TCMT Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lift :: Monad m => m a -> TCMT m a Source #
HasFresh i => MonadFresh i TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fresh :: TCM i Source #
MonadError TCErr TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods throwError :: TCErr -> TCM a Source # catchError :: TCM a -> (TCErr -> TCM a) -> TCM a Source #
Conversion TOM Clause (Maybe ([Pat O], MExp O)) Source # |
Instance details Defined in Agda.Auto.Convert Methods convert :: Clause -> TOM (Maybe ([Pat O], MExp O)) Source #
Conversion TOM Term (MExp O) Source # |
Instance details Defined in Agda.Auto.Convert Methods convert :: Term -> TOM (MExp O) Source #
Conversion TOM Type (MExp O) Source # |
Instance details Defined in Agda.Auto.Convert Methods convert :: Type -> TOM (MExp O) Source #
Conversion TOM Args (MM (ArgList O) (RefInfo O)) Source # |
Instance details Defined in Agda.Auto.Convert Methods convert :: Args -> TOM (MM (ArgList O) (RefInfo O)) Source #
Conversion TOM (Arg Pattern) (Pat O) Source # |
Instance details Defined in Agda.Auto.Convert Methods convert :: Arg Pattern -> TOM (Pat O) Source #
Conversion TOM [Clause] [([Pat O], MExp O)] Source # |
Instance details Defined in Agda.Auto.Convert Methods convert :: [Clause] -> TOM [([Pat O], MExp O)] Source #
Conversion TOM a b => Conversion TOM (Arg a) (Hiding, b) Source # |
Instance details Defined in Agda.Auto.Convert Methods convert :: Arg a -> TOM (Hiding, b) Source #
MonadIO m => HasOptions (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pragmaOptions :: TCMT m PragmaOptions Source # commandLineOptions :: TCMT m CommandLineOptions Source #
MonadIO m => MonadReduce (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> TCMT m a Source #
MonadIO m => MonadTCEnv (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: TCMT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> TCMT m a -> TCMT m a Source #
MonadIO m => MonadTCM (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> TCMT m a Source #
MonadIO m => MonadTCState (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: TCMT m TCState Source # putTC :: TCState -> TCMT m () Source # modifyTC :: (TCState -> TCState) -> TCMT m () Source #
MonadIO m => ReadTCState (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: TCMT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> TCMT m b -> TCMT m b Source # withTCState :: (TCState -> TCState) -> TCMT m a -> TCMT m a Source #
MonadIO m => HasBuiltins (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> TCMT m (Maybe (Builtin PrimFun)) Source #
ReportS (TCM Doc) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m () Source #
ReportS [TCM Doc] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> [TCM Doc] -> m () Source #
TraceS (TCM Doc) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m c -> m c Source #
TraceS [TCM Doc] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> [TCM Doc] -> m c -> m c Source #
HasConstInfo (TCMT IO) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> TCMT IO Definition Source # getConstInfo' :: QName -> TCMT IO (Either SigError Definition) Source # getRewriteRulesFor :: QName -> TCMT IO RewriteRules Source #
Null (TCM Doc) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods empty :: TCM Doc Source # null :: TCM Doc -> Bool Source #
MonadIO m => MonadFail (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fail :: String -> TCMT m a Source #
MonadIO m => MonadIO (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftIO :: IO a -> TCMT m a Source #
Applicative m => Applicative (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pure :: a -> TCMT m a Source # (<*>) :: TCMT m (a -> b) -> TCMT m a -> TCMT m b Source # liftA2 :: (a -> b -> c) -> TCMT m a -> TCMT m b -> TCMT m c Source # (*>) :: TCMT m a -> TCMT m b -> TCMT m b Source # (<*) :: TCMT m a -> TCMT m b -> TCMT m a Source #
Functor m => Functor (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> TCMT m a -> TCMT m b Source # (<$) :: a -> TCMT m b -> TCMT m a Source #
Monad m => Monad (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (>>=) :: TCMT m a -> (a -> TCMT m b) -> TCMT m b Source # (>>) :: TCMT m a -> TCMT m b -> TCMT m b Source # return :: a -> TCMT m a Source #
Semigroup (TCM Doc) Source # | This instance is more specific than a generic instance `Semigroup a => Semigroup (TCM a)`.
Instance details Defined in Agda.TypeChecking.Pretty Methods (<>) :: TCM Doc -> TCM Doc -> TCM Doc Source # sconcat :: NonEmpty (TCM Doc) -> TCM Doc Source # stimes :: Integral b => b -> TCM Doc -> TCM Doc Source #
(MonadIO m, Null a) => Null (TCMT m a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods empty :: TCMT m a Source # null :: TCMT m a -> Bool Source #
(IsString a, MonadIO m) => IsString (TCMT m a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fromString :: String -> TCMT m a Source #
(MonadIO m, Semigroup a, Monoid a) => Monoid (TCMT m a) Source # | Strict (non-shortcut) monoid.
Instance details Defined in Agda.TypeChecking.Monad.Base Methods mempty :: TCMT m a Source # mappend :: TCMT m a -> TCMT m a -> TCMT m a Source # mconcat :: [TCMT m a] -> TCMT m a Source #
(MonadIO m, Semigroup a) => Semigroup (TCMT m a) Source # | Strict (non-shortcut) semigroup. Note that there might be a lazy alternative, e.g., for TCM All we might want `and2M` as concatenation, to shortcut conjunction in case we already have `False`.
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (<>) :: TCMT m a -> TCMT m a -> TCMT m a Source # sconcat :: NonEmpty (TCMT m a) -> TCMT m a Source # stimes :: Integral b => b -> TCMT m a -> TCMT m a Source #
type BenchPhase TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type BenchPhase TCM = Phase

data TCState Source #

Constructors

TCSt |

Fields

- stPreScopeState :: !PreScopeState

  The state which is frozen after scope checking.

- stPostScopeState :: !PostScopeState

  The state which is modified after scope checking.

- stPersistentState :: !PersistentTCState

  State which is forever, like a diamond.

#### Instances

Instances details

LensCommandLineOptions TCState Source # |
Instance details Defined in Agda.Interaction.Options.Lenses Methods getCommandLineOptions :: TCState -> CommandLineOptions Source # setCommandLineOptions :: CommandLineOptions -> TCState -> TCState Source # mapCommandLineOptions :: (CommandLineOptions -> CommandLineOptions) -> TCState -> TCState Source #
LensIncludePaths TCState Source # |

Instance details

Defined in Agda.Interaction.Options.Lenses

Methods

getIncludePaths :: TCState -> [FilePath] Source #

setIncludePaths :: [FilePath] -> TCState -> TCState Source #

mapIncludePaths :: ([FilePath] -> [FilePath]) -> TCState -> TCState Source #

getAbsoluteIncludePaths :: TCState -> [AbsolutePath] Source #

setAbsoluteIncludePaths :: [AbsolutePath] -> TCState -> TCState Source #

mapAbsoluteIncludePaths :: ([AbsolutePath] -> [AbsolutePath]) -> TCState -> TCState Source #

LensPersistentVerbosity TCState Source # |
Instance details Defined in Agda.Interaction.Options.Lenses Methods getPersistentVerbosity :: TCState -> PersistentVerbosity Source # setPersistentVerbosity :: PersistentVerbosity -> TCState -> TCState Source # mapPersistentVerbosity :: (PersistentVerbosity -> PersistentVerbosity) -> TCState -> TCState Source #
LensPragmaOptions TCState Source # |
Instance details Defined in Agda.Interaction.Options.Lenses Methods getPragmaOptions :: TCState -> PragmaOptions Source # setPragmaOptions :: PragmaOptions -> TCState -> TCState Source # mapPragmaOptions :: (PragmaOptions -> PragmaOptions) -> TCState -> TCState Source # lensPragmaOptions :: Lens' PragmaOptions TCState Source #
LensSafeMode TCState Source # |
Instance details Defined in Agda.Interaction.Options.Lenses Methods getSafeMode :: TCState -> SafeMode Source # setSafeMode :: SafeMode -> TCState -> TCState Source # mapSafeMode :: (SafeMode -> SafeMode) -> TCState -> TCState Source #
LensVerbosity TCState Source # |
Instance details Defined in Agda.Interaction.Options.Lenses Methods getVerbosity :: TCState -> Verbosity Source # setVerbosity :: Verbosity -> TCState -> TCState Source # mapVerbosity :: (Verbosity -> Verbosity) -> TCState -> TCState Source #
Generic TCState Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep TCState :: Type -> Type Source # Methods from :: TCState -> Rep TCState x Source # to :: Rep TCState x -> TCState Source #
Show TCState Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> TCState -> ShowS Source # show :: TCState -> String Source # showList :: [TCState] -> ShowS Source #
NFData TCState Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TCState -> () Source #
type Rep TCState Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep TCState = D1 ('MetaData "TCState" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "TCSt" 'PrefixI 'True) (S1 ('MetaSel ('Just "stPreScopeState") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PreScopeState) :*: (S1 ('MetaSel ('Just "stPostScopeState") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PostScopeState) :*: S1 ('MetaSel ('Just "stPersistentState") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PersistentTCState))))

data TCEnv Source #

Constructors

TCEnv |

Fields

- envContext :: Context
- envLetBindings :: LetBindings
- envCurrentModule :: ModuleName
- 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`).

- envAnonymousModules :: [(ModuleName, Nat)]

  anonymous modules and their number of free variables

- envImportPath :: [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.

- envMutualBlock :: Maybe MutualId

  the current (if any) mutual block

- envTerminationCheck :: TerminationCheck ()

  are we inside the scope of a termination pragma

- envCoverageCheck :: CoverageCheck

  are we inside the scope of a coverage pragma

- envMakeCase :: Bool

  are we inside a make-case (if so, ignore forcing analysis in unifier)

- envSolvingConstraints :: Bool

  Are we currently in the process of solving active constraints?

- envCheckingWhere :: Bool

  Have we stepped into the where-declarations of a clause? Everything under a `where` will be checked with this flag on.

- envWorkingOnTypes :: Bool

  Are we working on types? Turned on by `workOnTypes`.

- envAssignMetas :: Bool

  Are we allowed to assign metas?

- envActiveProblems :: Set ProblemId
- 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.

- 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.

- 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.

- envDisplayFormsEnabled :: Bool

  Sometimes we want to disable display forms.

- envRange :: Range
- envHighlightingRange :: Range

  Interactive highlighting uses this range rather than `envRange`.

- envClause :: IPClause

  What is the current clause we are type-checking? Will be recorded in interaction points in this clause.

- envCall :: Maybe (Closure Call)

  what we're doing at the moment

- envHighlightingLevel :: HighlightingLevel

  Set to `None` when imported modules are type-checked.

- envHighlightingMethod :: HighlightingMethod
- 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.

- envAppDef :: Maybe QName

  We are reducing an application of this function. (For debugging of incomplete matches only.)

- envSimplification :: Simplification

  Did we encounter a simplification (proper match) during the current reduction process?

- envAllowedReductions :: AllowedReductions
- envReduceDefs :: ReduceDefs
- envReconstructed :: Bool
- envInjectivityDepth :: Int

  Injectivity can cause non-termination for unsolvable contraints (#431, #3067). Keep a limit on the nesting depth of injectivity uses.

- 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.

- envPrintDomainFreePi :: Bool

  When `True`, types will be omitted from printed pi types if they can be inferred.

- 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`.

- 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.

- envUnquoteFlags :: UnquoteFlags
- envInstanceDepth :: !Int

  Until we get a termination checker for instance search (#1743) we limit the search depth to ensure termination.

- envIsDebugPrinting :: Bool
- 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.

- envCallByNeed :: Bool

  Use call-by-need evaluation for reductions.

- envCurrentCheckpoint :: CheckpointId

  Checkpoints track the evolution of the context as we go under binders or refine it by pattern matching.

- envCheckpoints :: Map CheckpointId Substitution

  Keeps the substitution from each previous checkpoint to the current context.

- envGeneralizeMetas :: DoGeneralize

  Should new metas generalized over.

- envGeneralizedVars :: Map QName GeneralizedValue

  Values for used generalizable variables.

- 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`.

- envConflComputingOverlap :: Bool

  Are we currently computing the overlap between two rewrite rules for the purpose of confluence checking?

- envCurrentlyElaborating :: Bool

  Are we currently in the process of executing an elaborate-and-give interactive command?

#### Instances

Instances details

LensIsAbstract TCEnv Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensIsAbstract :: Lens' IsAbstract TCEnv Source #
LensModality TCEnv Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getModality :: TCEnv -> Modality Source # setModality :: Modality -> TCEnv -> TCEnv Source # mapModality :: (Modality -> Modality) -> TCEnv -> TCEnv Source #
LensQuantity TCEnv Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getQuantity :: TCEnv -> Quantity Source # setQuantity :: Quantity -> TCEnv -> TCEnv Source # mapQuantity :: (Quantity -> Quantity) -> TCEnv -> TCEnv Source #
LensRelevance TCEnv Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRelevance :: TCEnv -> Relevance Source # setRelevance :: Relevance -> TCEnv -> TCEnv Source # mapRelevance :: (Relevance -> Relevance) -> TCEnv -> TCEnv Source #
LensTCEnv TCEnv Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensTCEnv :: Lens' TCEnv TCEnv Source #
Generic TCEnv Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep TCEnv :: Type -> Type Source # Methods from :: TCEnv -> Rep TCEnv x Source # to :: Rep TCEnv x -> TCEnv Source #
NFData TCEnv Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TCEnv -> () Source #
type Rep TCEnv Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep TCEnv = D1 ('MetaData "TCEnv" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "TCEnv" 'PrefixI 'True) (((((S1 ('MetaSel ('Just "envContext") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Context) :*: (S1 ('MetaSel ('Just "envLetBindings") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 LetBindings) :*: S1 ('MetaSel ('Just "envCurrentModule") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName))) :*: (S1 ('MetaSel ('Just "envCurrentPath") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe AbsolutePath)) :*: (S1 ('MetaSel ('Just "envAnonymousModules") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(ModuleName, Nat)]) :*: S1 ('MetaSel ('Just "envImportPath") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TopLevelModuleName])))) :*: ((S1 ('MetaSel ('Just "envMutualBlock") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe MutualId)) :*: (S1 ('MetaSel ('Just "envTerminationCheck") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (TerminationCheck ())) :*: S1 ('MetaSel ('Just "envCoverageCheck") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CoverageCheck))) :*: (S1 ('MetaSel ('Just "envMakeCase") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: (S1 ('MetaSel ('Just "envSolvingConstraints") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "envCheckingWhere") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool))))) :*: (((S1 ('MetaSel ('Just "envWorkingOnTypes") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: (S1 ('MetaSel ('Just "envAssignMetas") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "envActiveProblems") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set ProblemId)))) :*: (S1 ('MetaSel ('Just "envAbstractMode") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AbstractMode) :*: (S1 ('MetaSel ('Just "envModality") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Modality) :*: S1 ('MetaSel ('Just "envSplitOnStrict") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))) :*: ((S1 ('MetaSel ('Just "envDisplayFormsEnabled") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: (S1 ('MetaSel ('Just "envRange") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Just "envHighlightingRange") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range))) :*: (S1 ('MetaSel ('Just "envClause") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IPClause) :*: (S1 ('MetaSel ('Just "envCall") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Closure Call))) :*: S1 ('MetaSel ('Just "envHighlightingLevel") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HighlightingLevel)))))) :*: ((((S1 ('MetaSel ('Just "envHighlightingMethod") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HighlightingMethod) :*: (S1 ('MetaSel ('Just "envExpandLast") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ExpandHidden) :*: S1 ('MetaSel ('Just "envAppDef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe QName)))) :*: (S1 ('MetaSel ('Just "envSimplification") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Simplification) :*: (S1 ('MetaSel ('Just "envAllowedReductions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AllowedReductions) :*: S1 ('MetaSel ('Just "envReduceDefs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ReduceDefs)))) :*: ((S1 ('MetaSel ('Just "envReconstructed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: (S1 ('MetaSel ('Just "envInjectivityDepth") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Just "envCompareBlocked") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool))) :*: (S1 ('MetaSel ('Just "envPrintDomainFreePi") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: (S1 ('MetaSel ('Just "envPrintMetasBare") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "envInsideDotPattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool))))) :*: (((S1 ('MetaSel ('Just "envUnquoteFlags") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 UnquoteFlags) :*: (S1 ('MetaSel ('Just "envInstanceDepth") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Just "envIsDebugPrinting") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool))) :*: (S1 ('MetaSel ('Just "envPrintingPatternLambdas") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QName]) :*: (S1 ('MetaSel ('Just "envCallByNeed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "envCurrentCheckpoint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CheckpointId)))) :*: ((S1 ('MetaSel ('Just "envCheckpoints") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Map CheckpointId Substitution)) :*: (S1 ('MetaSel ('Just "envGeneralizeMetas") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DoGeneralize) :*: S1 ('MetaSel ('Just "envGeneralizedVars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Map QName GeneralizedValue)))) :*: (S1 ('MetaSel ('Just "envActiveBackendName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe BackendName)) :*: (S1 ('MetaSel ('Just "envConflComputingOverlap") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "envCurrentlyElaborating") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool))))))))

data HighlightingLevel Source #

How much highlighting should be sent to the user interface?

Constructors

None |
NonInteractive |
Interactive | This includes both non-interactive highlighting and interactive highlighting of the expression that is currently being type-checked.

#### Instances

Instances details

Data HighlightingLevel Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HighlightingLevel -> c HighlightingLevel Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HighlightingLevel Source #

toConstr :: HighlightingLevel -> Constr Source #

dataTypeOf :: HighlightingLevel -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HighlightingLevel) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HighlightingLevel) Source #

gmapT :: (forall b. Data b => b -> b) -> HighlightingLevel -> HighlightingLevel Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HighlightingLevel -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HighlightingLevel -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HighlightingLevel -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HighlightingLevel -> m HighlightingLevel Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HighlightingLevel -> m HighlightingLevel Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HighlightingLevel -> m HighlightingLevel Source #

Generic HighlightingLevel Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep HighlightingLevel :: Type -> Type Source # Methods from :: HighlightingLevel -> Rep HighlightingLevel x Source # to :: Rep HighlightingLevel x -> HighlightingLevel Source #
Read HighlightingLevel Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods readsPrec :: Int -> ReadS HighlightingLevel Source # readList :: ReadS [HighlightingLevel] Source # readPrec :: ReadPrec HighlightingLevel Source # readListPrec :: ReadPrec [HighlightingLevel] Source #
Show HighlightingLevel Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> HighlightingLevel -> ShowS Source # show :: HighlightingLevel -> String Source # showList :: [HighlightingLevel] -> ShowS Source #
NFData HighlightingLevel Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: HighlightingLevel -> () Source #
Eq HighlightingLevel Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: HighlightingLevel -> HighlightingLevel -> Bool Source # (/=) :: HighlightingLevel -> HighlightingLevel -> Bool Source #
Ord HighlightingLevel Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: HighlightingLevel -> HighlightingLevel -> Ordering Source #

(<) :: HighlightingLevel -> HighlightingLevel -> Bool Source #

(<=) :: HighlightingLevel -> HighlightingLevel -> Bool Source #

(>) :: HighlightingLevel -> HighlightingLevel -> Bool Source #

(>=) :: HighlightingLevel -> HighlightingLevel -> Bool Source #

max :: HighlightingLevel -> HighlightingLevel -> HighlightingLevel Source #

min :: HighlightingLevel -> HighlightingLevel -> HighlightingLevel Source #

type Rep HighlightingLevel Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep HighlightingLevel = D1 ('MetaData "HighlightingLevel" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "None" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "NonInteractive" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Interactive" 'PrefixI 'False) (U1 :: Type -> Type)))

data HighlightingMethod Source #

How should highlighting be sent to the user interface?

Constructors

Direct | Via stdout.
Indirect | Both via files and via stdout.

#### Instances

Instances details

Data HighlightingMethod Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HighlightingMethod -> c HighlightingMethod Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HighlightingMethod Source #

toConstr :: HighlightingMethod -> Constr Source #

dataTypeOf :: HighlightingMethod -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HighlightingMethod) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HighlightingMethod) Source #

gmapT :: (forall b. Data b => b -> b) -> HighlightingMethod -> HighlightingMethod Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HighlightingMethod -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HighlightingMethod -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HighlightingMethod -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HighlightingMethod -> m HighlightingMethod Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HighlightingMethod -> m HighlightingMethod Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HighlightingMethod -> m HighlightingMethod Source #

Generic HighlightingMethod Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep HighlightingMethod :: Type -> Type Source # Methods from :: HighlightingMethod -> Rep HighlightingMethod x Source # to :: Rep HighlightingMethod x -> HighlightingMethod Source #
Read HighlightingMethod Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods readsPrec :: Int -> ReadS HighlightingMethod Source # readList :: ReadS [HighlightingMethod] Source # readPrec :: ReadPrec HighlightingMethod Source # readListPrec :: ReadPrec [HighlightingMethod] Source #
Show HighlightingMethod Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> HighlightingMethod -> ShowS Source # show :: HighlightingMethod -> String Source # showList :: [HighlightingMethod] -> ShowS Source #
NFData HighlightingMethod Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: HighlightingMethod -> () Source #
Eq HighlightingMethod Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: HighlightingMethod -> HighlightingMethod -> Bool Source # (/=) :: HighlightingMethod -> HighlightingMethod -> Bool Source #
type Rep HighlightingMethod Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep HighlightingMethod = D1 ('MetaData "HighlightingMethod" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Direct" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Indirect" 'PrefixI 'False) (U1 :: Type -> Type))

data NamedMeta Source #

For printing, we couple a meta with its name suggestion.

Constructors

NamedMeta |

Fields

- nmSuggestion :: MetaNameSuggestion
- nmid :: MetaId

#### Instances

Instances details

EncodeTCM NamedMeta Source # |
Instance details Defined in Agda.Interaction.JSONTop Methods encodeTCM :: NamedMeta -> TCM Value Source #
ToConcrete NamedMeta Source # |
Instance details Defined in Agda.Syntax.Translation.AbstractToConcrete Associated Types type ConOfAbs NamedMeta Source # Methods toConcrete :: NamedMeta -> AbsToCon (ConOfAbs NamedMeta) Source # bindToConcrete :: NamedMeta -> (ConOfAbs NamedMeta -> AbsToCon b) -> AbsToCon b Source #
Pretty NamedMeta Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: NamedMeta -> Doc Source # prettyPrec :: Int -> NamedMeta -> Doc Source # prettyList :: [NamedMeta] -> Doc Source #
type ConOfAbs NamedMeta Source # |
Instance details Defined in Agda.Syntax.Translation.AbstractToConcrete type ConOfAbs NamedMeta = Expr

data TCWarning Source #

Constructors

TCWarning |

Fields

- tcWarningLocation :: CallStack

  Location in the internal Agda source code location where the error raised

- tcWarningRange :: Range

  Range where the warning was raised

- tcWarning :: Warning

  The warning itself

- tcWarningPrintedWarning :: Doc

  The warning printed in the state and environment where it was raised

- tcWarningCached :: Bool

  Should the warning be affected by caching.

#### Instances

Instances details

EncodeTCM TCWarning Source # |
Instance details Defined in Agda.Interaction.JSONTop Methods encodeTCM :: TCWarning -> TCM Value Source #
HasRange TCWarning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: TCWarning -> Range Source #
PrettyTCM TCWarning Source # |
Instance details Defined in Agda.TypeChecking.Pretty.Warning Methods prettyTCM :: MonadPretty m => TCWarning -> m Doc Source #
EmbPrj TCWarning Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Errors Methods icode :: TCWarning -> S Int32 Source # icod_ :: TCWarning -> S Int32 Source # value :: Int32 -> R TCWarning Source #
Generic TCWarning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep TCWarning :: Type -> Type Source # Methods from :: TCWarning -> Rep TCWarning x Source # to :: Rep TCWarning x -> TCWarning Source #
Show TCWarning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> TCWarning -> ShowS Source # show :: TCWarning -> String Source # showList :: [TCWarning] -> ShowS Source #
NFData TCWarning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TCWarning -> () Source #
Eq TCWarning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: TCWarning -> TCWarning -> Bool Source # (/=) :: TCWarning -> TCWarning -> Bool Source #
type Rep TCWarning Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep TCWarning = D1 ('MetaData "TCWarning" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "TCWarning" 'PrefixI 'True) ((S1 ('MetaSel ('Just "tcWarningLocation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CallStack) :*: S1 ('MetaSel ('Just "tcWarningRange") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range)) :*: (S1 ('MetaSel ('Just "tcWarning") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Warning) :*: (S1 ('MetaSel ('Just "tcWarningPrintedWarning") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc) :*: S1 ('MetaSel ('Just "tcWarningCached") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))))

data TCErr Source #

Type-checking errors.

Constructors

TypeError |

Fields

- tcErrLocation :: CallStack

  Location in the internal Agda source code where the error was raised

- tcErrState :: TCState

  The state in which the error was raised.

- tcErrClosErr :: Closure TypeError

  The environment in which the error as raised plus the error.

Exception Range Doc |
IOException TCState Range 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.

#### Instances

Instances details

EncodeTCM TCErr Source # |
Instance details Defined in Agda.Interaction.JSONTop Methods encodeTCM :: TCErr -> TCM Value Source #
HasRange TCErr Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: TCErr -> Range Source #
PrettyTCM TCErr Source # |
Instance details Defined in Agda.TypeChecking.Errors Methods prettyTCM :: MonadPretty m => TCErr -> m Doc Source #
Exception TCErr Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods toException :: TCErr -> SomeException Source # fromException :: SomeException -> Maybe TCErr Source # displayException :: TCErr -> String Source #
Show TCErr Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> TCErr -> ShowS Source # show :: TCErr -> String Source # showList :: [TCErr] -> ShowS Source #
NFData TCErr Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TCErr -> () Source #
MonadError TCErr IM Source # |
Instance details Defined in Agda.Interaction.Monad Methods throwError :: TCErr -> IM a Source # catchError :: IM a -> (TCErr -> IM a) -> IM a Source #
MonadError TCErr TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods throwError :: TCErr -> TerM a Source # catchError :: TerM a -> (TCErr -> TerM a) -> TerM a Source #
MonadError TCErr TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods throwError :: TCErr -> TCM a Source # catchError :: TCM a -> (TCErr -> TCM a) -> TCM a Source #
Monad m => MonadError TCErr (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods throwError :: TCErr -> PureConversionT m a Source # catchError :: PureConversionT m a -> (TCErr -> PureConversionT m a) -> PureConversionT m a Source #
Monad m => MonadBlock (ExceptT TCErr m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternViolation :: Blocker -> ExceptT TCErr m a Source # catchPatternErr :: (Blocker -> ExceptT TCErr m a) -> ExceptT TCErr m a -> ExceptT TCErr m a Source #

data Warning Source #

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

Constructors

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 [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 [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.
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.
SafeFlagPostulate 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 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 QName [Name] [Name] [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 [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 |

#### Instances

Instances details

EmbPrj Warning Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Errors Methods icode :: Warning -> S Int32 Source # icod_ :: Warning -> S Int32 Source # value :: Int32 -> R Warning Source #
Generic Warning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Warning :: Type -> Type Source # Methods from :: Warning -> Rep Warning x Source # to :: Rep Warning x -> Warning Source #
Show Warning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Warning -> ShowS Source # show :: Warning -> String Source # showList :: [Warning] -> ShowS Source #
NFData Warning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Warning -> () Source #
type Rep Warning Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Warning = D1 ('MetaData "Warning" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (((((C1 ('MetaCons "NicifierIssue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DeclarationWarning)) :+: (C1 ('MetaCons "TerminationIssue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TerminationError])) :+: C1 ('MetaCons "UnreachableClauses" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Range])))) :+: ((C1 ('MetaCons "CoverageIssue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Telescope, [NamedArg DeBruijnPattern])])) :+: C1 ('MetaCons "CoverageNoExactSplit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause]))) :+: (C1 ('MetaCons "NotStrictlyPositive" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Seq OccursWhere))) :+: C1 ('MetaCons "UnsolvedMetaVariables" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Range]))))) :+: ((C1 ('MetaCons "UnsolvedInteractionMetas" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Range])) :+: (C1 ('MetaCons "UnsolvedConstraints" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Constraints)) :+: C1 ('MetaCons "CantGeneralizeOverSorts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [MetaId])))) :+: ((C1 ('MetaCons "AbsurdPatternRequiresNoRHS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [NamedArg DeBruijnPattern])) :+: C1 ('MetaCons "OldBuiltin" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) :+: (C1 ('MetaCons "EmptyRewritePragma" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EmptyWhere" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "IllformedAsClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: (C1 ('MetaCons "ClashesViaRenaming" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NameOrModule) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :+: C1 ('MetaCons "UselessPatternDeclarationForRecord" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))) :+: ((C1 ('MetaCons "UselessPublic" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UselessHiding" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ImportedName]))) :+: (C1 ('MetaCons "UselessInline" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "WrongInstanceDeclaration" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "InstanceWithExplicitArg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "InstanceNoOutputTypeName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc))) :+: (C1 ('MetaCons "InstanceArgWithExplicitArg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc)) :+: C1 ('MetaCons "InversionDepthReached" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)))) :+: ((C1 ('MetaCons "NoGuardednessFlag" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "GenericWarning" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc))) :+: (C1 ('MetaCons "GenericNonFatalError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc)) :+: C1 ('MetaCons "GenericUseless" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc))))))) :+: ((((C1 ('MetaCons "SafeFlagPostulate" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: (C1 ('MetaCons "SafeFlagPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [String])) :+: C1 ('MetaCons "SafeFlagNonTerminating" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "SafeFlagTerminating" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SafeFlagWithoutKFlagPrimEraseEquality" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "WithoutKFlagPrimEraseEquality" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SafeFlagNoPositivityCheck" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "SafeFlagPolarity" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SafeFlagNoUniverseCheck" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SafeFlagNoCoverageCheck" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "SafeFlagInjective" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SafeFlagEta" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ParseWarning" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ParseWarning)) :+: C1 ('MetaCons "LibraryWarning" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 LibWarning)))))) :+: (((C1 ('MetaCons "DeprecationWarning" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) :+: (C1 ('MetaCons "UserWarning" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)) :+: C1 ('MetaCons "DuplicateUsing" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List1 ImportedName))))) :+: ((C1 ('MetaCons "FixityInRenamingModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List1 Range))) :+: C1 ('MetaCons "ModuleDoesntExport" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ImportedName])))) :+: (C1 ('MetaCons "InfectiveImport" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName)) :+: C1 ('MetaCons "CoInfectiveImport" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName))))) :+: (((C1 ('MetaCons "RewriteNonConfluent" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc))) :+: C1 ('MetaCons "RewriteMaybeNonConfluent" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Doc])))) :+: (C1 ('MetaCons "RewriteAmbiguousRules" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: C1 ('MetaCons "RewriteMissingRule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))))) :+: ((C1 ('MetaCons "PragmaCompileErased" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BackendName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "NotInScopeW" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QName]))) :+: (C1 ('MetaCons "AsPatternShadowsConstructorOrPatternSynonym" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :+: C1 ('MetaCons "RecordFieldWarning" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RecordFieldWarning))))))))

builtinNat :: String Source #

builtinSuc :: String Source #

builtinZero :: String Source #

builtinNatPlus :: String Source #

builtinNatMinus :: String Source #

builtinNatTimes :: String Source #

builtinNatDivSucAux :: String Source #

builtinNatModSucAux :: String Source #

builtinNatEquals :: String Source #

builtinNatLess :: String Source #

builtinWord64 :: String Source #

builtinInteger :: String Source #

builtinIntegerPos :: String Source #

builtinIntegerNegSuc :: String Source #

builtinFloat :: String Source #

builtinChar :: String Source #

builtinString :: String Source #

builtinUnit :: String Source #

builtinUnitUnit :: String Source #

builtinSigma :: String Source #

builtinBool :: String Source #

builtinTrue :: String Source #

builtinFalse :: String Source #

builtinList :: String Source #

builtinNil :: String Source #

builtinCons :: String Source #

builtinMaybe :: String Source #

builtinNothing :: String Source #

builtinJust :: String Source #

builtinIO :: String Source #

builtinId :: String Source #

builtinConId :: String Source #

builtinIdElim :: String Source #

builtinPath :: String Source #

builtinPathP :: String Source #

builtinInterval :: String Source #

builtinIMin :: String Source #

builtinIMax :: String Source #

builtinINeg :: String Source #

builtinIZero :: String Source #

builtinIOne :: String Source #

builtinPartial :: String Source #

builtinPartialP :: String Source #

builtinIsOne :: String Source #

builtinItIsOne :: String Source #

builtinEquiv :: String Source #

builtinEquivFun :: String Source #

builtinEquivProof :: String Source #

builtinTranspProof :: String Source #

builtinGlue :: String Source #

builtin_glue :: String Source #

builtin_unglue :: String Source #

builtin_glueU :: String Source #

builtin_unglueU :: String Source #

builtinFaceForall :: String Source #

builtinIsOne1 :: String Source #

builtinIsOne2 :: String Source #

builtinIsOneEmpty :: String Source #

builtinComp :: String Source #

builtinPOr :: String Source #

builtinTrans :: String Source #

builtinHComp :: String Source #

builtinSub :: String Source #

builtinSubIn :: String Source #

builtinSubOut :: String Source #

builtinSizeUniv :: String Source #

builtinSize :: String Source #

builtinSizeLt :: String Source #

builtinSizeSuc :: String Source #

builtinSizeInf :: String Source #

builtinSizeMax :: String Source #

builtinInf :: String Source #

builtinSharp :: String Source #

builtinFlat :: String Source #

builtinEquality :: String Source #

builtinRefl :: String Source #

builtinRewrite :: String Source #

builtinLevelMax :: String Source #

builtinLevel :: String Source #

builtinLevelZero :: String Source #

builtinLevelSuc :: String Source #

builtinSet :: String Source #

builtinProp :: String Source #

builtinSetOmega :: String Source #

builtinLockUniv :: String Source #

builtinSSetOmega :: String Source #

builtinStrictSet :: String Source #

builtinFromNat :: String Source #

builtinFromNeg :: String Source #

builtinFromString :: String Source #

builtinQName :: String Source #

builtinAgdaSort :: String Source #

builtinAgdaSortSet :: String Source #

builtinAgdaSortLit :: String Source #

builtinAgdaSortProp :: String Source #

builtinAgdaSortPropLit :: String Source #

builtinAgdaSortInf :: String Source #

builtinAgdaSortUnsupported :: String Source #

builtinHiding :: String Source #

builtinHidden :: String Source #

builtinInstance :: String Source #

builtinVisible :: String Source #

builtinRelevance :: String Source #

builtinRelevant :: String Source #

builtinIrrelevant :: String Source #

builtinQuantity :: String Source #

builtinQuantity0 :: String Source #

builtinQuantityω :: String Source #

builtinModality :: String Source #

builtinModalityConstructor :: String Source #

builtinAssoc :: String Source #

builtinAssocLeft :: String Source #

builtinAssocRight :: String Source #

builtinAssocNon :: String Source #

builtinPrecedence :: String Source #

builtinPrecRelated :: String Source #

builtinPrecUnrelated :: String Source #

builtinFixity :: String Source #

builtinFixityFixity :: String Source #

builtinArg :: String Source #

builtinArgInfo :: String Source #

builtinArgArgInfo :: String Source #

builtinArgArg :: String Source #

builtinAbs :: String Source #

builtinAbsAbs :: String Source #

builtinAgdaTerm :: String Source #

builtinAgdaTermVar :: String Source #

builtinAgdaTermLam :: String Source #

builtinAgdaTermExtLam :: String Source #

builtinAgdaTermDef :: String Source #

builtinAgdaTermCon :: String Source #

builtinAgdaTermPi :: String Source #

builtinAgdaTermSort :: String Source #

builtinAgdaTermLit :: String Source #

builtinAgdaTermUnsupported :: String Source #

builtinAgdaTermMeta :: String Source #

builtinAgdaErrorPart :: String Source #

builtinAgdaErrorPartString :: String Source #

builtinAgdaErrorPartTerm :: String Source #

builtinAgdaErrorPartName :: String Source #

builtinAgdaLiteral :: String Source #

builtinAgdaLitNat :: String Source #

builtinAgdaLitWord64 :: String Source #

builtinAgdaLitFloat :: String Source #

builtinAgdaLitChar :: String Source #

builtinAgdaLitString :: String Source #

builtinAgdaLitQName :: String Source #

builtinAgdaLitMeta :: String Source #

builtinAgdaClause :: String Source #

builtinAgdaClauseClause :: String Source #

builtinAgdaClauseAbsurd :: String Source #

builtinAgdaPattern :: String Source #

builtinAgdaPatVar :: String Source #

builtinAgdaPatCon :: String Source #

builtinAgdaPatDot :: String Source #

builtinAgdaPatLit :: String Source #

builtinAgdaPatProj :: String Source #

builtinAgdaPatAbsurd :: String Source #

builtinAgdaDefinitionFunDef :: String Source #

builtinAgdaDefinitionDataDef :: String Source #

builtinAgdaDefinitionRecordDef :: String Source #

builtinAgdaDefinitionDataConstructor :: String Source #

builtinAgdaDefinitionPostulate :: String Source #

builtinAgdaDefinitionPrimitive :: String Source #

builtinAgdaDefinition :: String Source #

builtinAgdaMeta :: String Source #

builtinAgdaTCM :: String Source #

builtinAgdaTCMReturn :: String Source #

builtinAgdaTCMBind :: String Source #

builtinAgdaTCMUnify :: String Source #

builtinAgdaTCMTypeError :: String Source #

builtinAgdaTCMInferType :: String Source #

builtinAgdaTCMCheckType :: String Source #

builtinAgdaTCMNormalise :: String Source #

builtinAgdaTCMReduce :: String Source #

builtinAgdaTCMCatchError :: String Source #

builtinAgdaTCMGetContext :: String Source #

builtinAgdaTCMExtendContext :: String Source #

builtinAgdaTCMInContext :: String Source #

builtinAgdaTCMFreshName :: String Source #

builtinAgdaTCMDeclareDef :: String Source #

builtinAgdaTCMDeclarePostulate :: String Source #

builtinAgdaTCMDefineFun :: String Source #

builtinAgdaTCMGetType :: String Source #

builtinAgdaTCMGetDefinition :: String Source #

builtinAgdaTCMBlockOnMeta :: String Source #

builtinAgdaTCMCommit :: String Source #

builtinAgdaTCMQuoteTerm :: String Source #

builtinAgdaTCMUnquoteTerm :: String Source #

builtinAgdaTCMQuoteOmegaTerm :: String Source #

builtinAgdaTCMIsMacro :: String Source #

builtinAgdaTCMWithNormalisation :: String Source #

builtinAgdaTCMWithReconsParams :: String Source #

builtinAgdaTCMDebugPrint :: String Source #

builtinAgdaTCMOnlyReduceDefs :: String Source #

builtinAgdaTCMDontReduceDefs :: String Source #

builtinAgdaTCMNoConstraints :: String Source #

builtinAgdaTCMRunSpeculative :: String Source #

builtinAgdaTCMExec :: String Source #

isBuiltinNoDef :: String -> Bool Source #

Builtins that come without a definition in Agda syntax. These are giving names to Agda internal concepts which cannot be assigned an Agda type.

An example would be a user-defined name for `Set`.

{-# BUILTIN TYPE Type #-}

The type of `Type` would be `Type : Level → Setω` which is not valid Agda.

builtinsNoDef :: [String] Source #

sizeBuiltins :: [String] Source #

type Verbosity = Trie VerboseKey VerboseLevel Source #

type VerboseLevel = Int Source #

type VerboseKey = String Source #

class (Functor m, Applicative m, Monad m) => HasOptions m where Source #

Minimal complete definition

Nothing

Methods

pragmaOptions :: m PragmaOptions Source #

Returns the pragma options which are currently in effect.

default pragmaOptions :: (HasOptions n, MonadTrans t, m ~ t n) => m PragmaOptions Source #

commandLineOptions :: m CommandLineOptions Source #

Returns the command line options which are currently in effect.

default commandLineOptions :: (HasOptions n, MonadTrans t, m ~ t n) => m CommandLineOptions Source #

#### Instances

Instances details

HasOptions IM Source # |
Instance details Defined in Agda.Interaction.Monad Methods pragmaOptions :: IM PragmaOptions Source # commandLineOptions :: IM CommandLineOptions Source #
HasOptions AbsToCon Source # |
Instance details Defined in Agda.Syntax.Translation.AbstractToConcrete Methods pragmaOptions :: AbsToCon PragmaOptions Source # commandLineOptions :: AbsToCon CommandLineOptions Source #
HasOptions TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods pragmaOptions :: TerM PragmaOptions Source # commandLineOptions :: TerM CommandLineOptions Source #
HasOptions ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pragmaOptions :: ReduceM PragmaOptions Source # commandLineOptions :: ReduceM CommandLineOptions Source #
HasOptions NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods pragmaOptions :: NLM PragmaOptions Source # commandLineOptions :: NLM CommandLineOptions Source #
HasOptions m => HasOptions (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods pragmaOptions :: PureConversionT m PragmaOptions Source # commandLineOptions :: PureConversionT m CommandLineOptions Source #
HasOptions m => HasOptions (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pragmaOptions :: BlockT m PragmaOptions Source # commandLineOptions :: BlockT m CommandLineOptions Source #
MonadIO m => HasOptions (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pragmaOptions :: TCMT m PragmaOptions Source # commandLineOptions :: TCMT m CommandLineOptions Source #
HasOptions m => HasOptions (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods pragmaOptions :: NamesT m PragmaOptions Source # commandLineOptions :: NamesT m CommandLineOptions Source #
HasOptions m => HasOptions (ListT m) Source # |
Instance details Defined in Agda.Interaction.Options.HasOptions Methods pragmaOptions :: ListT m PragmaOptions Source # commandLineOptions :: ListT m CommandLineOptions Source #
HasOptions m => HasOptions (ChangeT m) Source # |
Instance details Defined in Agda.Interaction.Options.HasOptions Methods pragmaOptions :: ChangeT m PragmaOptions Source # commandLineOptions :: ChangeT m CommandLineOptions Source #
HasOptions m => HasOptions (MaybeT m) Source # |
Instance details Defined in Agda.Interaction.Options.HasOptions Methods pragmaOptions :: MaybeT m PragmaOptions Source # commandLineOptions :: MaybeT m CommandLineOptions Source #
HasOptions m => HasOptions (ExceptT e m) Source # |
Instance details Defined in Agda.Interaction.Options.HasOptions Methods pragmaOptions :: ExceptT e m PragmaOptions Source # commandLineOptions :: ExceptT e m CommandLineOptions Source #
HasOptions m => HasOptions (IdentityT m) Source # |
Instance details Defined in Agda.Interaction.Options.HasOptions Methods pragmaOptions :: IdentityT m PragmaOptions Source # commandLineOptions :: IdentityT m CommandLineOptions Source #
HasOptions m => HasOptions (ReaderT r m) Source # |
Instance details Defined in Agda.Interaction.Options.HasOptions Methods pragmaOptions :: ReaderT r m PragmaOptions Source # commandLineOptions :: ReaderT r m CommandLineOptions Source #
HasOptions m => HasOptions (StateT s m) Source # |
Instance details Defined in Agda.Interaction.Options.HasOptions Methods pragmaOptions :: StateT s m PragmaOptions Source # commandLineOptions :: StateT s m CommandLineOptions Source #
(HasOptions m, Monoid w) => HasOptions (WriterT w m) Source # |
Instance details Defined in Agda.Interaction.Options.HasOptions Methods pragmaOptions :: WriterT w m PragmaOptions Source # commandLineOptions :: WriterT w m CommandLineOptions Source #

type MonadTCError m = (MonadTCEnv m, ReadTCState m, MonadError TCErr m) Source #

The constraints needed for `typeError` and similar.

class (Applicative tcm, MonadIO tcm, MonadTCEnv tcm, MonadTCState tcm, HasOptions tcm) => MonadTCM tcm where Source #

Embedding a TCM computation.

Minimal complete definition

Nothing

Methods

liftTCM :: TCM a -> tcm a Source #

default liftTCM :: (MonadTCM m, MonadTrans t, tcm ~ t m) => TCM a -> tcm a Source #

#### Instances

Instances details

MonadTCM IM Source # |
Instance details Defined in Agda.Interaction.Monad Methods liftTCM :: TCM a -> IM a Source #
MonadTCM TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods liftTCM :: TCM a -> TerM a Source #
MonadTCM m => MonadTCM (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> BlockT m a Source #
MonadIO m => MonadTCM (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> TCMT m a Source #
MonadTCM m => MonadTCM (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods liftTCM :: TCM a -> NamesT m a Source #
MonadTCM tcm => MonadTCM (ListT tcm) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> ListT tcm a Source #
MonadTCM tcm => MonadTCM (ChangeT tcm) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> ChangeT tcm a Source #
MonadTCM tcm => MonadTCM (MaybeT tcm) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> MaybeT tcm a Source #
MonadTCM tcm => MonadTCM (ExceptT err tcm) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> ExceptT err tcm a Source #
MonadTCM tcm => MonadTCM (IdentityT tcm) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> IdentityT tcm a Source #
MonadTCM tcm => MonadTCM (ReaderT r tcm) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> ReaderT r tcm a Source #
MonadTCM tcm => MonadTCM (StateT s tcm) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> StateT s tcm a Source #
(Monoid w, MonadTCM tcm) => MonadTCM (WriterT w tcm) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> WriterT w tcm a Source #

newtype BlockT m a Source #

Constructors

BlockT |

Fields

- unBlockT :: ExceptT Blocker m a

#### Instances

Instances details

MonadTrans BlockT Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lift :: Monad m => m a -> BlockT m a Source #
HasOptions m => HasOptions (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pragmaOptions :: BlockT m PragmaOptions Source # commandLineOptions :: BlockT m CommandLineOptions Source #
Monad m => MonadBlock (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternViolation :: Blocker -> BlockT m a Source # catchPatternErr :: (Blocker -> BlockT m a) -> BlockT m a -> BlockT m a Source #
MonadReduce m => MonadReduce (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> BlockT m a Source #
MonadTCEnv m => MonadTCEnv (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: BlockT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> BlockT m a -> BlockT m a Source #
MonadTCM m => MonadTCM (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftTCM :: TCM a -> BlockT m a Source #
MonadTCState m => MonadTCState (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: BlockT m TCState Source # putTC :: TCState -> BlockT m () Source # modifyTC :: (TCState -> TCState) -> BlockT m () Source #
ReadTCState m => ReadTCState (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: BlockT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> BlockT m b -> BlockT m b Source # withTCState :: (TCState -> TCState) -> BlockT m a -> BlockT m a Source #
HasBuiltins m => HasBuiltins (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> BlockT m (Maybe (Builtin PrimFun)) Source #
MonadAddContext m => MonadAddContext (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addCtx :: Name -> Dom Type -> BlockT m a -> BlockT m a Source # addLetBinding' :: Name -> Term -> Dom Type -> BlockT m a -> BlockT m a Source # updateContext :: Substitution -> (Context -> Context) -> BlockT m a -> BlockT m a Source # withFreshName :: Range -> ArgName -> (Name -> BlockT m a) -> BlockT m a Source #
MonadDebug m => MonadDebug (BlockT m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Debug

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> BlockT m String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> BlockT m a -> BlockT m a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> BlockT m a -> BlockT m a Source #

getVerbosity :: BlockT m Verbosity Source #

isDebugPrinting :: BlockT m Bool Source #

nowDebugPrinting :: BlockT m a -> BlockT m a Source #

PureTCM m => PureTCM (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
HasConstInfo m => HasConstInfo (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> BlockT m Definition Source # getConstInfo' :: QName -> BlockT m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> BlockT m RewriteRules Source #
MonadFail m => MonadFail (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fail :: String -> BlockT m a Source #
MonadIO m => MonadIO (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftIO :: IO a -> BlockT m a Source #
Monad m => Applicative (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pure :: a -> BlockT m a Source # (<*>) :: BlockT m (a -> b) -> BlockT m a -> BlockT m b Source # liftA2 :: (a -> b -> c) -> BlockT m a -> BlockT m b -> BlockT m c Source # (*>) :: BlockT m a -> BlockT m b -> BlockT m b Source # (<*) :: BlockT m a -> BlockT m b -> BlockT m a Source #
Functor m => Functor (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> BlockT m a -> BlockT m b Source # (<$) :: a -> BlockT m b -> BlockT m a Source #
Monad m => Monad (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (>>=) :: BlockT m a -> (a -> BlockT m b) -> BlockT m b Source # (>>) :: BlockT m a -> BlockT m b -> BlockT m b Source # return :: a -> BlockT m a Source #

class Monad m => MonadBlock m where Source #

Minimal complete definition

catchPatternErr

Methods

patternViolation :: Blocker -> m a Source #

`patternViolation b` aborts the current computation

default patternViolation :: (MonadTrans t, MonadBlock n, m ~ t n) => Blocker -> m a Source #

catchPatternErr :: (Blocker -> m a) -> m a -> m a Source #

`catchPatternErr handle m` runs m, handling pattern violations with `handle` (doesn't roll back the state)

#### Instances

Instances details

MonadBlock TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternViolation :: Blocker -> TCM a Source # catchPatternErr :: (Blocker -> TCM a) -> TCM a -> TCM a Source #
MonadBlock NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods patternViolation :: Blocker -> NLM a Source # catchPatternErr :: (Blocker -> NLM a) -> NLM a -> NLM a Source #
Monad m => MonadBlock (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods patternViolation :: Blocker -> PureConversionT m a Source # catchPatternErr :: (Blocker -> PureConversionT m a) -> PureConversionT m a -> PureConversionT m a Source #
Monad m => MonadBlock (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternViolation :: Blocker -> BlockT m a Source # catchPatternErr :: (Blocker -> BlockT m a) -> BlockT m a -> BlockT m a Source #
MonadBlock m => MonadBlock (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternViolation :: Blocker -> MaybeT m a Source # catchPatternErr :: (Blocker -> MaybeT m a) -> MaybeT m a -> MaybeT m a Source #
Monad m => MonadBlock (ExceptT TCErr m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternViolation :: Blocker -> ExceptT TCErr m a Source # catchPatternErr :: (Blocker -> ExceptT TCErr m a) -> ExceptT TCErr m a -> ExceptT TCErr m a Source #
MonadBlock m => MonadBlock (ReaderT e m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternViolation :: Blocker -> ReaderT e m a Source # catchPatternErr :: (Blocker -> ReaderT e m a) -> ReaderT e m a -> ReaderT e m a Source #

class Monad m => MonadTCState m where Source #

`MonadTCState` made into its own dedicated service class. This allows us to use `MonadState` for `StateT` extensions of `TCM`.

Minimal complete definition

Nothing

Methods

getTC :: m TCState Source #

default getTC :: (MonadTrans t, MonadTCState n, t n ~ m) => m TCState Source #

putTC :: TCState -> m () Source #

default putTC :: (MonadTrans t, MonadTCState n, t n ~ m) => TCState -> m () Source #

modifyTC :: (TCState -> TCState) -> m () Source #

default modifyTC :: (MonadTrans t, MonadTCState n, t n ~ m) => (TCState -> TCState) -> m () Source #

#### Instances

Instances details

MonadTCState IM Source # |
Instance details Defined in Agda.Interaction.Monad Methods getTC :: IM TCState Source # putTC :: TCState -> IM () Source # modifyTC :: (TCState -> TCState) -> IM () Source #
MonadTCState TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods getTC :: TerM TCState Source # putTC :: TCState -> TerM () Source # modifyTC :: (TCState -> TCState) -> TerM () Source #
MonadTCState m => MonadTCState (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: BlockT m TCState Source # putTC :: TCState -> BlockT m () Source # modifyTC :: (TCState -> TCState) -> BlockT m () Source #
MonadIO m => MonadTCState (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: TCMT m TCState Source # putTC :: TCState -> TCMT m () Source # modifyTC :: (TCState -> TCState) -> TCMT m () Source #
MonadTCState m => MonadTCState (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods getTC :: NamesT m TCState Source # putTC :: TCState -> NamesT m () Source # modifyTC :: (TCState -> TCState) -> NamesT m () Source #
MonadTCState m => MonadTCState (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: ListT m TCState Source # putTC :: TCState -> ListT m () Source # modifyTC :: (TCState -> TCState) -> ListT m () Source #
MonadTCState m => MonadTCState (ChangeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: ChangeT m TCState Source # putTC :: TCState -> ChangeT m () Source # modifyTC :: (TCState -> TCState) -> ChangeT m () Source #
MonadTCState m => MonadTCState (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: MaybeT m TCState Source # putTC :: TCState -> MaybeT m () Source # modifyTC :: (TCState -> TCState) -> MaybeT m () Source #
MonadTCState m => MonadTCState (ExceptT err m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: ExceptT err m TCState Source # putTC :: TCState -> ExceptT err m () Source # modifyTC :: (TCState -> TCState) -> ExceptT err m () Source #
MonadTCState m => MonadTCState (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: IdentityT m TCState Source # putTC :: TCState -> IdentityT m () Source # modifyTC :: (TCState -> TCState) -> IdentityT m () Source #
MonadTCState m => MonadTCState (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: ReaderT r m TCState Source # putTC :: TCState -> ReaderT r m () Source # modifyTC :: (TCState -> TCState) -> ReaderT r m () Source #
MonadTCState m => MonadTCState (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: StateT s m TCState Source # putTC :: TCState -> StateT s m () Source # modifyTC :: (TCState -> TCState) -> StateT s m () Source #
(Monoid w, MonadTCState m) => MonadTCState (WriterT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTC :: WriterT w m TCState Source # putTC :: TCState -> WriterT w m () Source # modifyTC :: (TCState -> TCState) -> WriterT w m () Source #

class Monad m => MonadTCEnv m where Source #

`MonadTCEnv` made into its own dedicated service class. This allows us to use `MonadReader` for `ReaderT` extensions of `TCM`.

Minimal complete definition

Nothing

Methods

askTC :: m TCEnv Source #

default askTC :: (MonadTrans t, MonadTCEnv n, t n ~ m) => m TCEnv Source #

localTC :: (TCEnv -> TCEnv) -> m a -> m a Source #

default localTC :: (MonadTransControl t, MonadTCEnv n, t n ~ m) => (TCEnv -> TCEnv) -> m a -> m a Source #

#### Instances

Instances details

MonadTCEnv IM Source # |
Instance details Defined in Agda.Interaction.Monad Methods askTC :: IM TCEnv Source # localTC :: (TCEnv -> TCEnv) -> IM a -> IM a Source #
MonadTCEnv AbsToCon Source # |
Instance details Defined in Agda.Syntax.Translation.AbstractToConcrete Methods askTC :: AbsToCon TCEnv Source # localTC :: (TCEnv -> TCEnv) -> AbsToCon a -> AbsToCon a Source #
MonadTCEnv TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods askTC :: TerM TCEnv Source # localTC :: (TCEnv -> TCEnv) -> TerM a -> TerM a Source #
MonadTCEnv ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: ReduceM TCEnv Source # localTC :: (TCEnv -> TCEnv) -> ReduceM a -> ReduceM a Source #
MonadTCEnv NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods askTC :: NLM TCEnv Source # localTC :: (TCEnv -> TCEnv) -> NLM a -> NLM a Source #
MonadTCEnv m => MonadTCEnv (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods askTC :: PureConversionT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> PureConversionT m a -> PureConversionT m a Source #
MonadTCEnv m => MonadTCEnv (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: BlockT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> BlockT m a -> BlockT m a Source #
MonadIO m => MonadTCEnv (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: TCMT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> TCMT m a -> TCMT m a Source #
MonadTCEnv m => MonadTCEnv (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods askTC :: NamesT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> NamesT m a -> NamesT m a Source #
MonadTCEnv m => MonadTCEnv (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: ListT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> ListT m a -> ListT m a Source #
MonadTCEnv m => MonadTCEnv (ChangeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: ChangeT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> ChangeT m a -> ChangeT m a Source #
MonadTCEnv m => MonadTCEnv (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: MaybeT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> MaybeT m a -> MaybeT m a Source #
MonadTCEnv m => MonadTCEnv (ExceptT err m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: ExceptT err m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> ExceptT err m a -> ExceptT err m a Source #
MonadTCEnv m => MonadTCEnv (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: IdentityT m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> IdentityT m a -> IdentityT m a Source #
MonadTCEnv m => MonadTCEnv (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: ReaderT r m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> ReaderT r m a -> ReaderT r m a Source #
MonadTCEnv m => MonadTCEnv (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: StateT s m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> StateT s m a -> StateT s m a Source #
(Monoid w, MonadTCEnv m) => MonadTCEnv (WriterT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: WriterT w m TCEnv Source # localTC :: (TCEnv -> TCEnv) -> WriterT w m a -> WriterT w m a Source #

class (Applicative m, MonadTCEnv m, ReadTCState m, HasOptions m) => MonadReduce m where Source #

Minimal complete definition

Nothing

Methods

liftReduce :: ReduceM a -> m a Source #

default liftReduce :: (MonadTrans t, MonadReduce n, t n ~ m) => ReduceM a -> m a Source #

#### Instances

Instances details

MonadReduce TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods liftReduce :: ReduceM a -> TerM a Source #
MonadReduce ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> ReduceM a Source #
MonadReduce NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods liftReduce :: ReduceM a -> NLM a Source #
MonadReduce m => MonadReduce (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods liftReduce :: ReduceM a -> PureConversionT m a Source #
MonadReduce m => MonadReduce (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> BlockT m a Source #
MonadIO m => MonadReduce (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> TCMT m a Source #
MonadReduce m => MonadReduce (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods liftReduce :: ReduceM a -> NamesT m a Source #
MonadReduce m => MonadReduce (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> ListT m a Source #
MonadReduce m => MonadReduce (ChangeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> ChangeT m a Source #
MonadReduce m => MonadReduce (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> MaybeT m a Source #
MonadReduce m => MonadReduce (ExceptT err m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> ExceptT err m a Source #
MonadReduce m => MonadReduce (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> IdentityT m a Source #
MonadReduce m => MonadReduce (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> ReaderT r m a Source #
MonadReduce m => MonadReduce (StateT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> StateT w m a Source #
(Monoid w, MonadReduce m) => MonadReduce (WriterT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> WriterT w m a Source #

newtype ReduceM a Source #

Constructors

ReduceM |

Fields

- unReduceM :: ReduceEnv -> a

#### Instances

Instances details

HasOptions ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pragmaOptions :: ReduceM PragmaOptions Source # commandLineOptions :: ReduceM CommandLineOptions Source #
MonadReduce ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods liftReduce :: ReduceM a -> ReduceM a Source #
MonadTCEnv ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods askTC :: ReduceM TCEnv Source # localTC :: (TCEnv -> TCEnv) -> ReduceM a -> ReduceM a Source #
ReadTCState ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: ReduceM TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> ReduceM b -> ReduceM b Source # withTCState :: (TCState -> TCState) -> ReduceM a -> ReduceM a Source #
HasBuiltins ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Reduce.Monad Methods getBuiltinThing :: String -> ReduceM (Maybe (Builtin PrimFun)) Source #
MonadAddContext ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Reduce.Monad Methods addCtx :: Name -> Dom Type -> ReduceM a -> ReduceM a Source # addLetBinding' :: Name -> Term -> Dom Type -> ReduceM a -> ReduceM a Source # updateContext :: Substitution -> (Context -> Context) -> ReduceM a -> ReduceM a Source # withFreshName :: Range -> ArgName -> (Name -> ReduceM a) -> ReduceM a Source #
MonadDebug ReduceM Source # |

Instance details

Defined in Agda.TypeChecking.Reduce.Monad

Methods

formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> ReduceM String Source #

traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> ReduceM a -> ReduceM a Source #

verboseBracket :: VerboseKey -> VerboseLevel -> String -> ReduceM a -> ReduceM a Source #

getVerbosity :: ReduceM Verbosity Source #

isDebugPrinting :: ReduceM Bool Source #

nowDebugPrinting :: ReduceM a -> ReduceM a Source #

PureTCM ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Reduce.Monad
HasConstInfo ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Reduce.Monad Methods getConstInfo :: QName -> ReduceM Definition Source # getConstInfo' :: QName -> ReduceM (Either SigError Definition) Source # getRewriteRulesFor :: QName -> ReduceM RewriteRules Source #
MonadFail ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fail :: String -> ReduceM a Source #
Applicative ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pure :: a -> ReduceM a Source # (<*>) :: ReduceM (a -> b) -> ReduceM a -> ReduceM b Source # liftA2 :: (a -> b -> c) -> ReduceM a -> ReduceM b -> ReduceM c Source # (*>) :: ReduceM a -> ReduceM b -> ReduceM b Source # (<*) :: ReduceM a -> ReduceM b -> ReduceM a Source #
Functor ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> ReduceM a -> ReduceM b Source # (<$) :: a -> ReduceM b -> ReduceM a Source #
Monad ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (>>=) :: ReduceM a -> (a -> ReduceM b) -> ReduceM b Source # (>>) :: ReduceM a -> ReduceM b -> ReduceM b Source # return :: a -> ReduceM a Source #

data ReduceEnv Source #

Environment of the reduce monad.

Constructors

ReduceEnv |

Fields

- redEnv :: TCEnv

  Read only access to environment.

- redSt :: TCState

  Read only access to state (signature, metas...).

data LHSOrPatSyn Source #

Distinguish error message when parsing lhs or pattern synonym, resp.

Constructors

IsLHS |
IsPatSyn |

#### Instances

Instances details

Generic LHSOrPatSyn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep LHSOrPatSyn :: Type -> Type Source # Methods from :: LHSOrPatSyn -> Rep LHSOrPatSyn x Source # to :: Rep LHSOrPatSyn x -> LHSOrPatSyn Source #
Show LHSOrPatSyn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> LHSOrPatSyn -> ShowS Source # show :: LHSOrPatSyn -> String Source # showList :: [LHSOrPatSyn] -> ShowS Source #
NFData LHSOrPatSyn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: LHSOrPatSyn -> () Source #
Eq LHSOrPatSyn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: LHSOrPatSyn -> LHSOrPatSyn -> Bool Source # (/=) :: LHSOrPatSyn -> LHSOrPatSyn -> Bool Source #
type Rep LHSOrPatSyn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep LHSOrPatSyn = D1 ('MetaData "LHSOrPatSyn" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "IsLHS" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "IsPatSyn" 'PrefixI 'False) (U1 :: Type -> Type))

data TypeError Source #

Constructors

InternalError String |
NotImplemented String |
NotSupported String |
CompilationError String |
PropMustBeSingleton |
DataMustEndInSort Term |
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 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 Expr |
ForcedConstructorNotInstantiated Pattern |
IllformedProjectionPattern Pattern |
CannotEliminateWithPattern (Maybe Blocker) (NamedArg 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 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) |
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 |
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 Expr |
NoSuchBuiltinName String |
DuplicateBuiltinBinding String Term Term |
NoBindingForBuiltin String |
NoSuchPrimitiveFunction String |
DuplicatePrimitiveBinding String QName QName |
WrongModalityForPrimitive String ArgInfo ArgInfo |
ShadowedModule Name [ModuleName] |
BuiltinInParameterisedModule String |
IllegalLetInTelescope TypedBinding |
IllegalPatternInTelescope Binder |
NoRHSRequiresAbsurdPattern [NamedArg Pattern] |
TooManyFields QName [Name] [Name] | Record type, fields not supplied by user, non-fields but supplied.
DuplicateFields [Name] |
DuplicateConstructors [Name] |
WithOnFreeVariable Expr Term |
UnexpectedWithPatterns [Pattern] |
WithClausePatternMismatch Pattern (NamedArg DeBruijnPattern) |
FieldOutsideRecord |
ModuleArityMismatch ModuleName Telescope [NamedArg Expr] |
GeneralizeCyclicDependency |
GeneralizeUnsolvedMeta |
SplitError SplitError |
ImpossibleConstructor QName NegativeUnification |
TooManyPolarities QName Int |
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 [TopLevelModuleName] |
FileNotFound TopLevelModuleName [AbsolutePath] |
OverlappingProjects AbsolutePath TopLevelModuleName TopLevelModuleName |
AmbiguousTopLevelModuleName TopLevelModuleName [AbsolutePath] |
ModuleNameUnexpected TopLevelModuleName TopLevelModuleName | Found module name, expected module name.
ModuleNameDoesntMatchFileName TopLevelModuleName [AbsolutePath] |
ClashingFileNamesFor ModuleName [AbsolutePath] |
ModuleDefinedInOtherFile TopLevelModuleName AbsolutePath AbsolutePath | Module name, file from which it was loaded, file which the include path says contains the module. Scope errors
BothWithAndRHS |
AbstractConstructorNotInScope QName |
NotInScope [QName] |
NoSuchModule QName |
AmbiguousName QName (List1 QName) |
AmbiguousModule QName (List1 ModuleName) |
ClashingDefinition QName QName (Maybe NiceDeclaration) |
ClashingModule ModuleName ModuleName |
ClashingImport Name QName |
ClashingModuleImport Name ModuleName |
PatternShadowsConstructor Name QName |
DuplicateImports QName [ImportedName] |
InvalidPattern Pattern |
RepeatedVariablesInPattern [Name] |
GeneralizeNotSupportedHere QName |
MultipleFixityDecls [(Name, [Fixity'])] |
MultiplePolarityPragmas [Name] |
NotAModuleExpr 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 Expr |
NotAValidLetBinding NiceDeclaration |
NotValidBeforeField NiceDeclaration |
NothingAppliedToHiddenArg Expr |
NothingAppliedToInstanceArg Expr |
BadArgumentsToPatternSynonym AmbiguousQName |
TooFewArgumentsToPatternSynonym AmbiguousQName |
CannotResolveAmbiguousPatternSynonym (List1 (QName, PatternSynDefn)) |
UnusedVariableInPatternSynonym |
NoParseForApplication (List2 Expr) |
AmbiguousParseForApplication (List2 Expr) (List1 Expr) |
NoParseForLHS LHSOrPatSyn [Pattern] 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 Pattern [Pattern] | Pattern and its possible interpretations.
OperatorInformation [NotationSection] TypeError |
InstanceNoCandidate Type [(Term, TCErr)] |
UnquoteFailed UnquoteError |
DeBruijnIndexOutOfScope Nat Telescope [Name] |
NeedOptionCopatterns |
NeedOptionRewriting |
NeedOptionProp |
NeedOptionTwoLevel |
NonFatalErrors [TCWarning] |
InstanceSearchDepthExhausted Term Type Int |
TriedToCopyConstrainedPrim QName |

#### Instances

Instances details

PrettyTCM TypeError Source # |
Instance details Defined in Agda.TypeChecking.Errors Methods prettyTCM :: MonadPretty m => TypeError -> m Doc Source #
Generic TypeError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep TypeError :: Type -> Type Source # Methods from :: TypeError -> Rep TypeError x Source # to :: Rep TypeError x -> TypeError Source #
Show TypeError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> TypeError -> ShowS Source # show :: TypeError -> String Source # showList :: [TypeError] -> ShowS Source #
NFData TypeError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TypeError -> () Source #
type Rep TypeError Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep TypeError = D1 ('MetaData "TypeError" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (((((((C1 ('MetaCons "InternalError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "NotImplemented" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) :+: (C1 ('MetaCons "NotSupported" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "CompilationError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))) :+: ((C1 ('MetaCons "PropMustBeSingleton" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DataMustEndInSort" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: (C1 ('MetaCons "ShouldEndInApplicationOfTheDatatype" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "ShouldBeAppliedToTheDatatypeParameters" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))))) :+: (((C1 ('MetaCons "ShouldBeApplicationOf" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "ConstructorPatternInWrongDatatype" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName))) :+: (C1 ('MetaCons "CantResolveOverloadedConstructorsTargetingSameDatatype" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List1 QName))) :+: C1 ('MetaCons "DoesNotConstructAnElementOf" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: ((C1 ('MetaCons "WrongHidingInLHS" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WrongHidingInLambda" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: (C1 ('MetaCons "WrongHidingInApplication" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: (C1 ('MetaCons "WrongNamedArgument" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NamedArg Expr)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [NamedName])) :+: C1 ('MetaCons "WrongIrrelevanceInLambda" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: ((((C1 ('MetaCons "WrongQuantityInLambda" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WrongCohesionInLambda" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "QuantityMismatch" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Quantity) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Quantity)) :+: C1 ('MetaCons "HidingMismatch" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Hiding) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Hiding)))) :+: ((C1 ('MetaCons "RelevanceMismatch" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Relevance) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Relevance)) :+: C1 ('MetaCons "UninstantiatedDotPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr))) :+: (C1 ('MetaCons "ForcedConstructorNotInstantiated" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pattern)) :+: (C1 ('MetaCons "IllformedProjectionPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pattern)) :+: C1 ('MetaCons "CannotEliminateWithPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Blocker)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NamedArg Pattern)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))))) :+: (((C1 ('MetaCons "WrongNumberOfConstructorArguments" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat))) :+: C1 ('MetaCons "ShouldBeEmpty" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DeBruijnPattern]))) :+: (C1 ('MetaCons "ShouldBeASort" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "ShouldBePi" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: ((C1 ('MetaCons "ShouldBePath" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "ShouldBeRecordType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: (C1 ('MetaCons "ShouldBeRecordPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DeBruijnPattern)) :+: (C1 ('MetaCons "NotAProjectionPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NamedArg Pattern))) :+: C1 ('MetaCons "NotAProperTerm" 'PrefixI 'False) (U1 :: Type -> Type))))))) :+: (((((C1 ('MetaCons "InvalidTypeSort" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort)) :+: C1 ('MetaCons "InvalidType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: (C1 ('MetaCons "FunctionTypeInSizeUniv" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :+: C1 ('MetaCons "SplitOnIrrelevant" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Dom Type))))) :+: ((C1 ('MetaCons "SplitOnUnusableCohesion" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Dom Type))) :+: C1 ('MetaCons "SplitOnNonVariable" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: (C1 ('MetaCons "SplitOnNonEtaRecord" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "DefinitionIsIrrelevant" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName))))) :+: (((C1 ('MetaCons "DefinitionIsErased" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "VariableIsIrrelevant" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) :+: (C1 ('MetaCons "VariableIsErased" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "VariableIsOfUnusableCohesion" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Cohesion)))) :+: ((C1 ('MetaCons "UnequalLevel" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Level) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Level))) :+: C1 ('MetaCons "UnequalTerms" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CompareAs)))) :+: (C1 ('MetaCons "UnequalTypes" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: (C1 ('MetaCons "UnequalRelevance" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: C1 ('MetaCons "UnequalQuantity" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)))))))) :+: ((((C1 ('MetaCons "UnequalCohesion" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: C1 ('MetaCons "UnequalHiding" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: (C1 ('MetaCons "UnequalSorts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort)) :+: C1 ('MetaCons "UnequalBecauseOfUniverseConflict" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))))) :+: ((C1 ('MetaCons "NotLeqSort" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort)) :+: C1 ('MetaCons "MetaCannotDependOn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat))) :+: (C1 ('MetaCons "MetaOccursInItself" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId)) :+: (C1 ('MetaCons "MetaIrrelevantSolution" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :+: C1 ('MetaCons "MetaErasedSolution" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)))))) :+: (((C1 ('MetaCons "GenericError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "GenericDocError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc))) :+: (C1 ('MetaCons "SortOfSplitVarError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Blocker)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc)) :+: C1 ('MetaCons "BuiltinMustBeConstructor" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)))) :+: ((C1 ('MetaCons "NoSuchBuiltinName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "DuplicateBuiltinBinding" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)))) :+: (C1 ('MetaCons "NoBindingForBuiltin" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: (C1 ('MetaCons "NoSuchPrimitiveFunction" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "DuplicatePrimitiveBinding" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)))))))))) :+: ((((((C1 ('MetaCons "WrongModalityForPrimitive" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ArgInfo) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ArgInfo))) :+: C1 ('MetaCons "ShadowedModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ModuleName]))) :+: (C1 ('MetaCons "BuiltinInParameterisedModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "IllegalLetInTelescope" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TypedBinding)))) :+: ((C1 ('MetaCons "IllegalPatternInTelescope" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Binder)) :+: C1 ('MetaCons "NoRHSRequiresAbsurdPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [NamedArg Pattern]))) :+: (C1 ('MetaCons "TooManyFields" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]))) :+: C1 ('MetaCons "DuplicateFields" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]))))) :+: (((C1 ('MetaCons "DuplicateConstructors" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :+: C1 ('MetaCons "WithOnFreeVariable" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: (C1 ('MetaCons "UnexpectedWithPatterns" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pattern])) :+: C1 ('MetaCons "WithClausePatternMismatch" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pattern) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NamedArg DeBruijnPattern))))) :+: ((C1 ('MetaCons "FieldOutsideRecord" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ModuleArityMismatch" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [NamedArg Expr])))) :+: (C1 ('MetaCons "GeneralizeCyclicDependency" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "GeneralizeUnsolvedMeta" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SplitError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SplitError))))))) :+: ((((C1 ('MetaCons "ImpossibleConstructor" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NegativeUnification)) :+: C1 ('MetaCons "TooManyPolarities" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))) :+: (C1 ('MetaCons "LocalVsImportedModuleClash" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName)) :+: C1 ('MetaCons "SolvedButOpenHoles" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "CyclicModuleDependency" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TopLevelModuleName])) :+: C1 ('MetaCons "FileNotFound" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TopLevelModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [AbsolutePath]))) :+: (C1 ('MetaCons "OverlappingProjects" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AbsolutePath) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TopLevelModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TopLevelModuleName))) :+: (C1 ('MetaCons "AmbiguousTopLevelModuleName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TopLevelModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [AbsolutePath])) :+: C1 ('MetaCons "ModuleNameUnexpected" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TopLevelModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TopLevelModuleName)))))) :+: (((C1 ('MetaCons "ModuleNameDoesntMatchFileName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TopLevelModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [AbsolutePath])) :+: C1 ('MetaCons "ClashingFileNamesFor" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [AbsolutePath]))) :+: (C1 ('MetaCons "ModuleDefinedInOtherFile" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TopLevelModuleName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AbsolutePath) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AbsolutePath))) :+: C1 ('MetaCons "BothWithAndRHS" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "AbstractConstructorNotInScope" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "NotInScope" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QName]))) :+: (C1 ('MetaCons "NoSuchModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: (C1 ('MetaCons "AmbiguousName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List1 QName))) :+: C1 ('MetaCons "AmbiguousModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List1 ModuleName))))))))) :+: (((((C1 ('MetaCons "ClashingDefinition" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe NiceDeclaration)))) :+: C1 ('MetaCons "ClashingModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName))) :+: (C1 ('MetaCons "ClashingImport" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "ClashingModuleImport" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName)))) :+: ((C1 ('MetaCons "PatternShadowsConstructor" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: C1 ('MetaCons "DuplicateImports" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ImportedName]))) :+: (C1 ('MetaCons "InvalidPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pattern)) :+: (C1 ('MetaCons "RepeatedVariablesInPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])) :+: C1 ('MetaCons "GeneralizeNotSupportedHere" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)))))) :+: (((C1 ('MetaCons "MultipleFixityDecls" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Name, [Fixity'])])) :+: C1 ('MetaCons "MultiplePolarityPragmas" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]))) :+: (C1 ('MetaCons "NotAModuleExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)) :+: C1 ('MetaCons "NotAnExpression" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)))) :+: ((C1 ('MetaCons "NotAValidLetBinding" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NiceDeclaration)) :+: C1 ('MetaCons "NotValidBeforeField" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NiceDeclaration))) :+: (C1 ('MetaCons "NothingAppliedToHiddenArg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)) :+: (C1 ('MetaCons "NothingAppliedToInstanceArg" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)) :+: C1 ('MetaCons "BadArgumentsToPatternSynonym" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AmbiguousQName))))))) :+: ((((C1 ('MetaCons "TooFewArgumentsToPatternSynonym" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AmbiguousQName)) :+: C1 ('MetaCons "CannotResolveAmbiguousPatternSynonym" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List1 (QName, PatternSynDefn))))) :+: (C1 ('MetaCons "UnusedVariableInPatternSynonym" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NoParseForApplication" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List2 Expr))))) :+: ((C1 ('MetaCons "AmbiguousParseForApplication" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List2 Expr)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List1 Expr))) :+: C1 ('MetaCons "NoParseForLHS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 LHSOrPatSyn) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pattern]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pattern)))) :+: (C1 ('MetaCons "AmbiguousParseForLHS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 LHSOrPatSyn) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pattern) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pattern]))) :+: (C1 ('MetaCons "OperatorInformation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [NotationSection]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TypeError)) :+: C1 ('MetaCons "InstanceNoCandidate" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Term, TCErr)])))))) :+: (((C1 ('MetaCons "UnquoteFailed" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 UnquoteError)) :+: C1 ('MetaCons "DeBruijnIndexOutOfScope" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name])))) :+: (C1 ('MetaCons "NeedOptionCopatterns" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NeedOptionRewriting" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "NeedOptionProp" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NeedOptionTwoLevel" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "NonFatalErrors" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TCWarning])) :+: (C1 ('MetaCons "InstanceSearchDepthExhausted" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))) :+: C1 ('MetaCons "TriedToCopyConstrainedPrim" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName))))))))))

data UnquoteError Source #

Constructors

BadVisibility String (Arg Term) |
ConInsteadOfDef QName String String |
DefInsteadOfCon QName String String |
NonCanonical String Term |
BlockedOnMeta TCState Blocker |
UnquotePanic String |

#### Instances

Instances details

Generic UnquoteError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep UnquoteError :: Type -> Type Source # Methods from :: UnquoteError -> Rep UnquoteError x Source # to :: Rep UnquoteError x -> UnquoteError Source #
Show UnquoteError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> UnquoteError -> ShowS Source # show :: UnquoteError -> String Source # showList :: [UnquoteError] -> ShowS Source #
NFData UnquoteError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: UnquoteError -> () Source #
type Rep UnquoteError Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep UnquoteError = D1 ('MetaData "UnquoteError" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "BadVisibility" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg Term))) :+: (C1 ('MetaCons "ConInsteadOfDef" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) :+: C1 ('MetaCons "DefInsteadOfCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))))) :+: (C1 ('MetaCons "NonCanonical" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :+: (C1 ('MetaCons "BlockedOnMeta" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TCState) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Blocker)) :+: C1 ('MetaCons "UnquotePanic" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))))

data UnificationFailure Source #

Constructors

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"

#### Instances

Instances details

PrettyTCM UnificationFailure Source # |
Instance details Defined in Agda.TypeChecking.Errors Methods prettyTCM :: MonadPretty m => UnificationFailure -> m Doc Source #
Generic UnificationFailure Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep UnificationFailure :: Type -> Type Source # Methods from :: UnificationFailure -> Rep UnificationFailure x Source # to :: Rep UnificationFailure x -> UnificationFailure Source #
Show UnificationFailure Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> UnificationFailure -> ShowS Source # show :: UnificationFailure -> String Source # showList :: [UnificationFailure] -> ShowS Source #
NFData UnificationFailure Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: UnificationFailure -> () Source #
type Rep UnificationFailure Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep UnificationFailure = D1 ('MetaData "UnificationFailure" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "UnifyIndicesNotVars" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Args)))) :+: C1 ('MetaCons "UnifyRecursiveEq" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)))) :+: (C1 ('MetaCons "UnifyReflexiveEq" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: C1 ('MetaCons "UnifyUnusableModality" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Modality))))))

data NegativeUnification Source #

Constructors

UnifyConflict Telescope Term Term |
UnifyCycle Telescope Int Term |

#### Instances

Instances details

PrettyTCM NegativeUnification Source # |
Instance details Defined in Agda.TypeChecking.Errors Methods prettyTCM :: MonadPretty m => NegativeUnification -> m Doc Source #
Generic NegativeUnification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep NegativeUnification :: Type -> Type Source # Methods from :: NegativeUnification -> Rep NegativeUnification x Source # to :: Rep NegativeUnification x -> NegativeUnification Source #
Show NegativeUnification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> NegativeUnification -> ShowS Source # show :: NegativeUnification -> String Source # showList :: [NegativeUnification] -> ShowS Source #
NFData NegativeUnification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: NegativeUnification -> () Source #
type Rep NegativeUnification Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep NegativeUnification = D1 ('MetaData "NegativeUnification" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "UnifyConflict" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: C1 ('MetaCons "UnifyCycle" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))))

data SplitError Source #

Error when splitting a pattern variable into possible constructor patterns.

Constructors

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 |

Fields

- cantSplitBlocker :: Maybe Blocker

  Blocking metavariable (if any)

- cantSplitConName :: QName

  Constructor.

- cantSplitTel :: Telescope

  Context for indices.

- cantSplitConIdx :: Args

  Inferred indices (from type of constructor).

- cantSplitGivenIdx :: Args

  Expected indices (from checking pattern).

- 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 |

#### Instances

Instances details

PrettyTCM SplitError Source # |
Instance details Defined in Agda.TypeChecking.Errors Methods prettyTCM :: MonadPretty m => SplitError -> m Doc Source #
Generic SplitError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep SplitError :: Type -> Type Source # Methods from :: SplitError -> Rep SplitError x Source # to :: Rep SplitError x -> SplitError Source #
Show SplitError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> SplitError -> ShowS Source # show :: SplitError -> String Source # showList :: [SplitError] -> ShowS Source #
NFData SplitError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: SplitError -> () Source #
type Rep SplitError Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep SplitError = D1 ('MetaData "SplitError" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (((C1 ('MetaCons "NotADatatype" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure Type))) :+: C1 ('MetaCons "BlockedType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Blocker) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure Type)))) :+: (C1 ('MetaCons "ErasedDatatype" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure Type))) :+: (C1 ('MetaCons "CoinductiveDatatype" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure Type))) :+: C1 ('MetaCons "UnificationStuck" 'PrefixI 'True) ((S1 ('MetaSel ('Just "cantSplitBlocker") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Blocker)) :*: (S1 ('MetaSel ('Just "cantSplitConName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Just "cantSplitTel") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope))) :*: (S1 ('MetaSel ('Just "cantSplitConIdx") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Args) :*: (S1 ('MetaSel ('Just "cantSplitGivenIdx") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Args) :*: S1 ('MetaSel ('Just "cantSplitFailures") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [UnificationFailure]))))))) :+: ((C1 ('MetaCons "CosplitCatchall" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CosplitNoTarget" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CosplitNoRecordType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure Type))) :+: (C1 ('MetaCons "CannotCreateMissingClause" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Telescope, [NamedArg DeBruijnPattern]))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Doc) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure (Abs Type))))) :+: C1 ('MetaCons "GenericSplitError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))))))

data TerminationError Source #

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

Constructors

TerminationError |

Fields

- termErrFunctions :: [QName]

  The functions which failed to check. (May not include automatically generated functions.)

- termErrCalls :: [CallInfo]

  The problematic call sites.

#### Instances

Instances details

Generic TerminationError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep TerminationError :: Type -> Type Source # Methods from :: TerminationError -> Rep TerminationError x Source # to :: Rep TerminationError x -> TerminationError Source #
Show TerminationError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> TerminationError -> ShowS Source # show :: TerminationError -> String Source # showList :: [TerminationError] -> ShowS Source #
NFData TerminationError Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TerminationError -> () Source #
type Rep TerminationError Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep TerminationError = D1 ('MetaData "TerminationError" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "TerminationError" 'PrefixI 'True) (S1 ('MetaSel ('Just "termErrFunctions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QName]) :*: S1 ('MetaSel ('Just "termErrCalls") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [CallInfo])))

data CallInfo Source #

Information about a call.

Constructors

CallInfo |

Fields

- callInfoTarget :: QName

  Target function name.

- callInfoRange :: Range

  Range of the target function.

- callInfoCall :: Closure Term

  To be formatted representation of the call.

#### Instances

Instances details

PrettyTCM CallInfo Source # |
Instance details Defined in Agda.TypeChecking.Pretty.Call Methods prettyTCM :: MonadPretty m => CallInfo -> m Doc Source #
Pretty CallInfo Source # | We only `show` the name of the callee.
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: CallInfo -> Doc Source # prettyPrec :: Int -> CallInfo -> Doc Source # prettyList :: [CallInfo] -> Doc Source #
Generic CallInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep CallInfo :: Type -> Type Source # Methods from :: CallInfo -> Rep CallInfo x Source # to :: Rep CallInfo x -> CallInfo Source #
Show CallInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> CallInfo -> ShowS Source # show :: CallInfo -> String Source # showList :: [CallInfo] -> ShowS Source #
NFData CallInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: CallInfo -> () Source #
type Rep CallInfo Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep CallInfo = D1 ('MetaData "CallInfo" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "CallInfo" 'PrefixI 'True) (S1 ('MetaSel ('Just "callInfoTarget") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Just "callInfoRange") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Just "callInfoCall") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure Term)))))

data RecordFieldWarning Source #

Constructors

DuplicateFieldsWarning [(Name, Range)] | Each redundant field comes with a range of associated dead code.
TooManyFieldsWarning QName [Name] [(Name, Range)] | Record type, fields not supplied by user, non-fields but supplied. The redundant fields come with a range of associated dead code.

#### Instances

Instances details

EmbPrj RecordFieldWarning Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Errors Methods icode :: RecordFieldWarning -> S Int32 Source # icod_ :: RecordFieldWarning -> S Int32 Source # value :: Int32 -> R RecordFieldWarning Source #
Data RecordFieldWarning Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RecordFieldWarning -> c RecordFieldWarning Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RecordFieldWarning Source #

toConstr :: RecordFieldWarning -> Constr Source #

dataTypeOf :: RecordFieldWarning -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RecordFieldWarning) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecordFieldWarning) Source #

gmapT :: (forall b. Data b => b -> b) -> RecordFieldWarning -> RecordFieldWarning Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RecordFieldWarning -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> RecordFieldWarning -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RecordFieldWarning -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RecordFieldWarning -> m RecordFieldWarning Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordFieldWarning -> m RecordFieldWarning Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordFieldWarning -> m RecordFieldWarning Source #

Generic RecordFieldWarning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep RecordFieldWarning :: Type -> Type Source # Methods from :: RecordFieldWarning -> Rep RecordFieldWarning x Source # to :: Rep RecordFieldWarning x -> RecordFieldWarning Source #
Show RecordFieldWarning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> RecordFieldWarning -> ShowS Source # show :: RecordFieldWarning -> String Source # showList :: [RecordFieldWarning] -> ShowS Source #
NFData RecordFieldWarning Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: RecordFieldWarning -> () Source #
type Rep RecordFieldWarning Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep RecordFieldWarning = D1 ('MetaData "RecordFieldWarning" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "DuplicateFieldsWarning" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Name, Range)])) :+: C1 ('MetaCons "TooManyFieldsWarning" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Name, Range)]))))

data ArgsCheckState a Source #

Constructors

ACState |

Fields

- acRanges :: [Maybe Range]

  Ranges of checked arguments, where present. e.g. inserted implicits have no correponding abstract syntax.

- acElims :: Elims

  Checked and inserted arguments so far.

- acConstraints :: [Maybe (Abs Constraint)]

  Constraints for the head so far, i.e. before applying the correponding elim.

- acType :: Type

  Type for the rest of the application.

- acData :: a

#### Instances

Instances details

Show a => Show (ArgsCheckState a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> ArgsCheckState a -> ShowS Source # show :: ArgsCheckState a -> String Source # showList :: [ArgsCheckState a] -> ShowS Source #

data Candidate Source #

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.

Constructors

Candidate |

Fields

- candidateKind :: CandidateKind
- candidateTerm :: Term
- candidateType :: Type
- candidateOverlappable :: Bool

#### Instances

Instances details

Free Candidate Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freeVars' :: IsVarSet a c => Candidate -> FreeM a c Source #
PrettyTCM Candidate Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => Candidate -> m Doc Source #
Instantiate Candidate Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiate' :: Candidate -> ReduceM Candidate Source #
InstantiateFull Candidate Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Candidate -> ReduceM Candidate Source #
Normalise Candidate Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods normalise' :: Candidate -> ReduceM Candidate Source #
Reduce Candidate Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods reduce' :: Candidate -> ReduceM Candidate Source # reduceB' :: Candidate -> ReduceM (Blocked Candidate) Source #
Simplify Candidate Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods simplify' :: Candidate -> ReduceM Candidate Source #
Subst Candidate Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg Candidate Source # Methods applySubst :: Substitution' (SubstArg Candidate) -> Candidate -> Candidate Source #
Data Candidate Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Candidate -> c Candidate Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Candidate Source #

toConstr :: Candidate -> Constr Source #

dataTypeOf :: Candidate -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Candidate) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Candidate) Source #

gmapT :: (forall b. Data b => b -> b) -> Candidate -> Candidate Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Candidate -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Candidate -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Candidate -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Candidate -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Candidate -> m Candidate Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Candidate -> m Candidate Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Candidate -> m Candidate Source #

Generic Candidate Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Candidate :: Type -> Type Source # Methods from :: Candidate -> Rep Candidate x Source # to :: Rep Candidate x -> Candidate Source #
Show Candidate Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Candidate -> ShowS Source # show :: Candidate -> String Source # showList :: [Candidate] -> ShowS Source #
NFData Candidate Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Candidate -> () Source #
Eq Candidate Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods (==) :: Candidate -> Candidate -> Bool Source # (/=) :: Candidate -> Candidate -> Bool Source #
type SubstArg Candidate Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg Candidate = Term
type Rep Candidate Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Candidate = D1 ('MetaData "Candidate" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Candidate" 'PrefixI 'True) ((S1 ('MetaSel ('Just "candidateKind") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CandidateKind) :*: S1 ('MetaSel ('Just "candidateTerm") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :*: (S1 ('MetaSel ('Just "candidateType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Just "candidateOverlappable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool))))

data CandidateKind Source #

Constructors

LocalCandidate |
GlobalCandidate QName |

#### Instances

Instances details

Data CandidateKind Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CandidateKind -> c CandidateKind Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CandidateKind Source #

toConstr :: CandidateKind -> Constr Source #

dataTypeOf :: CandidateKind -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CandidateKind) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CandidateKind) Source #

gmapT :: (forall b. Data b => b -> b) -> CandidateKind -> CandidateKind Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CandidateKind -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CandidateKind -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CandidateKind -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CandidateKind -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CandidateKind -> m CandidateKind Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CandidateKind -> m CandidateKind Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CandidateKind -> m CandidateKind Source #

Generic CandidateKind Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep CandidateKind :: Type -> Type Source # Methods from :: CandidateKind -> Rep CandidateKind x Source # to :: Rep CandidateKind x -> CandidateKind Source #
Show CandidateKind Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> CandidateKind -> ShowS Source # show :: CandidateKind -> String Source # showList :: [CandidateKind] -> ShowS Source #
NFData CandidateKind Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: CandidateKind -> () Source #
Eq CandidateKind Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods (==) :: CandidateKind -> CandidateKind -> Bool Source # (/=) :: CandidateKind -> CandidateKind -> Bool Source #
type Rep CandidateKind Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep CandidateKind = D1 ('MetaData "CandidateKind" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "LocalCandidate" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GlobalCandidate" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)))

data ExpandHidden Source #

Constructors

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.

#### Instances

Instances details

Data ExpandHidden Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExpandHidden -> c ExpandHidden Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ExpandHidden Source #

toConstr :: ExpandHidden -> Constr Source #

dataTypeOf :: ExpandHidden -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ExpandHidden) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExpandHidden) Source #

gmapT :: (forall b. Data b => b -> b) -> ExpandHidden -> ExpandHidden Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExpandHidden -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ExpandHidden -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExpandHidden -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExpandHidden -> m ExpandHidden Source #

Generic ExpandHidden Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep ExpandHidden :: Type -> Type Source # Methods from :: ExpandHidden -> Rep ExpandHidden x Source # to :: Rep ExpandHidden x -> ExpandHidden Source #
NFData ExpandHidden Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: ExpandHidden -> () Source #
Eq ExpandHidden Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: ExpandHidden -> ExpandHidden -> Bool Source # (/=) :: ExpandHidden -> ExpandHidden -> Bool Source #
type Rep ExpandHidden Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep ExpandHidden = D1 ('MetaData "ExpandHidden" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "ExpandLast" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DontExpandLast" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ReallyDontExpandLast" 'PrefixI 'False) (U1 :: Type -> Type)))

data AbstractMode Source #

Constructors

AbstractMode | Abstract things in the current module can be accessed.
ConcreteMode | No abstract things can be accessed.
IgnoreAbstractMode | All abstract things can be accessed.

#### Instances

Instances details

Data AbstractMode Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AbstractMode -> c AbstractMode Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AbstractMode Source #

toConstr :: AbstractMode -> Constr Source #

dataTypeOf :: AbstractMode -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AbstractMode) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AbstractMode) Source #

gmapT :: (forall b. Data b => b -> b) -> AbstractMode -> AbstractMode Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AbstractMode -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> AbstractMode -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AbstractMode -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AbstractMode -> m AbstractMode Source #

Generic AbstractMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep AbstractMode :: Type -> Type Source # Methods from :: AbstractMode -> Rep AbstractMode x Source # to :: Rep AbstractMode x -> AbstractMode Source #
Show AbstractMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> AbstractMode -> ShowS Source # show :: AbstractMode -> String Source # showList :: [AbstractMode] -> ShowS Source #
NFData AbstractMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: AbstractMode -> () Source #
Eq AbstractMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: AbstractMode -> AbstractMode -> Bool Source # (/=) :: AbstractMode -> AbstractMode -> Bool Source #
type Rep AbstractMode Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep AbstractMode = D1 ('MetaData "AbstractMode" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "AbstractMode" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ConcreteMode" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "IgnoreAbstractMode" 'PrefixI 'False) (U1 :: Type -> Type)))

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

type ContextEntry = Dom (Name, Type) Source #

type Context = [ContextEntry] Source #

The `Context` is a stack of `ContextEntry`s.

data UnquoteFlags Source #

Constructors

UnquoteFlags |

Fields

- _unquoteNormalise :: Bool

#### Instances

Instances details

Data UnquoteFlags Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnquoteFlags -> c UnquoteFlags Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnquoteFlags Source #

toConstr :: UnquoteFlags -> Constr Source #

dataTypeOf :: UnquoteFlags -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnquoteFlags) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnquoteFlags) Source #

gmapT :: (forall b. Data b => b -> b) -> UnquoteFlags -> UnquoteFlags Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnquoteFlags -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnquoteFlags -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> UnquoteFlags -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnquoteFlags -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnquoteFlags -> m UnquoteFlags Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnquoteFlags -> m UnquoteFlags Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnquoteFlags -> m UnquoteFlags Source #

Generic UnquoteFlags Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep UnquoteFlags :: Type -> Type Source # Methods from :: UnquoteFlags -> Rep UnquoteFlags x Source # to :: Rep UnquoteFlags x -> UnquoteFlags Source #
NFData UnquoteFlags Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: UnquoteFlags -> () Source #
type Rep UnquoteFlags Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep UnquoteFlags = D1 ('MetaData "UnquoteFlags" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "UnquoteFlags" 'PrefixI 'True) (S1 ('MetaSel ('Just "_unquoteNormalise") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))

class LensTCEnv a where Source #

Methods

lensTCEnv :: Lens' TCEnv a Source #

#### Instances

Instances details

LensTCEnv TCEnv Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensTCEnv :: Lens' TCEnv TCEnv Source #
LensTCEnv (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensTCEnv :: Lens' TCEnv (Closure a) Source #

data Builtin pf Source #

Constructors

Builtin Term |
Prim pf |

#### Instances

Instances details

Foldable Builtin Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

fold :: Monoid m => Builtin m -> m Source #

foldMap :: Monoid m => (a -> m) -> Builtin a -> m Source #

foldMap' :: Monoid m => (a -> m) -> Builtin a -> m Source #

foldr :: (a -> b -> b) -> b -> Builtin a -> b Source #

foldr' :: (a -> b -> b) -> b -> Builtin a -> b Source #

foldl :: (b -> a -> b) -> b -> Builtin a -> b Source #

foldl' :: (b -> a -> b) -> b -> Builtin a -> b Source #

foldr1 :: (a -> a -> a) -> Builtin a -> a Source #

foldl1 :: (a -> a -> a) -> Builtin a -> a Source #

toList :: Builtin a -> [a] Source #

null :: Builtin a -> Bool Source #

length :: Builtin a -> Int Source #

elem :: Eq a => a -> Builtin a -> Bool Source #

maximum :: Ord a => Builtin a -> a Source #

minimum :: Ord a => Builtin a -> a Source #

sum :: Num a => Builtin a -> a Source #

product :: Num a => Builtin a -> a Source #

Traversable Builtin Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods traverse :: Applicative f => (a -> f b) -> Builtin a -> f (Builtin b) Source # sequenceA :: Applicative f => Builtin (f a) -> f (Builtin a) Source # mapM :: Monad m => (a -> m b) -> Builtin a -> m (Builtin b) Source # sequence :: Monad m => Builtin (m a) -> m (Builtin a) Source #
Functor Builtin Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> Builtin a -> Builtin b Source # (<$) :: a -> Builtin b -> Builtin a Source #
InstantiateFull a => InstantiateFull (Builtin a) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Builtin a -> ReduceM (Builtin a) Source #
EmbPrj a => EmbPrj (Builtin a) Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: Builtin a -> S Int32 Source # icod_ :: Builtin a -> S Int32 Source # value :: Int32 -> R (Builtin a) Source #
Generic (Builtin pf) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep (Builtin pf) :: Type -> Type Source # Methods from :: Builtin pf -> Rep (Builtin pf) x Source # to :: Rep (Builtin pf) x -> Builtin pf Source #
Show pf => Show (Builtin pf) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Builtin pf -> ShowS Source # show :: Builtin pf -> String Source # showList :: [Builtin pf] -> ShowS Source #
NFData pf => NFData (Builtin pf) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Builtin pf -> () Source #
type Rep (Builtin pf) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep (Builtin pf) = D1 ('MetaData "Builtin" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Builtin" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :+: C1 ('MetaCons "Prim" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 pf)))

type BuiltinThings pf = Map String (Builtin pf) Source #

data BuiltinInfo Source #

Constructors

BuiltinInfo |

Fields

- builtinName :: String
- builtinDesc :: BuiltinDescriptor

data BuiltinDescriptor Source #

Constructors

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.

type TempInstanceTable = (InstanceTable, Set QName) Source #

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 InstanceTable = Map QName (Set QName) Source #

The instance table is a `Map` associating to every name of recorddata typepostulate its list of instances

data Call Source #

Constructors

CheckClause Type SpineClause |
CheckLHS SpineLHS |
CheckPattern Pattern Telescope Type |
CheckPatternLinearityType Name |
CheckPatternLinearityValue Name |
CheckLetBinding LetBinding |
InferExpr Expr |
CheckExprCall Comparison Expr Type |
CheckDotPattern Expr Term |
CheckProjection Range QName Type |
IsTypeCall Comparison Expr Sort |
IsType_ Expr |
InferVar Name |
InferDef QName |
CheckArguments Range [NamedArg Expr] Type (Maybe Type) |
CheckMetaSolution Range MetaId Type Term |
CheckTargetType Range Type Type |
CheckDataDef Range QName [LamBinding] [Constructor] |
CheckRecDef Range QName [LamBinding] [Constructor] |
CheckConstructor QName Telescope Sort Constructor |
CheckConstructorFitsIn QName Type Sort |
CheckFunDefCall Range QName [Clause] Bool | Highlight (interactively) if and only if the boolean is `True`.
CheckPragma Range Pragma |
CheckPrimitive Range QName Expr |
CheckIsEmpty Range Type |
CheckConfluence QName QName |
CheckWithFunctionType Type |
CheckSectionApplication Range ModuleName ModuleApplication |
CheckNamedWhere ModuleName |
ScopeCheckExpr Expr |
ScopeCheckDeclaration NiceDeclaration |
ScopeCheckLHS QName Pattern |
NoHighlighting |
ModuleContents | Interaction command: show module contents.
SetRange Range | used by `setCurrentRange`

#### Instances

Instances details

HasRange Call Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: Call -> Range Source #
PrettyTCM Call Source # |
Instance details Defined in Agda.TypeChecking.Pretty.Call Methods prettyTCM :: MonadPretty m => Call -> m Doc Source #
Pretty Call Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Call -> Doc Source # prettyPrec :: Int -> Call -> Doc Source # prettyList :: [Call] -> Doc Source #
Data Call Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Call -> c Call Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Call Source #

toConstr :: Call -> Constr Source #

dataTypeOf :: Call -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Call) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Call) Source #

gmapT :: (forall b. Data b => b -> b) -> Call -> Call Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Call -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Call -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Call -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Call -> m Call Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Call -> m Call Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Call -> m Call Source #

Generic Call Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Call :: Type -> Type Source # Methods from :: Call -> Rep Call x Source # to :: Rep Call x -> Call Source #
NFData Call Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Call -> () Source #
type Rep Call Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Call = D1 ('MetaData "Call" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (((((C1 ('MetaCons "CheckClause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SpineClause)) :+: C1 ('MetaCons "CheckLHS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SpineLHS))) :+: (C1 ('MetaCons "CheckPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pattern) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "CheckPatternLinearityType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)))) :+: ((C1 ('MetaCons "CheckPatternLinearityValue" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "CheckLetBinding" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 LetBinding))) :+: (C1 ('MetaCons "InferExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)) :+: C1 ('MetaCons "CheckExprCall" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))))) :+: (((C1 ('MetaCons "CheckDotPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :+: C1 ('MetaCons "CheckProjection" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) :+: (C1 ('MetaCons "IsTypeCall" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort))) :+: C1 ('MetaCons "IsType_" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)))) :+: ((C1 ('MetaCons "InferVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "InferDef" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName))) :+: (C1 ('MetaCons "CheckArguments" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [NamedArg Expr])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Type)))) :+: (C1 ('MetaCons "CheckMetaSolution" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: C1 ('MetaCons "CheckTargetType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))))))) :+: ((((C1 ('MetaCons "CheckDataDef" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [LamBinding]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Constructor]))) :+: C1 ('MetaCons "CheckRecDef" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [LamBinding]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Constructor])))) :+: (C1 ('MetaCons "CheckConstructor" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Constructor))) :+: C1 ('MetaCons "CheckConstructorFitsIn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort))))) :+: ((C1 ('MetaCons "CheckFunDefCall" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool))) :+: C1 ('MetaCons "CheckPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pragma))) :+: (C1 ('MetaCons "CheckPrimitive" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr))) :+: (C1 ('MetaCons "CheckIsEmpty" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "CheckConfluence" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)))))) :+: (((C1 ('MetaCons "CheckWithFunctionType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "CheckSectionApplication" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleApplication)))) :+: (C1 ('MetaCons "CheckNamedWhere" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName)) :+: C1 ('MetaCons "ScopeCheckExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)))) :+: ((C1 ('MetaCons "ScopeCheckDeclaration" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NiceDeclaration)) :+: C1 ('MetaCons "ScopeCheckLHS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pattern))) :+: (C1 ('MetaCons "NoHighlighting" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ModuleContents" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SetRange" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range))))))))

type Statistics = Map String Integer Source #

newtype MutualId Source #

Constructors

MutId Int32 |

#### Instances

Instances details

KillRange MutualId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT MutualId Source #
HasFresh MutualId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' MutualId TCState Source # nextFresh' :: MutualId -> MutualId Source #
EmbPrj MutualId Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: MutualId -> S Int32 Source # icod_ :: MutualId -> S Int32 Source # value :: Int32 -> R MutualId Source #
Data MutualId Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MutualId -> c MutualId Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MutualId Source #

toConstr :: MutualId -> Constr Source #

dataTypeOf :: MutualId -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MutualId) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualId) Source #

gmapT :: (forall b. Data b => b -> b) -> MutualId -> MutualId Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MutualId -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MutualId -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> MutualId -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MutualId -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MutualId -> m MutualId Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MutualId -> m MutualId Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MutualId -> m MutualId Source #

Enum MutualId Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: MutualId -> MutualId Source #

pred :: MutualId -> MutualId Source #

toEnum :: Int -> MutualId Source #

fromEnum :: MutualId -> Int Source #

enumFrom :: MutualId -> [MutualId] Source #

enumFromThen :: MutualId -> MutualId -> [MutualId] Source #

enumFromTo :: MutualId -> MutualId -> [MutualId] Source #

enumFromThenTo :: MutualId -> MutualId -> MutualId -> [MutualId] Source #

Num MutualId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (+) :: MutualId -> MutualId -> MutualId Source # (-) :: MutualId -> MutualId -> MutualId Source # (*) :: MutualId -> MutualId -> MutualId Source # negate :: MutualId -> MutualId Source # abs :: MutualId -> MutualId Source # signum :: MutualId -> MutualId Source # fromInteger :: Integer -> MutualId Source #
Show MutualId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> MutualId -> ShowS Source # show :: MutualId -> String Source # showList :: [MutualId] -> ShowS Source #
NFData MutualId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: MutualId -> () Source #
Eq MutualId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: MutualId -> MutualId -> Bool Source # (/=) :: MutualId -> MutualId -> Bool Source #
Ord MutualId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods compare :: MutualId -> MutualId -> Ordering Source # (<) :: MutualId -> MutualId -> Bool Source # (<=) :: MutualId -> MutualId -> Bool Source # (>) :: MutualId -> MutualId -> Bool Source # (>=) :: MutualId -> MutualId -> Bool Source # max :: MutualId -> MutualId -> MutualId Source # min :: MutualId -> MutualId -> MutualId Source #

data TermHead Source #

Constructors

SortHead |
PiHead |
ConsHead QName |
VarHead Nat |
UnknownHead |

#### Instances

Instances details

KillRange TermHead Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT TermHead Source #
EmbPrj TermHead Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: TermHead -> S Int32 Source # icod_ :: TermHead -> S Int32 Source # value :: Int32 -> R TermHead Source #
Pretty TermHead Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: TermHead -> Doc Source # prettyPrec :: Int -> TermHead -> Doc Source # prettyList :: [TermHead] -> Doc Source #
Data TermHead Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TermHead -> c TermHead Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TermHead Source #

toConstr :: TermHead -> Constr Source #

dataTypeOf :: TermHead -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TermHead) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TermHead) Source #

gmapT :: (forall b. Data b => b -> b) -> TermHead -> TermHead Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TermHead -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TermHead -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> TermHead -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TermHead -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TermHead -> m TermHead Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TermHead -> m TermHead Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TermHead -> m TermHead Source #

Generic TermHead Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep TermHead :: Type -> Type Source # Methods from :: TermHead -> Rep TermHead x Source # to :: Rep TermHead x -> TermHead Source #
Show TermHead Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> TermHead -> ShowS Source # show :: TermHead -> String Source # showList :: [TermHead] -> ShowS Source #
NFData TermHead Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TermHead -> () Source #
Eq TermHead Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: TermHead -> TermHead -> Bool Source # (/=) :: TermHead -> TermHead -> Bool Source #
Ord TermHead Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods compare :: TermHead -> TermHead -> Ordering Source # (<) :: TermHead -> TermHead -> Bool Source # (<=) :: TermHead -> TermHead -> Bool Source # (>) :: TermHead -> TermHead -> Bool Source # (>=) :: TermHead -> TermHead -> Bool Source # max :: TermHead -> TermHead -> TermHead Source # min :: TermHead -> TermHead -> TermHead Source #
type Rep TermHead Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep TermHead = D1 ('MetaData "TermHead" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "SortHead" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PiHead" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ConsHead" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :+: (C1 ('MetaCons "VarHead" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat)) :+: C1 ('MetaCons "UnknownHead" 'PrefixI 'False) (U1 :: Type -> Type))))

data FunctionInverse' c Source #

Constructors

NotInjective |
Inverse (InversionMap c) |

#### Instances

Instances details

DropArgs FunctionInverse Source # |
Instance details Defined in Agda.TypeChecking.DropArgs Methods dropArgs :: Int -> FunctionInverse -> FunctionInverse Source #
InstantiateFull FunctionInverse Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: FunctionInverse -> ReduceM FunctionInverse Source #
Abstract FunctionInverse Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> FunctionInverse -> FunctionInverse Source #
Apply FunctionInverse Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: FunctionInverse -> Args -> FunctionInverse Source # applyE :: FunctionInverse -> Elims -> FunctionInverse Source #
Functor FunctionInverse' Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> FunctionInverse' a -> FunctionInverse' b Source # (<$) :: a -> FunctionInverse' b -> FunctionInverse' a Source #
KillRange c => KillRange (FunctionInverse' c) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT (FunctionInverse' c) Source #
EmbPrj a => EmbPrj (FunctionInverse' a) Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: FunctionInverse' a -> S Int32 Source # icod_ :: FunctionInverse' a -> S Int32 Source # value :: Int32 -> R (FunctionInverse' a) Source #
Pretty c => Pretty (FunctionInverse' c) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: FunctionInverse' c -> Doc Source # prettyPrec :: Int -> FunctionInverse' c -> Doc Source # prettyList :: [FunctionInverse' c] -> Doc Source #
Data c => Data (FunctionInverse' c) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> FunctionInverse' c -> c0 (FunctionInverse' c) Source #

gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (FunctionInverse' c) Source #

toConstr :: FunctionInverse' c -> Constr Source #

dataTypeOf :: FunctionInverse' c -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (FunctionInverse' c)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (FunctionInverse' c)) Source #

gmapT :: (forall b. Data b => b -> b) -> FunctionInverse' c -> FunctionInverse' c Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionInverse' c -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionInverse' c -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> FunctionInverse' c -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionInverse' c -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionInverse' c -> m (FunctionInverse' c) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionInverse' c -> m (FunctionInverse' c) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionInverse' c -> m (FunctionInverse' c) Source #

Generic (FunctionInverse' c) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep (FunctionInverse' c) :: Type -> Type Source # Methods from :: FunctionInverse' c -> Rep (FunctionInverse' c) x Source # to :: Rep (FunctionInverse' c) x -> FunctionInverse' c Source #
Show c => Show (FunctionInverse' c) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> FunctionInverse' c -> ShowS Source # show :: FunctionInverse' c -> String Source # showList :: [FunctionInverse' c] -> ShowS Source #
NFData c => NFData (FunctionInverse' c) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: FunctionInverse' c -> () Source #
type Rep (FunctionInverse' c) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep (FunctionInverse' c) = D1 ('MetaData "FunctionInverse'" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "NotInjective" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Inverse" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (InversionMap c))))

type InversionMap c = Map TermHead [c] Source #

type FunctionInverse = FunctionInverse' Clause Source #

data PrimFun Source #

Constructors

PrimFun |

Fields

- primFunName :: QName
- primFunArity :: Arity
- primFunImplementation :: [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term)

#### Instances

Instances details

Abstract PrimFun Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> PrimFun -> PrimFun Source #
Apply PrimFun Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: PrimFun -> Args -> PrimFun Source # applyE :: PrimFun -> Elims -> PrimFun Source #
Generic PrimFun Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep PrimFun :: Type -> Type Source # Methods from :: PrimFun -> Rep PrimFun x Source # to :: Rep PrimFun x -> PrimFun Source #
NFData PrimFun Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: PrimFun -> () Source #
type Rep PrimFun Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep PrimFun = D1 ('MetaData "PrimFun" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "PrimFun" 'PrefixI 'True) (S1 ('MetaSel ('Just "primFunName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Just "primFunArity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Arity) :*: S1 ('MetaSel ('Just "primFunImplementation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ([Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term))))))

data PrimitiveImpl Source #

Primitives

Constructors

PrimImpl Type PrimFun |

data ReduceDefs Source #

Constructors

OnlyReduceDefs (Set QName) |
DontReduceDefs (Set QName) |

#### Instances

Instances details

Data ReduceDefs Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ReduceDefs -> c ReduceDefs Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ReduceDefs Source #

toConstr :: ReduceDefs -> Constr Source #

dataTypeOf :: ReduceDefs -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ReduceDefs) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ReduceDefs) Source #

gmapT :: (forall b. Data b => b -> b) -> ReduceDefs -> ReduceDefs Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ReduceDefs -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ReduceDefs -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ReduceDefs -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ReduceDefs -> m ReduceDefs Source #

Monoid ReduceDefs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods mempty :: ReduceDefs Source # mappend :: ReduceDefs -> ReduceDefs -> ReduceDefs Source # mconcat :: [ReduceDefs] -> ReduceDefs Source #
Semigroup ReduceDefs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (<>) :: ReduceDefs -> ReduceDefs -> ReduceDefs Source # sconcat :: NonEmpty ReduceDefs -> ReduceDefs Source # stimes :: Integral b => b -> ReduceDefs -> ReduceDefs Source #
Generic ReduceDefs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep ReduceDefs :: Type -> Type Source # Methods from :: ReduceDefs -> Rep ReduceDefs x Source # to :: Rep ReduceDefs x -> ReduceDefs Source #
NFData ReduceDefs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: ReduceDefs -> () Source #
type Rep ReduceDefs Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep ReduceDefs = D1 ('MetaData "ReduceDefs" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "OnlyReduceDefs" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set QName))) :+: C1 ('MetaCons "DontReduceDefs" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set QName))))

type AllowedReductions = SmallSet AllowedReduction Source #

data AllowedReduction Source #

Controlling `reduce`.

Constructors

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.

#### Instances

Instances details

Data AllowedReduction Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AllowedReduction -> c AllowedReduction Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AllowedReduction Source #

toConstr :: AllowedReduction -> Constr Source #

dataTypeOf :: AllowedReduction -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AllowedReduction) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AllowedReduction) Source #

gmapT :: (forall b. Data b => b -> b) -> AllowedReduction -> AllowedReduction Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AllowedReduction -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> AllowedReduction -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AllowedReduction -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AllowedReduction -> m AllowedReduction Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AllowedReduction -> m AllowedReduction Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AllowedReduction -> m AllowedReduction Source #

Bounded AllowedReduction Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods minBound :: AllowedReduction Source # maxBound :: AllowedReduction Source #
Enum AllowedReduction Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: AllowedReduction -> AllowedReduction Source #

pred :: AllowedReduction -> AllowedReduction Source #

toEnum :: Int -> AllowedReduction Source #

fromEnum :: AllowedReduction -> Int Source #

enumFrom :: AllowedReduction -> [AllowedReduction] Source #

enumFromThen :: AllowedReduction -> AllowedReduction -> [AllowedReduction] Source #

enumFromTo :: AllowedReduction -> AllowedReduction -> [AllowedReduction] Source #

enumFromThenTo :: AllowedReduction -> AllowedReduction -> AllowedReduction -> [AllowedReduction] Source #

Generic AllowedReduction Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep AllowedReduction :: Type -> Type Source # Methods from :: AllowedReduction -> Rep AllowedReduction x Source # to :: Rep AllowedReduction x -> AllowedReduction Source #
Ix AllowedReduction Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

range :: (AllowedReduction, AllowedReduction) -> [AllowedReduction] Source #

index :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int Source #

unsafeIndex :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Int Source #

inRange :: (AllowedReduction, AllowedReduction) -> AllowedReduction -> Bool Source #

rangeSize :: (AllowedReduction, AllowedReduction) -> Int Source #

unsafeRangeSize :: (AllowedReduction, AllowedReduction) -> Int Source #

Show AllowedReduction Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> AllowedReduction -> ShowS Source # show :: AllowedReduction -> String Source # showList :: [AllowedReduction] -> ShowS Source #
NFData AllowedReduction Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: AllowedReduction -> () Source #
Eq AllowedReduction Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: AllowedReduction -> AllowedReduction -> Bool Source # (/=) :: AllowedReduction -> AllowedReduction -> Bool Source #
Ord AllowedReduction Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: AllowedReduction -> AllowedReduction -> Ordering Source #

(<) :: AllowedReduction -> AllowedReduction -> Bool Source #

(<=) :: AllowedReduction -> AllowedReduction -> Bool Source #

(>) :: AllowedReduction -> AllowedReduction -> Bool Source #

(>=) :: AllowedReduction -> AllowedReduction -> Bool Source #

max :: AllowedReduction -> AllowedReduction -> AllowedReduction Source #

min :: AllowedReduction -> AllowedReduction -> AllowedReduction Source #

type Rep AllowedReduction Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep AllowedReduction = D1 ('MetaData "AllowedReduction" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (((C1 ('MetaCons "ProjectionReductions" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InlineReductions" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CopatternReductions" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FunctionReductions" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "RecursiveReductions" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LevelReductions" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TypeLevelReductions" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "UnconfirmedReductions" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NonTerminatingReductions" 'PrefixI 'False) (U1 :: Type -> Type)))))

type MaybeReducedElims = [MaybeReduced Elim] Source #

type MaybeReducedArgs = [MaybeReduced (Arg Term)] Source #

data MaybeReduced a Source #

Constructors

MaybeRed |

Fields

- isReduced :: IsReduced
- ignoreReduced :: a

#### Instances

Instances details

Functor MaybeReduced Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> MaybeReduced a -> MaybeReduced b Source # (<$) :: a -> MaybeReduced b -> MaybeReduced a Source #
IsProjElim e => IsProjElim (MaybeReduced e) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods isProjElim :: MaybeReduced e -> Maybe (ProjOrigin, QName) Source #
PrettyTCM a => PrettyTCM (MaybeReduced a) Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => MaybeReduced a -> m Doc Source #

data IsReduced Source #

Three cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked.

Constructors

NotReduced |
Reduced (Blocked ()) |

data Reduced no yes Source #

Constructors

NoReduction no |
YesReduction Simplification yes |

#### Instances

Instances details

Functor (Reduced no) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> Reduced no a -> Reduced no b Source # (<$) :: a -> Reduced no b -> Reduced no a Source #

data Simplification Source #

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?

Constructors

YesSimplification |
NoSimplification |

#### Instances

Instances details

Null Simplification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods empty :: Simplification Source # null :: Simplification -> Bool Source #
Data Simplification Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Simplification -> c Simplification Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Simplification Source #

toConstr :: Simplification -> Constr Source #

dataTypeOf :: Simplification -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Simplification) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Simplification) Source #

gmapT :: (forall b. Data b => b -> b) -> Simplification -> Simplification Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Simplification -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Simplification -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Simplification -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Simplification -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Simplification -> m Simplification Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Simplification -> m Simplification Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Simplification -> m Simplification Source #

Monoid Simplification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods mempty :: Simplification Source # mappend :: Simplification -> Simplification -> Simplification Source # mconcat :: [Simplification] -> Simplification Source #
Semigroup Simplification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (<>) :: Simplification -> Simplification -> Simplification Source # sconcat :: NonEmpty Simplification -> Simplification Source # stimes :: Integral b => b -> Simplification -> Simplification Source #
Generic Simplification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Simplification :: Type -> Type Source # Methods from :: Simplification -> Rep Simplification x Source # to :: Rep Simplification x -> Simplification Source #
Show Simplification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Simplification -> ShowS Source # show :: Simplification -> String Source # showList :: [Simplification] -> ShowS Source #
NFData Simplification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Simplification -> () Source #
Eq Simplification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: Simplification -> Simplification -> Bool Source # (/=) :: Simplification -> Simplification -> Bool Source #
type Rep Simplification Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep Simplification = D1 ('MetaData "Simplification" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "YesSimplification" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NoSimplification" 'PrefixI 'False) (U1 :: Type -> Type))

newtype Fields Source #

Constructors

Fields [(Name, Type)] |

#### Instances

Instances details

Null Fields Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods empty :: Fields Source # null :: Fields -> Bool Source #

data Defn Source #

Constructors

Axiom | Postulate

Fields

- axiomConstTransp :: Bool

  Can transp for this postulate be constant? Set to `True` for bultins like String.

DataOrRecSig | Data or record type signature that doesn't yet have a definition

Fields

- datarecPars :: Int

GeneralizableVar | Generalizable variable (introduced in `generalize` block)
AbstractDefn Defn | Returned by `getConstInfo` if definition is abstract.
Function |

Fields

- funClauses :: [Clause]
- funCompiled :: Maybe CompiledClauses

  `Nothing` while function is still type-checked. `Just cc` after type and coverage checking and translation to case trees.

- funSplitTree :: Maybe SplitTree

  The split tree constructed by the coverage checker. Needed to re-compile the clauses after forcing translation.

- funTreeless :: Maybe Compiled

  Intermediate representation for compiler backends.

- funCovering :: [Clause]

  Covering clauses computed by coverage checking. Erased by (IApply) confluence checking(?)

- funInv :: FunctionInverse
- 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).

- funAbstr :: IsAbstract
- funDelayed :: Delayed

  Are the clauses of this definition delayed?

- 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.

- funFlags :: Set FunctionFlag
- funTerminates :: Maybe Bool

  Has this function been termination checked? Did it pass?

- 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

- funWith :: Maybe QName

  Is this a generated with-function? If yes, then what's the name of the parent function.

Datatype |

Fields

- dataPars :: Nat

  Number of parameters.

- dataIxs :: Nat

  Number of indices.

- dataClause :: Maybe Clause

  This might be in an instantiated module.

- dataCons :: [QName]

  Constructor names , ordered according to the order of their definition.

- dataSort :: Sort
- 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).

- dataAbstr :: IsAbstract
- dataPathCons :: [QName]

  Path constructor names (subset of dataCons)

Record |

Fields

- recPars :: Nat

  Number of parameters.

- 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).

- recConHead :: ConHead

  Constructor name and fields.

- recNamedCon :: Bool

  Does this record have a `constructor`?

- recFields :: [Dom QName]

  The record field names.

- recTel :: Telescope

  The record field telescope. (Includes record parameters.) Note: `TelV recTel _ == telView' recConType`. Thus, `recTel` is redundant.

- 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).

- recEtaEquality' :: EtaEquality

  Eta-expand at this record type? `False` for unguarded recursive records and coinductive records unless the user specifies otherwise.

- 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`.

- 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.

- recAbstr :: IsAbstract
- recComp :: CompKit

Constructor |

Fields

- conPars :: Int

  Number of parameters.

- conArity :: Int

  Number of arguments (excluding parameters).

- conSrcCon :: ConHead

  Name of (original) constructor and fields. (This might be in a module instance.)

- conData :: QName

  Name of datatype or record type.

- conAbstr :: IsAbstract
- conInd :: Induction

  Inductive or coinductive?

- conComp :: CompKit

  Cubical composition.

- conProj :: Maybe [QName]

  Projections. `Nothing` if not yet computed.

- 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`.

- 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.

Fields

- primAbstr :: IsAbstract
- primName :: String
- primClauses :: [Clause]

  `null` for primitive functions, `not null` for builtin functions.

- primInv :: FunctionInverse

  Builtin functions can have inverses. For instance, natural number addition.

- primCompiled :: Maybe CompiledClauses

  `Nothing` for primitive functions, ``Just` something` for builtin functions.

PrimitiveSort |

Fields

- primName :: String
- primSort :: Sort

#### Instances

Instances details

NamesIn Defn Source # |
Instance details Defined in Agda.Syntax.Internal.Names Methods namesIn' :: Monoid m => (QName -> m) -> Defn -> m Source #
KillRange Defn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT Defn Source #
Occurs Defn Source # |
Instance details Defined in Agda.TypeChecking.MetaVars.Occurs Methods occurs :: Defn -> OccursM Defn Source # metaOccurs :: MetaId -> Defn -> TCM () Source #
InstantiateFull Defn Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Defn -> ReduceM Defn Source #
EmbPrj Defn Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: Defn -> S Int32 Source # icod_ :: Defn -> S Int32 Source # value :: Int32 -> R Defn Source #
Abstract Defn Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> Defn -> Defn Source #
Apply Defn Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: Defn -> Args -> Defn Source # applyE :: Defn -> Elims -> Defn Source #
Pretty Defn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Defn -> Doc Source # prettyPrec :: Int -> Defn -> Doc Source # prettyList :: [Defn] -> Doc Source #
Data Defn Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Defn -> c Defn Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Defn Source #

toConstr :: Defn -> Constr Source #

dataTypeOf :: Defn -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Defn) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Defn) Source #

gmapT :: (forall b. Data b => b -> b) -> Defn -> Defn Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Defn -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Defn -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Defn -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Defn -> m Defn Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Defn -> m Defn Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Defn -> m Defn Source #

Generic Defn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Defn :: Type -> Type Source # Methods from :: Defn -> Rep Defn x Source # to :: Rep Defn x -> Defn Source #
Show Defn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Defn -> ShowS Source # show :: Defn -> String Source # showList :: [Defn] -> ShowS Source #
NFData Defn Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Defn -> () Source #
type Rep Defn Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Defn = D1 ('MetaData "Defn" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (((C1 ('MetaCons "Axiom" 'PrefixI 'True) (S1 ('MetaSel ('Just "axiomConstTransp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :+: C1 ('MetaCons "DataOrRecSig" 'PrefixI 'True) (S1 ('MetaSel ('Just "datarecPars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))) :+: (C1 ('MetaCons "GeneralizableVar" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "AbstractDefn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Defn)) :+: C1 ('MetaCons "Function" 'PrefixI 'True) (((S1 ('MetaSel ('Just "funClauses") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause]) :*: (S1 ('MetaSel ('Just "funCompiled") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe CompiledClauses)) :*: S1 ('MetaSel ('Just "funSplitTree") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SplitTree)))) :*: ((S1 ('MetaSel ('Just "funTreeless") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Compiled)) :*: S1 ('MetaSel ('Just "funCovering") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause])) :*: (S1 ('MetaSel ('Just "funInv") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FunctionInverse) :*: S1 ('MetaSel ('Just "funMutual") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [QName]))))) :*: ((S1 ('MetaSel ('Just "funAbstr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IsAbstract) :*: (S1 ('MetaSel ('Just "funDelayed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Delayed) :*: S1 ('MetaSel ('Just "funProjection") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Projection)))) :*: ((S1 ('MetaSel ('Just "funFlags") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set FunctionFlag)) :*: S1 ('MetaSel ('Just "funTerminates") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Bool))) :*: (S1 ('MetaSel ('Just "funExtLam") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ExtLamInfo)) :*: S1 ('MetaSel ('Just "funWith") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe QName))))))))) :+: ((C1 ('MetaCons "Datatype" 'PrefixI 'True) (((S1 ('MetaSel ('Just "dataPars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat) :*: S1 ('MetaSel ('Just "dataIxs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat)) :*: (S1 ('MetaSel ('Just "dataClause") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Clause)) :*: S1 ('MetaSel ('Just "dataCons") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QName]))) :*: ((S1 ('MetaSel ('Just "dataSort") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort) :*: S1 ('MetaSel ('Just "dataMutual") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [QName]))) :*: (S1 ('MetaSel ('Just "dataAbstr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IsAbstract) :*: S1 ('MetaSel ('Just "dataPathCons") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QName])))) :+: C1 ('MetaCons "Record" 'PrefixI 'True) (((S1 ('MetaSel ('Just "recPars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat) :*: (S1 ('MetaSel ('Just "recClause") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Clause)) :*: S1 ('MetaSel ('Just "recConHead") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ConHead))) :*: (S1 ('MetaSel ('Just "recNamedCon") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: (S1 ('MetaSel ('Just "recFields") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dom QName]) :*: S1 ('MetaSel ('Just "recTel") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope)))) :*: ((S1 ('MetaSel ('Just "recMutual") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [QName])) :*: (S1 ('MetaSel ('Just "recEtaEquality'") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 EtaEquality) :*: S1 ('MetaSel ('Just "recPatternMatching") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatternOrCopattern))) :*: (S1 ('MetaSel ('Just "recInduction") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Induction)) :*: (S1 ('MetaSel ('Just "recAbstr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IsAbstract) :*: S1 ('MetaSel ('Just "recComp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CompKit)))))) :+: (C1 ('MetaCons "Constructor" 'PrefixI 'True) (((S1 ('MetaSel ('Just "conPars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Just "conArity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :*: (S1 ('MetaSel ('Just "conSrcCon") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ConHead) :*: (S1 ('MetaSel ('Just "conData") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Just "conAbstr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IsAbstract)))) :*: ((S1 ('MetaSel ('Just "conInd") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Induction) :*: S1 ('MetaSel ('Just "conComp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CompKit)) :*: (S1 ('MetaSel ('Just "conProj") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [QName])) :*: (S1 ('MetaSel ('Just "conForced") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [IsForced]) :*: S1 ('MetaSel ('Just "conErased") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [Bool])))))) :+: (C1 ('MetaCons "Primitive" 'PrefixI 'True) ((S1 ('MetaSel ('Just "primAbstr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IsAbstract) :*: S1 ('MetaSel ('Just "primName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :*: (S1 ('MetaSel ('Just "primClauses") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause]) :*: (S1 ('MetaSel ('Just "primInv") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FunctionInverse) :*: S1 ('MetaSel ('Just "primCompiled") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe CompiledClauses))))) :+: C1 ('MetaCons "PrimitiveSort" 'PrefixI 'True) (S1 ('MetaSel ('Just "primName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "primSort") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort))))))

data CompKit Source #

Constructors

CompKit |

Fields

- nameOfHComp :: Maybe QName
- nameOfTransp :: Maybe QName

#### Instances

Instances details

NamesIn CompKit Source # |
Instance details Defined in Agda.Syntax.Internal.Names Methods namesIn' :: Monoid m => (QName -> m) -> CompKit -> m Source #
KillRange CompKit Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT CompKit Source #
EmbPrj CompKit Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: CompKit -> S Int32 Source # icod_ :: CompKit -> S Int32 Source # value :: Int32 -> R CompKit Source #
Data CompKit Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompKit -> c CompKit Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompKit Source #

toConstr :: CompKit -> Constr Source #

dataTypeOf :: CompKit -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CompKit) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompKit) Source #

gmapT :: (forall b. Data b => b -> b) -> CompKit -> CompKit Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompKit -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompKit -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CompKit -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CompKit -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompKit -> m CompKit Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompKit -> m CompKit Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompKit -> m CompKit Source #

Generic CompKit Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep CompKit :: Type -> Type Source # Methods from :: CompKit -> Rep CompKit x Source # to :: Rep CompKit x -> CompKit Source #
Show CompKit Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> CompKit -> ShowS Source # show :: CompKit -> String Source # showList :: [CompKit] -> ShowS Source #
NFData CompKit Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: CompKit -> () Source #
Eq CompKit Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: CompKit -> CompKit -> Bool Source # (/=) :: CompKit -> CompKit -> Bool Source #
Ord CompKit Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods compare :: CompKit -> CompKit -> Ordering Source # (<) :: CompKit -> CompKit -> Bool Source # (<=) :: CompKit -> CompKit -> Bool Source # (>) :: CompKit -> CompKit -> Bool Source # (>=) :: CompKit -> CompKit -> Bool Source # max :: CompKit -> CompKit -> CompKit Source # min :: CompKit -> CompKit -> CompKit Source #
type Rep CompKit Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep CompKit = D1 ('MetaData "CompKit" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "CompKit" 'PrefixI 'True) (S1 ('MetaSel ('Just "nameOfHComp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe QName)) :*: S1 ('MetaSel ('Just "nameOfTransp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe QName))))

data FunctionFlag Source #

Constructors

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?

#### Instances

Instances details

KillRange FunctionFlag Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT FunctionFlag Source #
EmbPrj FunctionFlag Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: FunctionFlag -> S Int32 Source # icod_ :: FunctionFlag -> S Int32 Source # value :: Int32 -> R FunctionFlag Source #
Data FunctionFlag Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunctionFlag -> c FunctionFlag Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunctionFlag Source #

toConstr :: FunctionFlag -> Constr Source #

dataTypeOf :: FunctionFlag -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunctionFlag) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunctionFlag) Source #

gmapT :: (forall b. Data b => b -> b) -> FunctionFlag -> FunctionFlag Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunctionFlag -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> FunctionFlag -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunctionFlag -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunctionFlag -> m FunctionFlag Source #

Enum FunctionFlag Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: FunctionFlag -> FunctionFlag Source #

pred :: FunctionFlag -> FunctionFlag Source #

toEnum :: Int -> FunctionFlag Source #

fromEnum :: FunctionFlag -> Int Source #

enumFrom :: FunctionFlag -> [FunctionFlag] Source #

enumFromThen :: FunctionFlag -> FunctionFlag -> [FunctionFlag] Source #

enumFromTo :: FunctionFlag -> FunctionFlag -> [FunctionFlag] Source #

enumFromThenTo :: FunctionFlag -> FunctionFlag -> FunctionFlag -> [FunctionFlag] Source #

Generic FunctionFlag Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep FunctionFlag :: Type -> Type Source # Methods from :: FunctionFlag -> Rep FunctionFlag x Source # to :: Rep FunctionFlag x -> FunctionFlag Source #
Show FunctionFlag Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> FunctionFlag -> ShowS Source # show :: FunctionFlag -> String Source # showList :: [FunctionFlag] -> ShowS Source #
NFData FunctionFlag Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: FunctionFlag -> () Source #
Eq FunctionFlag Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: FunctionFlag -> FunctionFlag -> Bool Source # (/=) :: FunctionFlag -> FunctionFlag -> Bool Source #
Ord FunctionFlag Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: FunctionFlag -> FunctionFlag -> Ordering Source #

(<) :: FunctionFlag -> FunctionFlag -> Bool Source #

(<=) :: FunctionFlag -> FunctionFlag -> Bool Source #

(>) :: FunctionFlag -> FunctionFlag -> Bool Source #

(>=) :: FunctionFlag -> FunctionFlag -> Bool Source #

max :: FunctionFlag -> FunctionFlag -> FunctionFlag Source #

min :: FunctionFlag -> FunctionFlag -> FunctionFlag Source #

type Rep FunctionFlag Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep FunctionFlag = D1 ('MetaData "FunctionFlag" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "FunStatic" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FunInline" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FunMacro" 'PrefixI 'False) (U1 :: Type -> Type)))

data EtaEquality Source #

Should a record type admit eta-equality?

Constructors

Specified | User specifed 'eta-equality' or 'no-eta-equality'.

Fields

- theEtaEquality :: !HasEta

Inferred | Positivity checker inferred whether eta is safe.

Fields

- theEtaEquality :: !HasEta

#### Instances

Instances details

CopatternMatchingAllowed EtaEquality Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods copatternMatchingAllowed :: EtaEquality -> Bool Source #
PatternMatchingAllowed EtaEquality Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods patternMatchingAllowed :: EtaEquality -> Bool Source #
KillRange EtaEquality Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT EtaEquality Source #
EmbPrj EtaEquality Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: EtaEquality -> S Int32 Source # icod_ :: EtaEquality -> S Int32 Source # value :: Int32 -> R EtaEquality Source #
Data EtaEquality Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EtaEquality -> c EtaEquality Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EtaEquality Source #

toConstr :: EtaEquality -> Constr Source #

dataTypeOf :: EtaEquality -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EtaEquality) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EtaEquality) Source #

gmapT :: (forall b. Data b => b -> b) -> EtaEquality -> EtaEquality Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EtaEquality -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> EtaEquality -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> EtaEquality -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EtaEquality -> m EtaEquality Source #

Generic EtaEquality Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep EtaEquality :: Type -> Type Source # Methods from :: EtaEquality -> Rep EtaEquality x Source # to :: Rep EtaEquality x -> EtaEquality Source #
Show EtaEquality Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> EtaEquality -> ShowS Source # show :: EtaEquality -> String Source # showList :: [EtaEquality] -> ShowS Source #
NFData EtaEquality Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: EtaEquality -> () Source #
Eq EtaEquality Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: EtaEquality -> EtaEquality -> Bool Source # (/=) :: EtaEquality -> EtaEquality -> Bool Source #
type Rep EtaEquality Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep EtaEquality = D1 ('MetaData "EtaEquality" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Specified" 'PrefixI 'True) (S1 ('MetaSel ('Just "theEtaEquality") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 HasEta)) :+: C1 ('MetaCons "Inferred" 'PrefixI 'True) (S1 ('MetaSel ('Just "theEtaEquality") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 HasEta)))

newtype ProjLams Source #

Abstractions to build projection function (dropping parameters).

Constructors

ProjLams |

Fields

- getProjLams :: [Arg ArgName]

#### Instances

Instances details

KillRange ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT ProjLams Source #
EmbPrj ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: ProjLams -> S Int32 Source # icod_ :: ProjLams -> S Int32 Source # value :: Int32 -> R ProjLams Source #
Abstract ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> ProjLams -> ProjLams Source #
Apply ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: ProjLams -> Args -> ProjLams Source # applyE :: ProjLams -> Elims -> ProjLams Source #
Null ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods empty :: ProjLams Source # null :: ProjLams -> Bool Source #
Pretty ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: ProjLams -> Doc Source # prettyPrec :: Int -> ProjLams -> Doc Source # prettyList :: [ProjLams] -> Doc Source #
Data ProjLams Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ProjLams -> c ProjLams Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ProjLams Source #

toConstr :: ProjLams -> Constr Source #

dataTypeOf :: ProjLams -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ProjLams) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProjLams) Source #

gmapT :: (forall b. Data b => b -> b) -> ProjLams -> ProjLams Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ProjLams -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ProjLams -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ProjLams -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ProjLams -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ProjLams -> m ProjLams Source #

Generic ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep ProjLams :: Type -> Type Source # Methods from :: ProjLams -> Rep ProjLams x Source # to :: Rep ProjLams x -> ProjLams Source #
Show ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> ProjLams -> ShowS Source # show :: ProjLams -> String Source # showList :: [ProjLams] -> ShowS Source #
NFData ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: ProjLams -> () Source #
type Rep ProjLams Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep ProjLams = D1 ('MetaData "ProjLams" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'True) (C1 ('MetaCons "ProjLams" 'PrefixI 'True) (S1 ('MetaSel ('Just "getProjLams") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Arg ArgName])))

data Projection Source #

Additional information for projection `Function`s.

Constructors

Projection |

Fields

- 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.

- projOrig :: QName

  The original projection name (current name could be from module application).

- 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.

- 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`.

- 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`.

#### Instances

Instances details

KillRange Projection Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT Projection Source #
EmbPrj Projection Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: Projection -> S Int32 Source # icod_ :: Projection -> S Int32 Source # value :: Int32 -> R Projection Source #
Abstract Projection Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> Projection -> Projection Source #
Apply Projection Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: Projection -> Args -> Projection Source # applyE :: Projection -> Elims -> Projection Source #
Pretty Projection Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Projection -> Doc Source # prettyPrec :: Int -> Projection -> Doc Source # prettyList :: [Projection] -> Doc Source #
Data Projection Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Projection -> c Projection Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Projection Source #

toConstr :: Projection -> Constr Source #

dataTypeOf :: Projection -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Projection) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Projection) Source #

gmapT :: (forall b. Data b => b -> b) -> Projection -> Projection Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Projection -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Projection -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Projection -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Projection -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Projection -> m Projection Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Projection -> m Projection Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Projection -> m Projection Source #

Generic Projection Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Projection :: Type -> Type Source # Methods from :: Projection -> Rep Projection x Source # to :: Rep Projection x -> Projection Source #
Show Projection Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Projection -> ShowS Source # show :: Projection -> String Source # showList :: [Projection] -> ShowS Source #
NFData Projection Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Projection -> () Source #
type Rep Projection Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Projection = D1 ('MetaData "Projection" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Projection" 'PrefixI 'True) ((S1 ('MetaSel ('Just "projProper") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe QName)) :*: S1 ('MetaSel ('Just "projOrig") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :*: (S1 ('MetaSel ('Just "projFromType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg QName)) :*: (S1 ('MetaSel ('Just "projIndex") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Just "projLams") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ProjLams)))))

data ExtLamInfo Source #

Additional information for extended lambdas.

Constructors

ExtLamInfo |

Fields

- 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.

- extLamAbsurd :: Bool

  Was this definition created from an absurd lambda `λ ()`?

- extLamSys :: !(Maybe System)

#### Instances

Instances details

KillRange ExtLamInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT ExtLamInfo Source #
InstantiateFull ExtLamInfo Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: ExtLamInfo -> ReduceM ExtLamInfo Source #
EmbPrj ExtLamInfo Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: ExtLamInfo -> S Int32 Source # icod_ :: ExtLamInfo -> S Int32 Source # value :: Int32 -> R ExtLamInfo Source #
Apply ExtLamInfo Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: ExtLamInfo -> Args -> ExtLamInfo Source # applyE :: ExtLamInfo -> Elims -> ExtLamInfo Source #
Data ExtLamInfo Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExtLamInfo -> c ExtLamInfo Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ExtLamInfo Source #

toConstr :: ExtLamInfo -> Constr Source #

dataTypeOf :: ExtLamInfo -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ExtLamInfo) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtLamInfo) Source #

gmapT :: (forall b. Data b => b -> b) -> ExtLamInfo -> ExtLamInfo Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExtLamInfo -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ExtLamInfo -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExtLamInfo -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExtLamInfo -> m ExtLamInfo Source #

Generic ExtLamInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep ExtLamInfo :: Type -> Type Source # Methods from :: ExtLamInfo -> Rep ExtLamInfo x Source # to :: Rep ExtLamInfo x -> ExtLamInfo Source #
Show ExtLamInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> ExtLamInfo -> ShowS Source # show :: ExtLamInfo -> String Source # showList :: [ExtLamInfo] -> ShowS Source #
NFData ExtLamInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: ExtLamInfo -> () Source #
type Rep ExtLamInfo Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep ExtLamInfo = D1 ('MetaData "ExtLamInfo" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "ExtLamInfo" 'PrefixI 'True) (S1 ('MetaSel ('Just "extLamModule") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName) :*: (S1 ('MetaSel ('Just "extLamAbsurd") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "extLamSys") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe System)))))

data System Source #

An alternative representation of partial elements in a telescope: Γ ⊢ λ Δ. [φ₁ u₁, ... , φₙ uₙ] : Δ → PartialP (∨_ᵢ φᵢ) T see cubicaltt paper (however we do not store the type T).

Constructors

System |

Fields

- systemTel :: Telescope

  the telescope Δ, binding vars for the clauses, Γ ⊢ Δ

- systemClauses :: [(Face, Term)]

  a system [φ₁ u₁, ... , φₙ uₙ] where Γ, Δ ⊢ φᵢ and Γ, Δ, φᵢ ⊢ uᵢ

#### Instances

Instances details

KillRange System Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT System Source #
InstantiateFull System Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: System -> ReduceM System Source #
EmbPrj System Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: System -> S Int32 Source # icod_ :: System -> S Int32 Source # value :: Int32 -> R System Source #
Abstract System Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> System -> System Source #
Apply System Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: System -> Args -> System Source # applyE :: System -> Elims -> System Source #
Data System Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> System -> c System Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c System Source #

toConstr :: System -> Constr Source #

dataTypeOf :: System -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c System) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c System) Source #

gmapT :: (forall b. Data b => b -> b) -> System -> System Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> System -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> System -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> System -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> System -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> System -> m System Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> System -> m System Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> System -> m System Source #

Generic System Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep System :: Type -> Type Source # Methods from :: System -> Rep System x Source # to :: Rep System x -> System Source #
Show System Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> System -> ShowS Source # show :: System -> String Source # showList :: [System] -> ShowS Source #
NFData System Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: System -> () Source #
Reify (QNamed System) Source # |
Instance details Defined in Agda.Syntax.Translation.InternalToAbstract Associated Types type ReifiesTo (QNamed System) Source # Methods reify :: MonadReify m => QNamed System -> m (ReifiesTo (QNamed System)) Source # reifyWhen :: MonadReify m => Bool -> QNamed System -> m (ReifiesTo (QNamed System)) Source #
type Rep System Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep System = D1 ('MetaData "System" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "System" 'PrefixI 'True) (S1 ('MetaSel ('Just "systemTel") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: S1 ('MetaSel ('Just "systemClauses") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Face, Term)])))

type ReifiesTo (QNamed System) Source # |
Instance details Defined in Agda.Syntax.Translation.InternalToAbstract type ReifiesTo (QNamed System) = [Clause]

type Face = [(Term, Bool)] Source #

type CompiledRepresentation = Map BackendName [CompilerPragma] Source #

data CompilerPragma Source #

The backends are responsible for parsing their own pragmas.

Constructors

CompilerPragma Range String |

#### Instances

Instances details

HasRange CompilerPragma Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: CompilerPragma -> Range Source #
KillRange CompiledRepresentation Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT CompiledRepresentation Source #
EmbPrj CompilerPragma Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Compilers Methods icode :: CompilerPragma -> S Int32 Source # icod_ :: CompilerPragma -> S Int32 Source # value :: Int32 -> R CompilerPragma Source #
Data CompilerPragma Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompilerPragma -> c CompilerPragma Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompilerPragma Source #

toConstr :: CompilerPragma -> Constr Source #

dataTypeOf :: CompilerPragma -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CompilerPragma) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompilerPragma) Source #

gmapT :: (forall b. Data b => b -> b) -> CompilerPragma -> CompilerPragma Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompilerPragma -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompilerPragma -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CompilerPragma -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CompilerPragma -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompilerPragma -> m CompilerPragma Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompilerPragma -> m CompilerPragma Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompilerPragma -> m CompilerPragma Source #

Generic CompilerPragma Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep CompilerPragma :: Type -> Type Source # Methods from :: CompilerPragma -> Rep CompilerPragma x Source # to :: Rep CompilerPragma x -> CompilerPragma Source #
Show CompilerPragma Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> CompilerPragma -> ShowS Source # show :: CompilerPragma -> String Source # showList :: [CompilerPragma] -> ShowS Source #
NFData CompilerPragma Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: CompilerPragma -> () Source #
Eq CompilerPragma Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: CompilerPragma -> CompilerPragma -> Bool Source # (/=) :: CompilerPragma -> CompilerPragma -> Bool Source #
type Rep CompilerPragma Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep CompilerPragma = D1 ('MetaData "CompilerPragma" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "CompilerPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))

data IsForced Source #

Information about whether an argument is forced by the type of a function.

Constructors

Forced |
NotForced |

#### Instances

Instances details

KillRange IsForced Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT IsForced Source #
PrettyTCM IsForced Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => IsForced -> m Doc Source #
ChooseFlex IsForced Source # |
Instance details Defined in Agda.TypeChecking.Rules.LHS.Problem Methods chooseFlex :: IsForced -> IsForced -> FlexChoice Source #
EmbPrj IsForced Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: IsForced -> S Int32 Source # icod_ :: IsForced -> S Int32 Source # value :: Int32 -> R IsForced Source #
Data IsForced Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IsForced -> c IsForced Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IsForced Source #

toConstr :: IsForced -> Constr Source #

dataTypeOf :: IsForced -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IsForced) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IsForced) Source #

gmapT :: (forall b. Data b => b -> b) -> IsForced -> IsForced Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IsForced -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IsForced -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> IsForced -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IsForced -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IsForced -> m IsForced Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IsForced -> m IsForced Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IsForced -> m IsForced Source #

Generic IsForced Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep IsForced :: Type -> Type Source # Methods from :: IsForced -> Rep IsForced x Source # to :: Rep IsForced x -> IsForced Source #
Show IsForced Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> IsForced -> ShowS Source # show :: IsForced -> String Source # showList :: [IsForced] -> ShowS Source #
NFData IsForced Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: IsForced -> () Source #
Eq IsForced Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: IsForced -> IsForced -> Bool Source # (/=) :: IsForced -> IsForced -> Bool Source #
type Rep IsForced Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep IsForced = D1 ('MetaData "IsForced" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Forced" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NotForced" 'PrefixI 'False) (U1 :: Type -> Type))

data NumGeneralizableArgs Source #

Constructors

NoGeneralizableArgs |
SomeGeneralizableArgs !Int | When lambda-lifting new args are generalizable if `SomeGeneralizableArgs`, also when the number is zero.

#### Instances

Instances details

KillRange NumGeneralizableArgs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT NumGeneralizableArgs Source #
EmbPrj NumGeneralizableArgs Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: NumGeneralizableArgs -> S Int32 Source # icod_ :: NumGeneralizableArgs -> S Int32 Source # value :: Int32 -> R NumGeneralizableArgs Source #
Abstract NumGeneralizableArgs Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> NumGeneralizableArgs -> NumGeneralizableArgs Source #
Apply NumGeneralizableArgs Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: NumGeneralizableArgs -> Args -> NumGeneralizableArgs Source # applyE :: NumGeneralizableArgs -> Elims -> NumGeneralizableArgs Source #
Data NumGeneralizableArgs Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NumGeneralizableArgs -> c NumGeneralizableArgs Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NumGeneralizableArgs Source #

toConstr :: NumGeneralizableArgs -> Constr Source #

dataTypeOf :: NumGeneralizableArgs -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NumGeneralizableArgs) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NumGeneralizableArgs) Source #

gmapT :: (forall b. Data b => b -> b) -> NumGeneralizableArgs -> NumGeneralizableArgs Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NumGeneralizableArgs -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> NumGeneralizableArgs -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NumGeneralizableArgs -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NumGeneralizableArgs -> m NumGeneralizableArgs Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NumGeneralizableArgs -> m NumGeneralizableArgs Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NumGeneralizableArgs -> m NumGeneralizableArgs Source #

Show NumGeneralizableArgs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> NumGeneralizableArgs -> ShowS Source # show :: NumGeneralizableArgs -> String Source # showList :: [NumGeneralizableArgs] -> ShowS Source #
NFData NumGeneralizableArgs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: NumGeneralizableArgs -> () Source #

data Definition Source #

Constructors

Defn |

Fields

- defArgInfo :: ArgInfo

  Hiding should not be used.

- defName :: QName

  The canonical name, used e.g. in compilation.

- defType :: Type

  Type of the lifted definition.

- defPolarity :: [Polarity]

  Variance information on arguments of the definition. Does not include info for dropped parameters to projection(-like) functions and constructors.

- defArgOccurrences :: [Occurrence]

  Positivity information on arguments of the definition. Does not include info for dropped parameters to projection(-like) functions and constructors.

- defArgGeneralizable :: NumGeneralizableArgs

  How many arguments should be generalised.

- 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.

- defDisplay :: [LocalDisplayForm]
- defMutual :: MutualId
- defCompiledRep :: CompiledRepresentation
- defInstance :: Maybe QName

  `Just q` when this definition is an instance of class q

- defCopy :: Bool

  Has this function been created by a module instantiation?

- defMatchable :: Set QName

  The set of symbols with rewrite rules that match against this symbol

- defNoCompilation :: Bool

  should compilers skip this? Used for e.g. cubical's comp

- defInjective :: Bool

  Should the def be treated as injective by the pattern matching unifier?

- defCopatternLHS :: Bool

  Is this a function defined by copatterns?

- 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.

- defLanguage :: !Language

  The language used for the definition.

- theDef :: Defn

#### Instances

Instances details

LensArgInfo Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getArgInfo :: Definition -> ArgInfo Source # setArgInfo :: ArgInfo -> Definition -> Definition Source # mapArgInfo :: (ArgInfo -> ArgInfo) -> Definition -> Definition Source #
LensModality Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getModality :: Definition -> Modality Source # setModality :: Modality -> Definition -> Definition Source # mapModality :: (Modality -> Modality) -> Definition -> Definition Source #
LensQuantity Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getQuantity :: Definition -> Quantity Source # setQuantity :: Quantity -> Definition -> Definition Source # mapQuantity :: (Quantity -> Quantity) -> Definition -> Definition Source #
LensRelevance Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRelevance :: Definition -> Relevance Source # setRelevance :: Relevance -> Definition -> Definition Source # mapRelevance :: (Relevance -> Relevance) -> Definition -> Definition Source #
NamesIn Definition Source # |
Instance details Defined in Agda.Syntax.Internal.Names Methods namesIn' :: Monoid m => (QName -> m) -> Definition -> m Source #
KillRange Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT Definition Source #
KillRange Definitions Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT Definitions Source #
InstantiateFull Definition Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Definition -> ReduceM Definition Source #
EmbPrj Definition Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: Definition -> S Int32 Source # icod_ :: Definition -> S Int32 Source # value :: Int32 -> R Definition Source #
Abstract Definition Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> Definition -> Definition Source #
Apply Definition Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: Definition -> Args -> Definition Source # applyE :: Definition -> Elims -> Definition Source #
Pretty Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Definition -> Doc Source # prettyPrec :: Int -> Definition -> Doc Source # prettyList :: [Definition] -> Doc Source #
Generic Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Definition :: Type -> Type Source # Methods from :: Definition -> Rep Definition x Source # to :: Rep Definition x -> Definition Source #
Show Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Definition -> ShowS Source # show :: Definition -> String Source # showList :: [Definition] -> ShowS Source #
NFData Definition Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Definition -> () Source #
type Rep Definition Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Definition = D1 ('MetaData "Definition" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Defn" 'PrefixI 'True) ((((S1 ('MetaSel ('Just "defArgInfo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ArgInfo) :*: S1 ('MetaSel ('Just "defName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)) :*: (S1 ('MetaSel ('Just "defType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Just "defPolarity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Polarity]))) :*: ((S1 ('MetaSel ('Just "defArgOccurrences") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Occurrence]) :*: S1 ('MetaSel ('Just "defArgGeneralizable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NumGeneralizableArgs)) :*: (S1 ('MetaSel ('Just "defGeneralizedParams") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Maybe Name]) :*: (S1 ('MetaSel ('Just "defDisplay") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [LocalDisplayForm]) :*: S1 ('MetaSel ('Just "defMutual") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MutualId))))) :*: (((S1 ('MetaSel ('Just "defCompiledRep") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CompiledRepresentation) :*: S1 ('MetaSel ('Just "defInstance") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe QName))) :*: (S1 ('MetaSel ('Just "defCopy") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: (S1 ('MetaSel ('Just "defMatchable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set QName)) :*: S1 ('MetaSel ('Just "defNoCompilation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))) :*: ((S1 ('MetaSel ('Just "defInjective") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "defCopatternLHS") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :*: (S1 ('MetaSel ('Just "defBlocked") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Blocked_) :*: (S1 ('MetaSel ('Just "defLanguage") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Language) :*: S1 ('MetaSel ('Just "theDef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Defn)))))))

data RewriteRule Source #

Rewrite rules can be added independently from function clauses.

Constructors

RewriteRule |

Fields

- rewName :: QName

  Name of rewrite rule `q : Γ → f ps ≡ rhs` where `≡` is the rewrite relation.

- rewContext :: Telescope

  `Γ`.

- rewHead :: QName

  `f`.

- rewPats :: PElims

  `Γ ⊢ f ps : t`.

- rewRHS :: Term

  `Γ ⊢ rhs : t`.

- rewType :: Type

  `Γ ⊢ t`.

- rewFromClause :: Bool

  Was this rewrite rule created from a clause in the definition of the function?

#### Instances

Instances details

KillRange RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT RewriteRule Source #
KillRange RewriteRuleMap Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT RewriteRuleMap Source #
PrettyTCM RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => RewriteRule -> m Doc Source #
InstantiateFull RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: RewriteRule -> ReduceM RewriteRule Source #
GetMatchables RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods getMatchables :: RewriteRule -> [QName] Source #
EmbPrj RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: RewriteRule -> S Int32 Source # icod_ :: RewriteRule -> S Int32 Source # value :: Int32 -> R RewriteRule Source #
Abstract RewriteRule Source # | `tel ⊢ (Γ ⊢ lhs ↦ rhs : t)` becomes `tel, Γ ⊢ lhs ↦ rhs : t)` we do not need to change lhs, rhs, and t since they live in Γ. See 'Abstract Clause'.
Instance details Defined in Agda.TypeChecking.Substitute Methods abstract :: Telescope -> RewriteRule -> RewriteRule Source #
Apply RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: RewriteRule -> Args -> RewriteRule Source # applyE :: RewriteRule -> Elims -> RewriteRule Source #
Subst RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg RewriteRule Source # Methods applySubst :: Substitution' (SubstArg RewriteRule) -> RewriteRule -> RewriteRule Source #
Data RewriteRule Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RewriteRule -> c RewriteRule Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RewriteRule Source #

toConstr :: RewriteRule -> Constr Source #

dataTypeOf :: RewriteRule -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RewriteRule) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RewriteRule) Source #

gmapT :: (forall b. Data b => b -> b) -> RewriteRule -> RewriteRule Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RewriteRule -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> RewriteRule -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RewriteRule -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RewriteRule -> m RewriteRule Source #

Generic RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep RewriteRule :: Type -> Type Source # Methods from :: RewriteRule -> Rep RewriteRule x Source # to :: Rep RewriteRule x -> RewriteRule Source #
Show RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> RewriteRule -> ShowS Source # show :: RewriteRule -> String Source # showList :: [RewriteRule] -> ShowS Source #
NFData RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: RewriteRule -> () Source #
type SubstArg RewriteRule Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg RewriteRule = NLPat
type Rep RewriteRule Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep RewriteRule = D1 ('MetaData "RewriteRule" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "RewriteRule" 'PrefixI 'True) ((S1 ('MetaSel ('Just "rewName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Just "rewContext") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Telescope) :*: S1 ('MetaSel ('Just "rewHead") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName))) :*: ((S1 ('MetaSel ('Just "rewPats") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PElims) :*: S1 ('MetaSel ('Just "rewRHS") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :*: (S1 ('MetaSel ('Just "rewType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Just "rewFromClause") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))))

type RewriteRules = [RewriteRule] Source #

data NLPSort Source #

Constructors

PType NLPat |
PProp NLPat |
PInf IsFibrant Integer |
PSizeUniv |
PLockUniv |

#### Instances

Instances details

KillRange NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT NLPSort Source #
Free NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods freeVars' :: IsVarSet a c => NLPSort -> FreeM a c Source #
PrettyTCM NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => NLPSort -> m Doc Source #
InstantiateFull NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: NLPSort -> ReduceM NLPSort Source #
GetMatchables NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods getMatchables :: NLPSort -> [QName] Source #
NLPatVars NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods nlPatVarsUnder :: Int -> NLPSort -> IntSet Source # nlPatVars :: NLPSort -> IntSet Source #
EmbPrj NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: NLPSort -> S Int32 Source # icod_ :: NLPSort -> S Int32 Source # value :: Int32 -> R NLPSort Source #
Subst NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg NLPSort Source # Methods applySubst :: Substitution' (SubstArg NLPSort) -> NLPSort -> NLPSort Source #
Data NLPSort Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NLPSort -> c NLPSort Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NLPSort Source #

toConstr :: NLPSort -> Constr Source #

dataTypeOf :: NLPSort -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NLPSort) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NLPSort) Source #

gmapT :: (forall b. Data b => b -> b) -> NLPSort -> NLPSort Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPSort -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPSort -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> NLPSort -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NLPSort -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NLPSort -> m NLPSort Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPSort -> m NLPSort Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPSort -> m NLPSort Source #

Generic NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep NLPSort :: Type -> Type Source # Methods from :: NLPSort -> Rep NLPSort x Source # to :: Rep NLPSort x -> NLPSort Source #
Show NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> NLPSort -> ShowS Source # show :: NLPSort -> String Source # showList :: [NLPSort] -> ShowS Source #
NFData NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: NLPSort -> () Source #
NLPatToTerm NLPSort Sort Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods nlPatToTerm :: PureTCM m => NLPSort -> m Sort Source #
Match () NLPSort Sort Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods match :: Relevance -> Telescope -> Telescope -> () -> NLPSort -> Sort -> NLM () Source #
PatternFrom () Sort NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods patternFrom :: Relevance -> Int -> () -> Sort -> TCM NLPSort Source #
type SubstArg NLPSort Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg NLPSort = NLPat
type Rep NLPSort Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep NLPSort = D1 ('MetaData "NLPSort" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "PType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NLPat)) :+: C1 ('MetaCons "PProp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NLPat))) :+: (C1 ('MetaCons "PInf" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IsFibrant) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer)) :+: (C1 ('MetaCons "PSizeUniv" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PLockUniv" 'PrefixI 'False) (U1 :: Type -> Type))))

data NLPType Source #

Constructors

NLPType |

Fields

- nlpTypeSort :: NLPSort
- nlpTypeUnEl :: NLPat

#### Instances

Instances details

KillRange NLPType Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT NLPType Source #
Free NLPType Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods freeVars' :: IsVarSet a c => NLPType -> FreeM a c Source #
PrettyTCM NLPType Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => NLPType -> m Doc Source #
InstantiateFull NLPType Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: NLPType -> ReduceM NLPType Source #
GetMatchables NLPType Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods getMatchables :: NLPType -> [QName] Source #
NLPatVars NLPType Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods nlPatVarsUnder :: Int -> NLPType -> IntSet Source # nlPatVars :: NLPType -> IntSet Source #
EmbPrj NLPType Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: NLPType -> S Int32 Source # icod_ :: NLPType -> S Int32 Source # value :: Int32 -> R NLPType Source #
Subst NLPType Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg NLPType Source # Methods applySubst :: Substitution' (SubstArg NLPType) -> NLPType -> NLPType Source #
Data NLPType Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NLPType -> c NLPType Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NLPType Source #

toConstr :: NLPType -> Constr Source #

dataTypeOf :: NLPType -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NLPType) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NLPType) Source #

gmapT :: (forall b. Data b => b -> b) -> NLPType -> NLPType Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPType -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPType -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> NLPType -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NLPType -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NLPType -> m NLPType Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPType -> m NLPType Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPType -> m NLPType Source #

Generic NLPType Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep NLPType :: Type -> Type Source # Methods from :: NLPType -> Rep NLPType x Source # to :: Rep NLPType x -> NLPType Source #
Show NLPType Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> NLPType -> ShowS Source # show :: NLPType -> String Source # showList :: [NLPType] -> ShowS Source #
NFData NLPType Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: NLPType -> () Source #
NLPatToTerm NLPType Type Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods nlPatToTerm :: PureTCM m => NLPType -> m Type Source #
Match () NLPType Type Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods match :: Relevance -> Telescope -> Telescope -> () -> NLPType -> Type -> NLM () Source #
PatternFrom () Type NLPType Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods patternFrom :: Relevance -> Int -> () -> Type -> TCM NLPType Source #
type SubstArg NLPType Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg NLPType = NLPat
type Rep NLPType Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep NLPType = D1 ('MetaData "NLPType" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "NLPType" 'PrefixI 'True) (S1 ('MetaSel ('Just "nlpTypeSort") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NLPSort) :*: S1 ('MetaSel ('Just "nlpTypeUnEl") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NLPat)))

type PElims = [Elim' NLPat] Source #

data NLPat Source #

Non-linear (non-constructor) first-order pattern.

Constructors

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 !Int PElims | Matches `x es` where x is a lambda-bound variable
PTerm Term | Matches the term modulo β (ideally βη).

#### Instances

Instances details

KillRange NLPat Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT NLPat Source #
Free NLPat Source # | Only computes free variables that are not bound (see `nlPatVars`), i.e., those in a `PTerm`.
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods freeVars' :: IsVarSet a c => NLPat -> FreeM a c Source #
PrettyTCM NLPat Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => NLPat -> m Doc Source #
InstantiateFull NLPat Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: NLPat -> ReduceM NLPat Source #
GetMatchables NLPat Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods getMatchables :: NLPat -> [QName] Source #
NLPatVars NLPat Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods nlPatVarsUnder :: Int -> NLPat -> IntSet Source # nlPatVars :: NLPat -> IntSet Source #
EmbPrj NLPat Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: NLPat -> S Int32 Source # icod_ :: NLPat -> S Int32 Source # value :: Int32 -> R NLPat Source #
Subst NLPat Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg NLPat Source # Methods applySubst :: Substitution' (SubstArg NLPat) -> NLPat -> NLPat Source #
DeBruijn NLPat Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods deBruijnVar :: Int -> NLPat Source # debruijnNamedVar :: String -> Int -> NLPat Source # deBruijnView :: NLPat -> Maybe Int Source #
Data NLPat Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NLPat -> c NLPat Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NLPat Source #

toConstr :: NLPat -> Constr Source #

dataTypeOf :: NLPat -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NLPat) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NLPat) Source #

gmapT :: (forall b. Data b => b -> b) -> NLPat -> NLPat Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NLPat -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> NLPat -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NLPat -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NLPat -> m NLPat Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPat -> m NLPat Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NLPat -> m NLPat Source #

Generic NLPat Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep NLPat :: Type -> Type Source # Methods from :: NLPat -> Rep NLPat x Source # to :: Rep NLPat x -> NLPat Source #
Show NLPat Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> NLPat -> ShowS Source # show :: NLPat -> String Source # showList :: [NLPat] -> ShowS Source #
NFData NLPat Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: NLPat -> () Source #
NLPatToTerm NLPat Level Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods nlPatToTerm :: PureTCM m => NLPat -> m Level Source #
NLPatToTerm NLPat Term Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods nlPatToTerm :: PureTCM m => NLPat -> m Term Source #
Match Type NLPat Term Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods match :: Relevance -> Telescope -> Telescope -> Type -> NLPat -> Term -> NLM () Source #
Match () NLPat Level Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods match :: Relevance -> Telescope -> Telescope -> () -> NLPat -> Level -> NLM () Source #
PatternFrom Type Term NLPat Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods patternFrom :: Relevance -> Int -> Type -> Term -> TCM NLPat Source #
PatternFrom () Level NLPat Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods patternFrom :: Relevance -> Int -> () -> Level -> TCM NLPat Source #
PrettyTCM (Type' NLPat) Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => Type' NLPat -> m Doc Source #
PrettyTCM (Elim' NLPat) Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => Elim' NLPat -> m Doc Source #
ToNLPat (Arg DeBruijnPattern) (Elim' NLPat) Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.Clause Methods toNLPat :: Arg DeBruijnPattern -> Elim' NLPat Source #
ToNLPat (NamedArg DeBruijnPattern) (Elim' NLPat) Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.Clause Methods toNLPat :: NamedArg DeBruijnPattern -> Elim' NLPat Source #
PatternFrom (Type, Term) Elims [Elim' NLPat] Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinPattern Methods patternFrom :: Relevance -> Int -> (Type, Term) -> Elims -> TCM [Elim' NLPat] Source #
Match (Type, Elims -> Term) [Elim' NLPat] Elims Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods match :: Relevance -> Telescope -> Telescope -> (Type, Elims -> Term) -> [Elim' NLPat] -> Elims -> NLM () Source #
type SubstArg NLPat Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg NLPat = NLPat
type Rep NLPat Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep NLPat = D1 ('MetaData "NLPat" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "PVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Arg Int])) :+: (C1 ('MetaCons "PDef" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PElims)) :+: C1 ('MetaCons "PLam" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ArgInfo) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Abs NLPat))))) :+: ((C1 ('MetaCons "PPi" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Dom NLPType)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Abs NLPType))) :+: C1 ('MetaCons "PSort" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NLPSort))) :+: (C1 ('MetaCons "PBoundVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PElims)) :+: C1 ('MetaCons "PTerm" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)))))

data DisplayTerm Source #

A structured presentation of a `Term` for reification into `Syntax`.

Constructors

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`.

#### Instances

Instances details

NamesIn DisplayTerm Source # |
Instance details Defined in Agda.Syntax.Internal.Names Methods namesIn' :: Monoid m => (QName -> m) -> DisplayTerm -> m Source #
KillRange DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT DisplayTerm Source #
Reify DisplayTerm Source # |
Instance details Defined in Agda.Syntax.Translation.InternalToAbstract Associated Types type ReifiesTo DisplayTerm Source # Methods reify :: MonadReify m => DisplayTerm -> m (ReifiesTo DisplayTerm) Source # reifyWhen :: MonadReify m => Bool -> DisplayTerm -> m (ReifiesTo DisplayTerm) Source #
Free DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freeVars' :: IsVarSet a c => DisplayTerm -> FreeM a c Source #
PrettyTCM DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => DisplayTerm -> m Doc Source #
InstantiateFull DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: DisplayTerm -> ReduceM DisplayTerm Source #
EmbPrj DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: DisplayTerm -> S Int32 Source # icod_ :: DisplayTerm -> S Int32 Source # value :: Int32 -> R DisplayTerm Source #
Apply DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods apply :: DisplayTerm -> Args -> DisplayTerm Source # applyE :: DisplayTerm -> Elims -> DisplayTerm Source #
Subst DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg DisplayTerm Source # Methods applySubst :: Substitution' (SubstArg DisplayTerm) -> DisplayTerm -> DisplayTerm Source #
Pretty DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: DisplayTerm -> Doc Source # prettyPrec :: Int -> DisplayTerm -> Doc Source # prettyList :: [DisplayTerm] -> Doc Source #
Data DisplayTerm Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DisplayTerm -> c DisplayTerm Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DisplayTerm Source #

toConstr :: DisplayTerm -> Constr Source #

dataTypeOf :: DisplayTerm -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DisplayTerm) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DisplayTerm) Source #

gmapT :: (forall b. Data b => b -> b) -> DisplayTerm -> DisplayTerm Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DisplayTerm -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> DisplayTerm -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DisplayTerm -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DisplayTerm -> m DisplayTerm Source #

Generic DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep DisplayTerm :: Type -> Type Source # Methods from :: DisplayTerm -> Rep DisplayTerm x Source # to :: Rep DisplayTerm x -> DisplayTerm Source #
Show DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> DisplayTerm -> ShowS Source # show :: DisplayTerm -> String Source # showList :: [DisplayTerm] -> ShowS Source #
NFData DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: DisplayTerm -> () Source #
PrettyTCM (Elim' DisplayTerm) Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => Elim' DisplayTerm -> m Doc Source #
type ReifiesTo DisplayTerm Source # |
Instance details Defined in Agda.Syntax.Translation.InternalToAbstract type ReifiesTo DisplayTerm = Expr
type SubstArg DisplayTerm Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg DisplayTerm = Term
type Rep DisplayTerm Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep DisplayTerm = D1 ('MetaData "DisplayTerm" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "DWithApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DisplayTerm) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [DisplayTerm]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Elims))) :+: C1 ('MetaCons "DCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ConHead) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ConInfo) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Arg DisplayTerm])))) :+: (C1 ('MetaCons "DDef" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Elim' DisplayTerm])) :+: (C1 ('MetaCons "DDot" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :+: C1 ('MetaCons "DTerm" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)))))

type LocalDisplayForm = Open DisplayForm Source #

data DisplayForm Source #

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 `Syntax`.

The patterns `ts` are just terms, but the first `dfPatternVars` variables are pattern variables that matches any term.

Constructors

Display |

Fields

- dfPatternVars :: Nat

  Number `n` of pattern variables in `dfPats`.

- 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.

- dfRHS :: DisplayTerm

  Right hand side.

#### Instances

Instances details

NamesIn DisplayForm Source # |
Instance details Defined in Agda.Syntax.Internal.Names Methods namesIn' :: Monoid m => (QName -> m) -> DisplayForm -> m Source #
KillRange DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT DisplayForm Source #
Free DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freeVars' :: IsVarSet a c => DisplayForm -> FreeM a c Source #
InstantiateFull DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: DisplayForm -> ReduceM DisplayForm Source #
Normalise DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods normalise' :: DisplayForm -> ReduceM DisplayForm Source #
Simplify DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods simplify' :: DisplayForm -> ReduceM DisplayForm Source #
EmbPrj DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: DisplayForm -> S Int32 Source # icod_ :: DisplayForm -> S Int32 Source # value :: Int32 -> R DisplayForm Source #
Subst DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg DisplayForm Source # Methods applySubst :: Substitution' (SubstArg DisplayForm) -> DisplayForm -> DisplayForm Source #
Pretty DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: DisplayForm -> Doc Source # prettyPrec :: Int -> DisplayForm -> Doc Source # prettyList :: [DisplayForm] -> Doc Source #
Data DisplayForm Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DisplayForm -> c DisplayForm Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DisplayForm Source #

toConstr :: DisplayForm -> Constr Source #

dataTypeOf :: DisplayForm -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DisplayForm) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DisplayForm) Source #

gmapT :: (forall b. Data b => b -> b) -> DisplayForm -> DisplayForm Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DisplayForm -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> DisplayForm -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DisplayForm -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DisplayForm -> m DisplayForm Source #

Generic DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep DisplayForm :: Type -> Type Source # Methods from :: DisplayForm -> Rep DisplayForm x Source # to :: Rep DisplayForm x -> DisplayForm Source #
Show DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> DisplayForm -> ShowS Source # show :: DisplayForm -> String Source # showList :: [DisplayForm] -> ShowS Source #
NFData DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: DisplayForm -> () Source #
type SubstArg DisplayForm Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg DisplayForm = Term
type Rep DisplayForm Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep DisplayForm = D1 ('MetaData "DisplayForm" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Display" 'PrefixI 'True) (S1 ('MetaSel ('Just "dfPatternVars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat) :*: (S1 ('MetaSel ('Just "dfPats") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Elims) :*: S1 ('MetaSel ('Just "dfRHS") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DisplayTerm))))

newtype Section Source #

Constructors

Section |

Fields

- _secTelescope :: Telescope

#### Instances

Instances details

KillRange Section Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT Section Source #
KillRange Sections Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT Sections Source #
InstantiateFull Section Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Section -> ReduceM Section Source #
EmbPrj Section Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: Section -> S Int32 Source # icod_ :: Section -> S Int32 Source # value :: Int32 -> R Section Source #
Pretty Section Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Section -> Doc Source # prettyPrec :: Int -> Section -> Doc Source # prettyList :: [Section] -> Doc Source #
Data Section Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Section -> c Section Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Section Source #

toConstr :: Section -> Constr Source #

dataTypeOf :: Section -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Section) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Section) Source #

gmapT :: (forall b. Data b => b -> b) -> Section -> Section Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Section -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Section -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Section -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Section -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Section -> m Section Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Section -> m Section Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Section -> m Section Source #

Show Section Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Section -> ShowS Source # show :: Section -> String Source # showList :: [Section] -> ShowS Source #
NFData Section Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Section -> () Source #
Eq Section Source # |
Instance details Defined in Agda.TypeChecking.Substitute Methods (==) :: Section -> Section -> Bool Source # (/=) :: Section -> Section -> Bool Source #

type DisplayForms = HashMap QName [LocalDisplayForm] Source #

type RewriteRuleMap = HashMap QName RewriteRules Source #

type Definitions = HashMap QName Definition Source #

type Sections = Map ModuleName Section Source #

data Signature Source #

Constructors

Sig |

Fields

- _sigSections :: Sections
- _sigDefinitions :: Definitions
- _sigRewriteRules :: RewriteRuleMap

  The rewrite rules defined in this file.

#### Instances

Instances details

KillRange Signature Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT Signature Source #
InstantiateFull Signature Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Signature -> ReduceM Signature Source #
EmbPrj Signature Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: Signature -> S Int32 Source # icod_ :: Signature -> S Int32 Source # value :: Int32 -> R Signature Source #
Generic Signature Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Signature :: Type -> Type Source # Methods from :: Signature -> Rep Signature x Source # to :: Rep Signature x -> Signature Source #
Show Signature Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Signature -> ShowS Source # show :: Signature -> String Source # showList :: [Signature] -> ShowS Source #
NFData Signature Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Signature -> () Source #
type Rep Signature Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Signature = D1 ('MetaData "Signature" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Sig" 'PrefixI 'True) (S1 ('MetaSel ('Just "_sigSections") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sections) :*: (S1 ('MetaSel ('Just "_sigDefinitions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Definitions) :*: S1 ('MetaSel ('Just "_sigRewriteRules") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RewriteRuleMap))))

data IPClause Source #

Which clause is an interaction point located in?

Constructors

IPClause |

Fields

- ipcQName :: QName

  The name of the function.

- ipcClauseNo :: Int

  The number of the clause of this function.

- ipcType :: Type

  The type of the function

- ipcWithSub :: Maybe Substitution

  Module parameter substitution

- ipcClause :: SpineClause

  The original AST clause.

- ipcClosure :: Closure ()

  Environment for rechecking the clause.

- ipcBoundary :: [Closure IPBoundary]

  The boundary imposed by the LHS.

IPNoClause | The interaction point is not in the rhs of a clause.

#### Instances

Instances details

Generic IPClause Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep IPClause :: Type -> Type Source # Methods from :: IPClause -> Rep IPClause x Source # to :: Rep IPClause x -> IPClause Source #
NFData IPClause Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: IPClause -> () Source #
Eq IPClause Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: IPClause -> IPClause -> Bool Source # (/=) :: IPClause -> IPClause -> Bool Source #
type Rep IPClause Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep IPClause = D1 ('MetaData "IPClause" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "IPClause" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ipcQName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Just "ipcClauseNo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Just "ipcType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :*: ((S1 ('MetaSel ('Just "ipcWithSub") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Substitution)) :*: S1 ('MetaSel ('Just "ipcClause") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SpineClause)) :*: (S1 ('MetaSel ('Just "ipcClosure") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure ())) :*: S1 ('MetaSel ('Just "ipcBoundary") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Closure IPBoundary])))) :+: C1 ('MetaCons "IPNoClause" 'PrefixI 'False) (U1 :: Type -> Type))

type IPBoundary = IPBoundary' Term Source #

data IPBoundary' t Source #

Datatype representing a single boundary condition: x_0 = u_0, ... ,x_n = u_n ⊢ t = ?n es

Constructors

IPBoundary |

Fields

- ipbEquations :: [(t, t)]
  x_0 = u_0, ... ,x_n = u_n
- ipbValue :: t

      t

- ipbMetaApp :: t

      ?n es

- ipbOverapplied :: Overapplied

  Is `?n` overapplied in `?n es` ?

#### Instances

Instances details

Foldable IPBoundary' Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

fold :: Monoid m => IPBoundary' m -> m Source #

foldMap :: Monoid m => (a -> m) -> IPBoundary' a -> m Source #

foldMap' :: Monoid m => (a -> m) -> IPBoundary' a -> m Source #

foldr :: (a -> b -> b) -> b -> IPBoundary' a -> b Source #

foldr' :: (a -> b -> b) -> b -> IPBoundary' a -> b Source #

foldl :: (b -> a -> b) -> b -> IPBoundary' a -> b Source #

foldl' :: (b -> a -> b) -> b -> IPBoundary' a -> b Source #

foldr1 :: (a -> a -> a) -> IPBoundary' a -> a Source #

foldl1 :: (a -> a -> a) -> IPBoundary' a -> a Source #

toList :: IPBoundary' a -> [a] Source #

null :: IPBoundary' a -> Bool Source #

length :: IPBoundary' a -> Int Source #

elem :: Eq a => a -> IPBoundary' a -> Bool Source #

maximum :: Ord a => IPBoundary' a -> a Source #

minimum :: Ord a => IPBoundary' a -> a Source #

sum :: Num a => IPBoundary' a -> a Source #

product :: Num a => IPBoundary' a -> a Source #

Traversable IPBoundary' Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods traverse :: Applicative f => (a -> f b) -> IPBoundary' a -> f (IPBoundary' b) Source # sequenceA :: Applicative f => IPBoundary' (f a) -> f (IPBoundary' a) Source # mapM :: Monad m => (a -> m b) -> IPBoundary' a -> m (IPBoundary' b) Source # sequence :: Monad m => IPBoundary' (m a) -> m (IPBoundary' a) Source #
Functor IPBoundary' Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> IPBoundary' a -> IPBoundary' b Source # (<$) :: a -> IPBoundary' b -> IPBoundary' a Source #
ToConcrete a => ToConcrete (IPBoundary' a) Source # |
Instance details Defined in Agda.Interaction.BasicOps Associated Types type ConOfAbs (IPBoundary' a) Source # Methods toConcrete :: IPBoundary' a -> AbsToCon (ConOfAbs (IPBoundary' a)) Source # bindToConcrete :: IPBoundary' a -> (ConOfAbs (IPBoundary' a) -> AbsToCon b) -> AbsToCon b Source #
Reify a => Reify (IPBoundary' a) Source # |
Instance details Defined in Agda.Interaction.BasicOps Associated Types type ReifiesTo (IPBoundary' a) Source # Methods reify :: MonadReify m => IPBoundary' a -> m (ReifiesTo (IPBoundary' a)) Source # reifyWhen :: MonadReify m => Bool -> IPBoundary' a -> m (ReifiesTo (IPBoundary' a)) Source #
Instantiate t => Instantiate (IPBoundary' t) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiate' :: IPBoundary' t -> ReduceM (IPBoundary' t) Source #
InstantiateFull t => InstantiateFull (IPBoundary' t) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: IPBoundary' t -> ReduceM (IPBoundary' t) Source #
Normalise t => Normalise (IPBoundary' t) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods normalise' :: IPBoundary' t -> ReduceM (IPBoundary' t) Source #
Reduce t => Reduce (IPBoundary' t) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods reduce' :: IPBoundary' t -> ReduceM (IPBoundary' t) Source # reduceB' :: IPBoundary' t -> ReduceM (Blocked (IPBoundary' t)) Source #
Simplify t => Simplify (IPBoundary' t) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods simplify' :: IPBoundary' t -> ReduceM (IPBoundary' t) Source #
Pretty c => Pretty (IPBoundary' c) Source # |
Instance details Defined in Agda.Interaction.BasicOps Methods pretty :: IPBoundary' c -> Doc Source # prettyPrec :: Int -> IPBoundary' c -> Doc Source # prettyList :: [IPBoundary' c] -> Doc Source #
Data t => Data (IPBoundary' t) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPBoundary' t -> c (IPBoundary' t) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IPBoundary' t) Source #

toConstr :: IPBoundary' t -> Constr Source #

dataTypeOf :: IPBoundary' t -> DataType Source #

dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (IPBoundary' t)) Source #

dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (IPBoundary' t)) Source #

gmapT :: (forall b. Data b => b -> b) -> IPBoundary' t -> IPBoundary' t Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPBoundary' t -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> IPBoundary' t -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IPBoundary' t -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPBoundary' t -> m (IPBoundary' t) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBoundary' t -> m (IPBoundary' t) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBoundary' t -> m (IPBoundary' t) Source #

Generic (IPBoundary' t) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep (IPBoundary' t) :: Type -> Type Source # Methods from :: IPBoundary' t -> Rep (IPBoundary' t) x Source # to :: Rep (IPBoundary' t) x -> IPBoundary' t Source #
Show t => Show (IPBoundary' t) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> IPBoundary' t -> ShowS Source # show :: IPBoundary' t -> String Source # showList :: [IPBoundary' t] -> ShowS Source #
NFData t => NFData (IPBoundary' t) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: IPBoundary' t -> () Source #
type ConOfAbs (IPBoundary' a) Source # |
Instance details Defined in Agda.Interaction.BasicOps type ConOfAbs (IPBoundary' a) = IPBoundary' (ConOfAbs a)
type ReifiesTo (IPBoundary' a) Source # |
Instance details Defined in Agda.Interaction.BasicOps type ReifiesTo (IPBoundary' a) = IPBoundary' (ReifiesTo a)
type Rep (IPBoundary' t) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep (IPBoundary' t) = D1 ('MetaData "IPBoundary'" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "IPBoundary" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ipbEquations") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(t, t)]) :*: S1 ('MetaSel ('Just "ipbValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 t)) :*: (S1 ('MetaSel ('Just "ipbMetaApp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 t) :*: S1 ('MetaSel ('Just "ipbOverapplied") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Overapplied))))

data Overapplied Source #

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).

Constructors

Overapplied |
NotOverapplied |

#### Instances

Instances details

Data Overapplied Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overapplied -> c Overapplied Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overapplied Source #

toConstr :: Overapplied -> Constr Source #

dataTypeOf :: Overapplied -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overapplied) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overapplied) Source #

gmapT :: (forall b. Data b => b -> b) -> Overapplied -> Overapplied Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overapplied -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overapplied -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Overapplied -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overapplied -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overapplied -> m Overapplied Source #

Generic Overapplied Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Overapplied :: Type -> Type Source # Methods from :: Overapplied -> Rep Overapplied x Source # to :: Rep Overapplied x -> Overapplied Source #
Show Overapplied Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Overapplied -> ShowS Source # show :: Overapplied -> String Source # showList :: [Overapplied] -> ShowS Source #
NFData Overapplied Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Overapplied -> () Source #
Eq Overapplied Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: Overapplied -> Overapplied -> Bool Source # (/=) :: Overapplied -> Overapplied -> Bool Source #
type Rep Overapplied Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep Overapplied = D1 ('MetaData "Overapplied" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Overapplied" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NotOverapplied" 'PrefixI 'False) (U1 :: Type -> Type))

type InteractionPoints = BiMap InteractionId InteractionPoint Source #

Data structure managing the interaction points.

We never remove interaction points from this map, only set their `ipSolved` to `True`. (Issue #2368)

data InteractionPoint Source #

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.

Constructors

InteractionPoint |

Fields

- ipRange :: Range

  The position of the interaction point.

- ipMeta :: Maybe MetaId

  The meta variable, if any, holding the type etc.

- ipSolved :: Bool

  Has this interaction point already been solved?

- ipClause :: IPClause

  The clause of the interaction point (if any). Used for case splitting.

#### Instances

Instances details

HasTag InteractionPoint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Tag InteractionPoint Source # Methods tag :: InteractionPoint -> Maybe (Tag InteractionPoint) Source #
Generic InteractionPoint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep InteractionPoint :: Type -> Type Source # Methods from :: InteractionPoint -> Rep InteractionPoint x Source # to :: Rep InteractionPoint x -> InteractionPoint Source #
NFData InteractionPoint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: InteractionPoint -> () Source #
NFData InteractionPoints Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: InteractionPoints -> () Source #
Eq InteractionPoint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: InteractionPoint -> InteractionPoint -> Bool Source # (/=) :: InteractionPoint -> InteractionPoint -> Bool Source #
type Tag InteractionPoint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Tag InteractionPoint = MetaId
type Rep InteractionPoint Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep InteractionPoint = D1 ('MetaData "InteractionPoint" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "InteractionPoint" 'PrefixI 'True) ((S1 ('MetaSel ('Just "ipRange") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Just "ipMeta") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe MetaId))) :*: (S1 ('MetaSel ('Just "ipSolved") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "ipClause") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IPClause))))

type MetaStore = IntMap MetaVariable Source #

type MetaNameSuggestion = String Source #

Name suggestion for meta variable. Empty string means no suggestion.

data MetaInfo Source #

`MetaInfo` is cloned from one meta to the next during pruning.

Constructors

MetaInfo |

Fields

- miClosRange :: Closure Range
- miModality :: Modality

  Instantiable with irrelevant/erased solution?

- miMetaOccursCheck :: RunMetaOccursCheck

  Run the extended occurs check that goes in definitions?

- miNameSuggestion :: MetaNameSuggestion

  Used for printing. `Just x` if meta-variable comes from omitted argument with name `x`.

- miGeneralizable :: Arg DoGeneralize

  Should this meta be generalized if unsolved? If so, at what ArgInfo?

#### Instances

Instances details

LensIsAbstract MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensIsAbstract :: Lens' IsAbstract MetaInfo Source #
LensModality MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getModality :: MetaInfo -> Modality Source # setModality :: Modality -> MetaInfo -> MetaInfo Source # mapModality :: (Modality -> Modality) -> MetaInfo -> MetaInfo Source #
LensQuantity MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getQuantity :: MetaInfo -> Quantity Source # setQuantity :: Quantity -> MetaInfo -> MetaInfo Source # mapQuantity :: (Quantity -> Quantity) -> MetaInfo -> MetaInfo Source #
HasRange MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: MetaInfo -> Range Source #
SetRange MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods setRange :: Range -> MetaInfo -> MetaInfo Source #
Generic MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep MetaInfo :: Type -> Type Source # Methods from :: MetaInfo -> Rep MetaInfo x Source # to :: Rep MetaInfo x -> MetaInfo Source #
NFData MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: MetaInfo -> () Source #
LensClosure Range MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensClosure :: Lens' (Closure Range) MetaInfo Source #
type Rep MetaInfo Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep MetaInfo = D1 ('MetaData "MetaInfo" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "MetaInfo" 'PrefixI 'True) ((S1 ('MetaSel ('Just "miClosRange") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure Range)) :*: S1 ('MetaSel ('Just "miModality") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Modality)) :*: (S1 ('MetaSel ('Just "miMetaOccursCheck") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RunMetaOccursCheck) :*: (S1 ('MetaSel ('Just "miNameSuggestion") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaNameSuggestion) :*: S1 ('MetaSel ('Just "miGeneralizable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg DoGeneralize))))))

data RunMetaOccursCheck Source #

Constructors

RunMetaOccursCheck |
DontRunMetaOccursCheck |

#### Instances

Instances details

Generic RunMetaOccursCheck Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep RunMetaOccursCheck :: Type -> Type Source # Methods from :: RunMetaOccursCheck -> Rep RunMetaOccursCheck x Source # to :: Rep RunMetaOccursCheck x -> RunMetaOccursCheck Source #
Show RunMetaOccursCheck Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> RunMetaOccursCheck -> ShowS Source # show :: RunMetaOccursCheck -> String Source # showList :: [RunMetaOccursCheck] -> ShowS Source #
NFData RunMetaOccursCheck Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: RunMetaOccursCheck -> () Source #
Eq RunMetaOccursCheck Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool Source # (/=) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool Source #
Ord RunMetaOccursCheck Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: RunMetaOccursCheck -> RunMetaOccursCheck -> Ordering Source #

(<) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool Source #

(<=) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool Source #

(>) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool Source #

(>=) :: RunMetaOccursCheck -> RunMetaOccursCheck -> Bool Source #

max :: RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck Source #

min :: RunMetaOccursCheck -> RunMetaOccursCheck -> RunMetaOccursCheck Source #

type Rep RunMetaOccursCheck Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep RunMetaOccursCheck = D1 ('MetaData "RunMetaOccursCheck" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "RunMetaOccursCheck" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DontRunMetaOccursCheck" 'PrefixI 'False) (U1 :: Type -> Type))

newtype MetaPriority Source #

Meta variable priority: When we have an equation between meta-variables, which one should be instantiated?

Higher value means higher priority to be instantiated.

Constructors

MetaPriority Int |

#### Instances

Instances details

Show MetaPriority Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> MetaPriority -> ShowS Source # show :: MetaPriority -> String Source # showList :: [MetaPriority] -> ShowS Source #
NFData MetaPriority Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: MetaPriority -> () Source #
Eq MetaPriority Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: MetaPriority -> MetaPriority -> Bool Source # (/=) :: MetaPriority -> MetaPriority -> Bool Source #
Ord MetaPriority Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: MetaPriority -> MetaPriority -> Ordering Source #

(<) :: MetaPriority -> MetaPriority -> Bool Source #

(<=) :: MetaPriority -> MetaPriority -> Bool Source #

(>) :: MetaPriority -> MetaPriority -> Bool Source #

(>=) :: MetaPriority -> MetaPriority -> Bool Source #

max :: MetaPriority -> MetaPriority -> MetaPriority Source #

min :: MetaPriority -> MetaPriority -> MetaPriority Source #

data TypeCheckingProblem Source #

Constructors

CheckExpr Comparison Expr Type |
CheckArgs Comparison ExpandHidden Range [NamedArg Expr] Type Type (ArgsCheckState CheckedTarget -> TCM Term) |
CheckProjAppToKnownPrincipalArg Comparison Expr ProjOrigin (List1 QName) Args Type Int Term Type PrincipalArgTypeMetas |
CheckLambda Comparison (Arg (List1 (WithHiding Name), Maybe Type)) 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 `Expr`.
DoQuoteTerm Comparison Term Type | Quote the given term and check type against `Term`

#### Instances

Instances details

PrettyTCM TypeCheckingProblem Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => TypeCheckingProblem -> m Doc Source #
Generic TypeCheckingProblem Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep TypeCheckingProblem :: Type -> Type Source # Methods from :: TypeCheckingProblem -> Rep TypeCheckingProblem x Source # to :: Rep TypeCheckingProblem x -> TypeCheckingProblem Source #
NFData TypeCheckingProblem Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TypeCheckingProblem -> () Source #
type Rep TypeCheckingProblem Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep TypeCheckingProblem = D1 ('MetaData "TypeCheckingProblem" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "CheckExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "CheckArgs" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ExpandHidden) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range))) :*: ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [NamedArg Expr]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (ArgsCheckState CheckedTarget -> TCM Term)))))) :+: (C1 ('MetaCons "CheckProjAppToKnownPrincipalArg" 'PrefixI 'False) (((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ProjOrigin) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (List1 QName)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Args)))) :*: ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PrincipalArgTypeMetas))))) :+: (C1 ('MetaCons "CheckLambda" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg (List1 (WithHiding Name), Maybe Type)))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Expr) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "DoQuoteTerm" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))))

data PrincipalArgTypeMetas Source #

Constructors

PrincipalArgTypeMetas |

Fields

- patmMetas :: Args

  metas created for hidden and instance arguments in the principal argument's type

- patmRemainder :: Type

  principal argument's type, stripped of hidden and instance arguments

#### Instances

Instances details

Generic PrincipalArgTypeMetas Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep PrincipalArgTypeMetas :: Type -> Type Source # Methods from :: PrincipalArgTypeMetas -> Rep PrincipalArgTypeMetas x Source # to :: Rep PrincipalArgTypeMetas x -> PrincipalArgTypeMetas Source #
NFData PrincipalArgTypeMetas Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: PrincipalArgTypeMetas -> () Source #
type Rep PrincipalArgTypeMetas Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep PrincipalArgTypeMetas = D1 ('MetaData "PrincipalArgTypeMetas" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "PrincipalArgTypeMetas" 'PrefixI 'True) (S1 ('MetaSel ('Just "patmMetas") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Args) :*: S1 ('MetaSel ('Just "patmRemainder") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))

data CheckedTarget Source #

Solving a `CheckArgs` constraint may or may not check the target type. If it did, it returns a handle to any unsolved constraints.

Constructors

CheckedTarget (Maybe ProblemId) |
NotCheckedTarget |

data MetaInstantiation Source #

Constructors

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) |

#### Instances

Instances details

Generic MetaInstantiation Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep MetaInstantiation :: Type -> Type Source # Methods from :: MetaInstantiation -> Rep MetaInstantiation x Source # to :: Rep MetaInstantiation x -> MetaInstantiation Source #
Show MetaInstantiation Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> MetaInstantiation -> ShowS Source # show :: MetaInstantiation -> String Source # showList :: [MetaInstantiation] -> ShowS Source #
NFData MetaInstantiation Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: MetaInstantiation -> () Source #
type Rep MetaInstantiation Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep MetaInstantiation = D1 ('MetaData "MetaInstantiation" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "InstV" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Arg String]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :+: C1 ('MetaCons "Open" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "OpenInstance" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "BlockedConst" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :+: C1 ('MetaCons "PostponedTypeCheckingProblem" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure TypeCheckingProblem))))))

data Frozen Source #

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).

Constructors

Frozen | Do not instantiate.
Instantiable |

#### Instances

Instances details

Generic Frozen Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Frozen :: Type -> Type Source # Methods from :: Frozen -> Rep Frozen x Source # to :: Rep Frozen x -> Frozen Source #
Show Frozen Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Frozen -> ShowS Source # show :: Frozen -> String Source # showList :: [Frozen] -> ShowS Source #
NFData Frozen Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Frozen -> () Source #
Eq Frozen Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: Frozen -> Frozen -> Bool Source # (/=) :: Frozen -> Frozen -> Bool Source #
type Rep Frozen Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep Frozen = D1 ('MetaData "Frozen" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Frozen" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Instantiable" 'PrefixI 'False) (U1 :: Type -> Type))

data Listener Source #

Constructors

EtaExpand MetaId |
CheckConstraint Nat ProblemConstraint |

#### Instances

Instances details

Generic Listener Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Listener :: Type -> Type Source # Methods from :: Listener -> Rep Listener x Source # to :: Rep Listener x -> Listener Source #
NFData Listener Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Listener -> () Source #
Eq Listener Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: Listener -> Listener -> Bool Source # (/=) :: Listener -> Listener -> Bool Source #
Ord Listener Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods compare :: Listener -> Listener -> Ordering Source # (<) :: Listener -> Listener -> Bool Source # (<=) :: Listener -> Listener -> Bool Source # (>) :: Listener -> Listener -> Bool Source # (>=) :: Listener -> Listener -> Bool Source # max :: Listener -> Listener -> Listener Source # min :: Listener -> Listener -> Listener Source #
type Rep Listener Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Listener = D1 ('MetaData "Listener" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "EtaExpand" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId)) :+: C1 ('MetaCons "CheckConstraint" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nat) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ProblemConstraint)))

data MetaVariable Source #

Constructors

MetaVar |

Fields

- mvInfo :: MetaInfo
- mvPriority :: MetaPriority

  some metavariables are more eager to be instantiated

- 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

- mvJudgement :: Judgement MetaId
- mvInstantiation :: MetaInstantiation
- mvListeners :: Set Listener

  meta variables scheduled for eta-expansion but blocked by this one

- mvFrozen :: Frozen

  are we past the point where we can instantiate this meta variable?

- mvTwin :: Maybe MetaId

  `Just m` means that this meta-variable will be equated to `m` when the latter is unblocked. See `blockTermOnProblem`.

#### Instances

Instances details

LensModality MetaVariable Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getModality :: MetaVariable -> Modality Source # setModality :: Modality -> MetaVariable -> MetaVariable Source # mapModality :: (Modality -> Modality) -> MetaVariable -> MetaVariable Source #
LensQuantity MetaVariable Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getQuantity :: MetaVariable -> Quantity Source # setQuantity :: Quantity -> MetaVariable -> MetaVariable Source # mapQuantity :: (Quantity -> Quantity) -> MetaVariable -> MetaVariable Source #
HasRange MetaVariable Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: MetaVariable -> Range Source #
SetRange MetaVariable Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods setRange :: Range -> MetaVariable -> MetaVariable Source #
Generic MetaVariable Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep MetaVariable :: Type -> Type Source # Methods from :: MetaVariable -> Rep MetaVariable x Source # to :: Rep MetaVariable x -> MetaVariable Source #
NFData MetaVariable Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: MetaVariable -> () Source #
LensClosure Range MetaVariable Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensClosure :: Lens' (Closure Range) MetaVariable Source #
type Rep MetaVariable Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep MetaVariable = D1 ('MetaData "MetaVariable" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "MetaVar" 'PrefixI 'True) (((S1 ('MetaSel ('Just "mvInfo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaInfo) :*: S1 ('MetaSel ('Just "mvPriority") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaPriority)) :*: (S1 ('MetaSel ('Just "mvPermutation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Permutation) :*: S1 ('MetaSel ('Just "mvJudgement") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Judgement MetaId)))) :*: ((S1 ('MetaSel ('Just "mvInstantiation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaInstantiation) :*: S1 ('MetaSel ('Just "mvListeners") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set Listener))) :*: (S1 ('MetaSel ('Just "mvFrozen") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Frozen) :*: S1 ('MetaSel ('Just "mvTwin") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe MetaId))))))

data GeneralizedValue Source #

The value of a generalizable variable. This is created to be a generalizable meta before checking the type to be generalized.

Constructors

GeneralizedValue |

Fields

- genvalCheckpoint :: CheckpointId
- genvalTerm :: Term
- genvalType :: Type

#### Instances

Instances details

Data GeneralizedValue Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GeneralizedValue -> c GeneralizedValue Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GeneralizedValue Source #

toConstr :: GeneralizedValue -> Constr Source #

dataTypeOf :: GeneralizedValue -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GeneralizedValue) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GeneralizedValue) Source #

gmapT :: (forall b. Data b => b -> b) -> GeneralizedValue -> GeneralizedValue Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GeneralizedValue -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> GeneralizedValue -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GeneralizedValue -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GeneralizedValue -> m GeneralizedValue Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GeneralizedValue -> m GeneralizedValue Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GeneralizedValue -> m GeneralizedValue Source #

Generic GeneralizedValue Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep GeneralizedValue :: Type -> Type Source # Methods from :: GeneralizedValue -> Rep GeneralizedValue x Source # to :: Rep GeneralizedValue x -> GeneralizedValue Source #
Show GeneralizedValue Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> GeneralizedValue -> ShowS Source # show :: GeneralizedValue -> String Source # showList :: [GeneralizedValue] -> ShowS Source #
NFData GeneralizedValue Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: GeneralizedValue -> () Source #
type Rep GeneralizedValue Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep GeneralizedValue = D1 ('MetaData "GeneralizedValue" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "GeneralizedValue" 'PrefixI 'True) (S1 ('MetaSel ('Just "genvalCheckpoint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CheckpointId) :*: (S1 ('MetaSel ('Just "genvalTerm") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Just "genvalType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))))

data DoGeneralize Source #

Constructors

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.

#### Instances

Instances details

KillRange DoGeneralize Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT DoGeneralize Source #
EmbPrj DoGeneralize Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: DoGeneralize -> S Int32 Source # icod_ :: DoGeneralize -> S Int32 Source # value :: Int32 -> R DoGeneralize Source #
Data DoGeneralize Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DoGeneralize -> c DoGeneralize Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DoGeneralize Source #

toConstr :: DoGeneralize -> Constr Source #

dataTypeOf :: DoGeneralize -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DoGeneralize) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DoGeneralize) Source #

gmapT :: (forall b. Data b => b -> b) -> DoGeneralize -> DoGeneralize Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DoGeneralize -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> DoGeneralize -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DoGeneralize -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DoGeneralize -> m DoGeneralize Source #

Generic DoGeneralize Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep DoGeneralize :: Type -> Type Source # Methods from :: DoGeneralize -> Rep DoGeneralize x Source # to :: Rep DoGeneralize x -> DoGeneralize Source #
Show DoGeneralize Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> DoGeneralize -> ShowS Source # show :: DoGeneralize -> String Source # showList :: [DoGeneralize] -> ShowS Source #
NFData DoGeneralize Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: DoGeneralize -> () Source #
Eq DoGeneralize Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: DoGeneralize -> DoGeneralize -> Bool Source # (/=) :: DoGeneralize -> DoGeneralize -> Bool Source #
Ord DoGeneralize Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: DoGeneralize -> DoGeneralize -> Ordering Source #

(<) :: DoGeneralize -> DoGeneralize -> Bool Source #

(<=) :: DoGeneralize -> DoGeneralize -> Bool Source #

(>) :: DoGeneralize -> DoGeneralize -> Bool Source #

(>=) :: DoGeneralize -> DoGeneralize -> Bool Source #

max :: DoGeneralize -> DoGeneralize -> DoGeneralize Source #

min :: DoGeneralize -> DoGeneralize -> DoGeneralize Source #

type Rep DoGeneralize Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep DoGeneralize = D1 ('MetaData "DoGeneralize" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "YesGeneralizeVar" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "YesGeneralizeMeta" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NoGeneralize" 'PrefixI 'False) (U1 :: Type -> Type)))

data Judgement a Source #

Parametrized since it is used without MetaId when creating a new meta.

Constructors

HasType |

Fields

- jMetaId :: a
- jComparison :: Comparison

  are we checking (`CmpLeq`) or inferring (`CmpEq`) the type?

- jMetaType :: Type

IsSort |

Fields

- jMetaId :: a
- jMetaType :: Type

#### Instances

Instances details

PrettyTCM a => PrettyTCM (Judgement a) Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => Judgement a -> m Doc Source #
Pretty a => Pretty (Judgement a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Judgement a -> Doc Source # prettyPrec :: Int -> Judgement a -> Doc Source # prettyList :: [Judgement a] -> Doc Source #
Generic (Judgement a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep (Judgement a) :: Type -> Type Source # Methods from :: Judgement a -> Rep (Judgement a) x Source # to :: Rep (Judgement a) x -> Judgement a Source #
NFData a => NFData (Judgement a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Judgement a -> () Source #
type Rep (Judgement a) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep (Judgement a) = D1 ('MetaData "Judgement" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "HasType" 'PrefixI 'True) (S1 ('MetaSel ('Just "jMetaId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: (S1 ('MetaSel ('Just "jComparison") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: S1 ('MetaSel ('Just "jMetaType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "IsSort" 'PrefixI 'True) (S1 ('MetaSel ('Just "jMetaId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "jMetaType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))

data Open a Source #

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.

Constructors

OpenThing |

Fields

- openThingCheckpoint :: CheckpointId
- openThingCheckpointMap :: Map CheckpointId Substitution
- openThingModule :: ModuleNameHash
- openThing :: a

#### Instances

Instances details

Decoration Open Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods traverseF :: Functor m => (a -> m b) -> Open a -> m (Open b) Source # distributeF :: Functor m => Open (m a) -> m (Open a) Source #
Foldable Open Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

fold :: Monoid m => Open m -> m Source #

foldMap :: Monoid m => (a -> m) -> Open a -> m Source #

foldMap' :: Monoid m => (a -> m) -> Open a -> m Source #

foldr :: (a -> b -> b) -> b -> Open a -> b Source #

foldr' :: (a -> b -> b) -> b -> Open a -> b Source #

foldl :: (b -> a -> b) -> b -> Open a -> b Source #

foldl' :: (b -> a -> b) -> b -> Open a -> b Source #

foldr1 :: (a -> a -> a) -> Open a -> a Source #

foldl1 :: (a -> a -> a) -> Open a -> a Source #

toList :: Open a -> [a] Source #

null :: Open a -> Bool Source #

length :: Open a -> Int Source #

elem :: Eq a => a -> Open a -> Bool Source #

maximum :: Ord a => Open a -> a Source #

minimum :: Ord a => Open a -> a Source #

sum :: Num a => Open a -> a Source #

product :: Num a => Open a -> a Source #

Traversable Open Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods traverse :: Applicative f => (a -> f b) -> Open a -> f (Open b) Source # sequenceA :: Applicative f => Open (f a) -> f (Open a) Source # mapM :: Monad m => (a -> m b) -> Open a -> m (Open b) Source # sequence :: Monad m => Open (m a) -> m (Open a) Source #
Functor Open Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> Open a -> Open b Source # (<$) :: a -> Open b -> Open a Source #
NamesIn a => NamesIn (Open a) Source # |
Instance details Defined in Agda.Syntax.Internal.Names Methods namesIn' :: Monoid m => (QName -> m) -> Open a -> m Source #
KillRange a => KillRange (Open a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT (Open a) Source #
InstantiateFull t => InstantiateFull (Open t) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Open t -> ReduceM (Open t) Source #
EmbPrj a => EmbPrj (Open a) Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: Open a -> S Int32 Source # icod_ :: Open a -> S Int32 Source # value :: Int32 -> R (Open a) Source #
Pretty a => Pretty (Open a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Open a -> Doc Source # prettyPrec :: Int -> Open a -> Doc Source # prettyList :: [Open a] -> Doc Source #
Generic (Open a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep (Open a) :: Type -> Type Source # Methods from :: Open a -> Rep (Open a) x Source # to :: Rep (Open a) x -> Open a Source #
Show a => Show (Open a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Open a -> ShowS Source # show :: Open a -> String Source # showList :: [Open a] -> ShowS Source #
NFData a => NFData (Open a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Open a -> () Source #
type Rep (Open a) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep (Open a) = D1 ('MetaData "Open" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "OpenThing" 'PrefixI 'True) ((S1 ('MetaSel ('Just "openThingCheckpoint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CheckpointId) :*: S1 ('MetaSel ('Just "openThingCheckpointMap") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Map CheckpointId Substitution))) :*: (S1 ('MetaSel ('Just "openThingModule") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleNameHash) :*: S1 ('MetaSel ('Just "openThing") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))))

data CompareAs Source #

We can either compare two terms at a given type, or compare two types without knowing (or caring about) their sorts.

Constructors

AsTermsOf Type | `Type` should not be `Size`. But currently, we do not rely on this invariant.
AsSizes | Replaces `AsTermsOf Size`.
AsTypes |

#### Instances

Instances details

TermLike CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods traverseTermM :: Monad m => (Term -> m Term) -> CompareAs -> m CompareAs Source # foldTerm :: Monoid m => (Term -> m) -> CompareAs -> m Source #
AllMetas CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods allMetas :: Monoid m => (MetaId -> m) -> CompareAs -> m Source #
Free CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freeVars' :: IsVarSet a c => CompareAs -> FreeM a c Source #
MentionsMeta CompareAs Source # |
Instance details Defined in Agda.TypeChecking.MetaVars.Mention Methods mentionsMetas :: HashSet MetaId -> CompareAs -> Bool Source #
IsSizeType CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods isSizeType :: (HasOptions m, HasBuiltins m) => CompareAs -> m (Maybe BoundedSize) Source #
PrettyTCM CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => CompareAs -> m Doc Source #
Instantiate CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiate' :: CompareAs -> ReduceM CompareAs Source #
InstantiateFull CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: CompareAs -> ReduceM CompareAs Source #
IsMeta CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods isMeta :: CompareAs -> Maybe MetaId Source #
Normalise CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods normalise' :: CompareAs -> ReduceM CompareAs Source #
Reduce CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods reduce' :: CompareAs -> ReduceM CompareAs Source # reduceB' :: CompareAs -> ReduceM (Blocked CompareAs) Source #
Simplify CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods simplify' :: CompareAs -> ReduceM CompareAs Source #
Subst CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg CompareAs Source # Methods applySubst :: Substitution' (SubstArg CompareAs) -> CompareAs -> CompareAs Source #
Data CompareAs Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompareAs -> c CompareAs Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompareAs Source #

toConstr :: CompareAs -> Constr Source #

dataTypeOf :: CompareAs -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CompareAs) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompareAs) Source #

gmapT :: (forall b. Data b => b -> b) -> CompareAs -> CompareAs Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompareAs -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompareAs -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CompareAs -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CompareAs -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompareAs -> m CompareAs Source #

Generic CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep CompareAs :: Type -> Type Source # Methods from :: CompareAs -> Rep CompareAs x Source # to :: Rep CompareAs x -> CompareAs Source #
Show CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> CompareAs -> ShowS Source # show :: CompareAs -> String Source # showList :: [CompareAs] -> ShowS Source #
NFData CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: CompareAs -> () Source #
type SubstArg CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg CompareAs = Term
type Rep CompareAs Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep CompareAs = D1 ('MetaData "CompareAs" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "AsTermsOf" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: (C1 ('MetaCons "AsSizes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AsTypes" 'PrefixI 'False) (U1 :: Type -> Type)))

data CompareDirection Source #

An extension of `Comparison` to `>=`.

Constructors

DirEq |
DirLeq |
DirGeq |

#### Instances

Instances details

Pretty CompareDirection Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: CompareDirection -> Doc Source # prettyPrec :: Int -> CompareDirection -> Doc Source # prettyList :: [CompareDirection] -> Doc Source #
Show CompareDirection Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> CompareDirection -> ShowS Source # show :: CompareDirection -> String Source # showList :: [CompareDirection] -> ShowS Source #
Eq CompareDirection Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: CompareDirection -> CompareDirection -> Bool Source # (/=) :: CompareDirection -> CompareDirection -> Bool Source #

data Constraint Source #

Constructors

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 |
HasBiggerSort Sort |
HasPTSRule (Dom Type) (Abs Sort) |
CheckMetaInst MetaId |
CheckType Type |
UnBlock MetaId | Meta created for a term blocked by a postponed type checking problem or unsolved constraints. The `MetaInstantiation` for the meta (when unsolved) is either `BlockedConst` or `PostponedTypeCheckingProblem`.
IsEmpty Range Type | The range is the one of the absurd pattern.
CheckSizeLtSat Term | Check that the `Term` is either not a SIZELT or a non-empty SIZELT.
FindInstance MetaId (Maybe [Candidate]) | the first argument is the instance argument and the second one is the list of candidates (or Nothing if we haven’t determined the list of candidates yet)
CheckFunDef Delayed DefInfo QName [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?

#### Instances

Instances details

TermLike Constraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods traverseTermM :: Monad m => (Term -> m Term) -> Constraint -> m Constraint Source # foldTerm :: Monoid m => (Term -> m) -> Constraint -> m Source #
AllMetas Constraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods allMetas :: Monoid m => (MetaId -> m) -> Constraint -> m Source #
HasRange Constraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: Constraint -> Range Source #
Reify Constraint Source # |
Instance details Defined in Agda.Interaction.BasicOps Associated Types type ReifiesTo Constraint Source # Methods reify :: MonadReify m => Constraint -> m (ReifiesTo Constraint) Source # reifyWhen :: MonadReify m => Bool -> Constraint -> m (ReifiesTo Constraint) Source #
Free Constraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freeVars' :: IsVarSet a c => Constraint -> FreeM a c Source #
MentionsMeta Constraint Source # |
Instance details Defined in Agda.TypeChecking.MetaVars.Mention Methods mentionsMetas :: HashSet MetaId -> Constraint -> Bool Source #
PrettyTCM Constraint Source # |
Instance details Defined in Agda.TypeChecking.Pretty.Constraint Methods prettyTCM :: MonadPretty m => Constraint -> m Doc Source #
Instantiate Constraint Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiate' :: Constraint -> ReduceM Constraint Source #
InstantiateFull Constraint Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Constraint -> ReduceM Constraint Source #
Normalise Constraint Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods normalise' :: Constraint -> ReduceM Constraint Source #
Reduce Constraint Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods reduce' :: Constraint -> ReduceM Constraint Source # reduceB' :: Constraint -> ReduceM (Blocked Constraint) Source #
Simplify Constraint Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods simplify' :: Constraint -> ReduceM Constraint Source #
Subst Constraint Source # |
Instance details Defined in Agda.TypeChecking.Substitute Associated Types type SubstArg Constraint Source # Methods applySubst :: Substitution' (SubstArg Constraint) -> Constraint -> Constraint Source #
Generic Constraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Constraint :: Type -> Type Source # Methods from :: Constraint -> Rep Constraint x Source # to :: Rep Constraint x -> Constraint Source #
Show Constraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Constraint -> ShowS Source # show :: Constraint -> String Source # showList :: [Constraint] -> ShowS Source #
NFData Constraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Constraint -> () Source #
type ReifiesTo Constraint Source # |
Instance details Defined in Agda.Interaction.BasicOps type ReifiesTo Constraint = OutputConstraint Expr Expr
type SubstArg Constraint Source # |
Instance details Defined in Agda.TypeChecking.Substitute type SubstArg Constraint = Term
type Rep Constraint Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Constraint = D1 ('MetaData "Constraint" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((((C1 ('MetaCons "ValueCmp" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CompareAs)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))) :+: C1 ('MetaCons "ValueCmpOnFace" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term))))) :+: (C1 ('MetaCons "ElimCmp" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Polarity]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [IsForced]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Elim]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Elim])))) :+: C1 ('MetaCons "SortCmp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort))))) :+: ((C1 ('MetaCons "LevelCmp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Comparison) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Level) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Level))) :+: C1 ('MetaCons "HasBiggerSort" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Sort))) :+: (C1 ('MetaCons "HasPTSRule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Dom Type)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Abs Sort))) :+: C1 ('MetaCons "CheckMetaInst" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId))))) :+: (((C1 ('MetaCons "CheckType" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "UnBlock" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId))) :+: (C1 ('MetaCons "IsEmpty" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "CheckSizeLtSat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)))) :+: ((C1 ('MetaCons "FindInstance" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MetaId) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [Candidate]))) :+: C1 ('MetaCons "CheckFunDef" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Delayed) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DefInfo)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TCErr))))) :+: (C1 ('MetaCons "UnquoteTactic" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: (C1 ('MetaCons "CheckLockedVars" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Arg Term)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: C1 ('MetaCons "UsableAtModality" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Modality) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Term)))))))

data ProblemConstraint Source #

Constructors

PConstr |

Fields

- constraintProblems :: Set ProblemId
- constraintUnblocker :: Blocker
- theConstraint :: Closure Constraint

#### Instances

Instances details

HasRange ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: ProblemConstraint -> Range Source #
Reify ProblemConstraint Source # |
Instance details Defined in Agda.Interaction.BasicOps Associated Types type ReifiesTo ProblemConstraint Source # Methods reify :: MonadReify m => ProblemConstraint -> m (ReifiesTo ProblemConstraint) Source # reifyWhen :: MonadReify m => Bool -> ProblemConstraint -> m (ReifiesTo ProblemConstraint) Source #
MentionsMeta ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.MetaVars.Mention Methods mentionsMetas :: HashSet MetaId -> ProblemConstraint -> Bool Source #
PrettyTCM ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.Pretty.Constraint Methods prettyTCM :: MonadPretty m => ProblemConstraint -> m Doc Source #
InstantiateFull ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: ProblemConstraint -> ReduceM ProblemConstraint Source #
Normalise ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods normalise' :: ProblemConstraint -> ReduceM ProblemConstraint Source #
Simplify ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods simplify' :: ProblemConstraint -> ReduceM ProblemConstraint Source #
Generic ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep ProblemConstraint :: Type -> Type Source # Methods from :: ProblemConstraint -> Rep ProblemConstraint x Source # to :: Rep ProblemConstraint x -> ProblemConstraint Source #
Show ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> ProblemConstraint -> ShowS Source # show :: ProblemConstraint -> String Source # showList :: [ProblemConstraint] -> ShowS Source #
NFData ProblemConstraint Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: ProblemConstraint -> () Source #
type ReifiesTo ProblemConstraint Source # |
Instance details Defined in Agda.Interaction.BasicOps type ReifiesTo ProblemConstraint = Closure (OutputForm Expr Expr)
type Rep ProblemConstraint Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep ProblemConstraint = D1 ('MetaData "ProblemConstraint" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "PConstr" 'PrefixI 'True) (S1 ('MetaSel ('Just "constraintProblems") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set ProblemId)) :*: (S1 ('MetaSel ('Just "constraintUnblocker") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Blocker) :*: S1 ('MetaSel ('Just "theConstraint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Closure Constraint)))))

type Constraints = [ProblemConstraint] Source #

class LensClosure a b | b -> a where Source #

Methods

lensClosure :: Lens' (Closure a) b Source #

#### Instances

Instances details

LensClosure Range MetaInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensClosure :: Lens' (Closure Range) MetaInfo Source #
LensClosure Range MetaVariable Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensClosure :: Lens' (Closure Range) MetaVariable Source #
LensClosure a (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensClosure :: Lens' (Closure a) (Closure a) Source #

data Closure a Source #

Constructors

Closure |

Fields

- clSignature :: Signature
- clEnv :: TCEnv
- clScope :: ScopeInfo
- clModuleCheckpoints :: Map ModuleName CheckpointId
- clValue :: a

#### Instances

Instances details

Foldable Closure Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

fold :: Monoid m => Closure m -> m Source #

foldMap :: Monoid m => (a -> m) -> Closure a -> m Source #

foldMap' :: Monoid m => (a -> m) -> Closure a -> m Source #

foldr :: (a -> b -> b) -> b -> Closure a -> b Source #

foldr' :: (a -> b -> b) -> b -> Closure a -> b Source #

foldl :: (b -> a -> b) -> b -> Closure a -> b Source #

foldl' :: (b -> a -> b) -> b -> Closure a -> b Source #

foldr1 :: (a -> a -> a) -> Closure a -> a Source #

foldl1 :: (a -> a -> a) -> Closure a -> a Source #

toList :: Closure a -> [a] Source #

null :: Closure a -> Bool Source #

length :: Closure a -> Int Source #

elem :: Eq a => a -> Closure a -> Bool Source #

maximum :: Ord a => Closure a -> a Source #

minimum :: Ord a => Closure a -> a Source #

sum :: Num a => Closure a -> a Source #

product :: Num a => Closure a -> a Source #

Functor Closure Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fmap :: (a -> b) -> Closure a -> Closure b Source # (<$) :: a -> Closure b -> Closure a Source #
LensClosure a (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensClosure :: Lens' (Closure a) (Closure a) Source #
LensIsAbstract (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensIsAbstract :: Lens' IsAbstract (Closure a) Source #
HasRange a => HasRange (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getRange :: Closure a -> Range Source #
KillRange a => KillRange (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods killRange :: KillRangeT (Closure a) Source #
MentionsMeta a => MentionsMeta (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.MetaVars.Mention Methods mentionsMetas :: HashSet MetaId -> Closure a -> Bool Source #
LensTCEnv (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods lensTCEnv :: Lens' TCEnv (Closure a) Source #
PrettyTCM a => PrettyTCM (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => Closure a -> m Doc Source #
Instantiate a => Instantiate (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiate' :: Closure a -> ReduceM (Closure a) Source #
InstantiateFull a => InstantiateFull (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Closure a -> ReduceM (Closure a) Source #
Normalise a => Normalise (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods normalise' :: Closure a -> ReduceM (Closure a) Source #
Reduce a => Reduce (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods reduce' :: Closure a -> ReduceM (Closure a) Source # reduceB' :: Closure a -> ReduceM (Blocked (Closure a)) Source #
Simplify a => Simplify (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods simplify' :: Closure a -> ReduceM (Closure a) Source #
Generic (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep (Closure a) :: Type -> Type Source # Methods from :: Closure a -> Rep (Closure a) x Source # to :: Rep (Closure a) x -> Closure a Source #
Show a => Show (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Closure a -> ShowS Source # show :: Closure a -> String Source # showList :: [Closure a] -> ShowS Source #
NFData a => NFData (Closure a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Closure a -> () Source #
type Rep (Closure a) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep (Closure a) = D1 ('MetaData "Closure" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Closure" 'PrefixI 'True) ((S1 ('MetaSel ('Just "clSignature") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Signature) :*: S1 ('MetaSel ('Just "clEnv") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TCEnv)) :*: (S1 ('MetaSel ('Just "clScope") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ScopeInfo) :*: (S1 ('MetaSel ('Just "clModuleCheckpoints") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Map ModuleName CheckpointId)) :*: S1 ('MetaSel ('Just "clValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))))

data Interface Source #

Constructors

Interface |

Fields

- iSourceHash :: Hash

  Hash of the source code.

- iSource :: 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.

- iFileType :: FileType

  Source file type, determined from the file extension

- iImportedModules :: [(ModuleName, Hash)]

  Imported modules and their hashes.

- iModuleName :: ModuleName

  Module name of this interface.

- 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`.

- iInsideScope :: ScopeInfo

  Scope after we loaded this interface. Used in `AtTopLevel` and `interactionLoop`.

- iSignature :: Signature
- iDisplayForms :: DisplayForms

  Display forms added for imported identifiers.

- iUserWarnings :: Map QName Text

  User warnings for imported identifiers

- iImportWarning :: Maybe Text

  Whether this module should raise a warning when imported

- iBuiltin :: BuiltinThings (String, QName)
- iForeignCode :: Map BackendName [ForeignCode]
- iHighlighting :: HighlightingInfo
- iDefaultPragmaOptions :: [OptionsPragma]

  Pragma options set in library files.

- iFilePragmaOptions :: [OptionsPragma]

  Pragma options set in the file.

- iOptionsUsed :: PragmaOptions

  Options/features used when checking the file (can be different from options set directly in the file).

- iPatternSyns :: PatternSynDefns
- iWarnings :: [TCWarning]
- iPartialDefs :: Set QName

#### Instances

Instances details

InstantiateFull Interface Source # |
Instance details Defined in Agda.TypeChecking.Reduce Methods instantiateFull' :: Interface -> ReduceM Interface Source #
EmbPrj Interface Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances Methods icode :: Interface -> S Int32 Source # icod_ :: Interface -> S Int32 Source # value :: Int32 -> R Interface Source #
Pretty Interface Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: Interface -> Doc Source # prettyPrec :: Int -> Interface -> Doc Source # prettyList :: [Interface] -> Doc Source #
Generic Interface Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep Interface :: Type -> Type Source # Methods from :: Interface -> Rep Interface x Source # to :: Rep Interface x -> Interface Source #
Show Interface Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> Interface -> ShowS Source # show :: Interface -> String Source # showList :: [Interface] -> ShowS Source #
NFData Interface Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: Interface -> () Source #
type Rep Interface Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep Interface = D1 ('MetaData "Interface" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "Interface" 'PrefixI 'True) ((((S1 ('MetaSel ('Just "iSourceHash") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Hash) :*: S1 ('MetaSel ('Just "iSource") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)) :*: (S1 ('MetaSel ('Just "iFileType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FileType) :*: (S1 ('MetaSel ('Just "iImportedModules") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(ModuleName, Hash)]) :*: S1 ('MetaSel ('Just "iModuleName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleName)))) :*: ((S1 ('MetaSel ('Just "iScope") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Map ModuleName Scope)) :*: S1 ('MetaSel ('Just "iInsideScope") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ScopeInfo)) :*: (S1 ('MetaSel ('Just "iSignature") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Signature) :*: (S1 ('MetaSel ('Just "iDisplayForms") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DisplayForms) :*: S1 ('MetaSel ('Just "iUserWarnings") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Map QName Text)))))) :*: (((S1 ('MetaSel ('Just "iImportWarning") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Text)) :*: S1 ('MetaSel ('Just "iBuiltin") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (BuiltinThings (String, QName)))) :*: (S1 ('MetaSel ('Just "iForeignCode") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Map BackendName [ForeignCode])) :*: (S1 ('MetaSel ('Just "iHighlighting") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HighlightingInfo) :*: S1 ('MetaSel ('Just "iDefaultPragmaOptions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [OptionsPragma])))) :*: ((S1 ('MetaSel ('Just "iFilePragmaOptions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [OptionsPragma]) :*: S1 ('MetaSel ('Just "iOptionsUsed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PragmaOptions)) :*: (S1 ('MetaSel ('Just "iPatternSyns") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PatternSynDefns) :*: (S1 ('MetaSel ('Just "iWarnings") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TCWarning]) :*: S1 ('MetaSel ('Just "iPartialDefs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set QName))))))))

data ForeignCode Source #

Constructors

ForeignCode Range String |

#### Instances

Instances details

EmbPrj ForeignCode Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Compilers Methods icode :: ForeignCode -> S Int32 Source # icod_ :: ForeignCode -> S Int32 Source # value :: Int32 -> R ForeignCode Source #
Generic ForeignCode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep ForeignCode :: Type -> Type Source # Methods from :: ForeignCode -> Rep ForeignCode x Source # to :: Rep ForeignCode x -> ForeignCode Source #
Show ForeignCode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> ForeignCode -> ShowS Source # show :: ForeignCode -> String Source # showList :: [ForeignCode] -> ShowS Source #
NFData ForeignCode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: ForeignCode -> () Source #
type Rep ForeignCode Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep ForeignCode = D1 ('MetaData "ForeignCode" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "ForeignCode" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Range) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))

type DecodedModules = Map TopLevelModuleName ModuleInfo Source #

type VisitedModules = Map TopLevelModuleName ModuleInfo Source #

data ModuleInfo Source #

Constructors

ModuleInfo |

Fields

- miInterface :: Interface
- 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

- miPrimitive :: Bool

  `True` if the module is a primitive module, which should always be importable.

- miMode :: ModuleCheckMode

  The `ModuleCheckMode` used to create the `Interface`

#### Instances

Instances details

Generic ModuleInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep ModuleInfo :: Type -> Type Source # Methods from :: ModuleInfo -> Rep ModuleInfo x Source # to :: Rep ModuleInfo x -> ModuleInfo Source #
NFData ModuleInfo Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: ModuleInfo -> () Source #
type Rep ModuleInfo Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep ModuleInfo = D1 ('MetaData "ModuleInfo" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "ModuleInfo" 'PrefixI 'True) ((S1 ('MetaSel ('Just "miInterface") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Interface) :*: S1 ('MetaSel ('Just "miWarnings") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TCWarning])) :*: (S1 ('MetaSel ('Just "miPrimitive") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "miMode") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModuleCheckMode))))

data ModuleCheckMode Source #

Distinguishes between type-checked and scope-checked interfaces when stored in the map of `VisitedModules`.

Constructors

ModuleScopeChecked |
ModuleTypeChecked |

#### Instances

Instances details

Bounded ModuleCheckMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods minBound :: ModuleCheckMode Source # maxBound :: ModuleCheckMode Source #
Enum ModuleCheckMode Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: ModuleCheckMode -> ModuleCheckMode Source #

pred :: ModuleCheckMode -> ModuleCheckMode Source #

toEnum :: Int -> ModuleCheckMode Source #

fromEnum :: ModuleCheckMode -> Int Source #

enumFrom :: ModuleCheckMode -> [ModuleCheckMode] Source #

enumFromThen :: ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode] Source #

enumFromTo :: ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode] Source #

enumFromThenTo :: ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode -> [ModuleCheckMode] Source #

Generic ModuleCheckMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep ModuleCheckMode :: Type -> Type Source # Methods from :: ModuleCheckMode -> Rep ModuleCheckMode x Source # to :: Rep ModuleCheckMode x -> ModuleCheckMode Source #
Show ModuleCheckMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> ModuleCheckMode -> ShowS Source # show :: ModuleCheckMode -> String Source # showList :: [ModuleCheckMode] -> ShowS Source #
NFData ModuleCheckMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: ModuleCheckMode -> () Source #
Eq ModuleCheckMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: ModuleCheckMode -> ModuleCheckMode -> Bool Source # (/=) :: ModuleCheckMode -> ModuleCheckMode -> Bool Source #
Ord ModuleCheckMode Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: ModuleCheckMode -> ModuleCheckMode -> Ordering Source #

(<) :: ModuleCheckMode -> ModuleCheckMode -> Bool Source #

(<=) :: ModuleCheckMode -> ModuleCheckMode -> Bool Source #

(>) :: ModuleCheckMode -> ModuleCheckMode -> Bool Source #

(>=) :: ModuleCheckMode -> ModuleCheckMode -> Bool Source #

max :: ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode Source #

min :: ModuleCheckMode -> ModuleCheckMode -> ModuleCheckMode Source #

type Rep ModuleCheckMode Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base type Rep ModuleCheckMode = D1 ('MetaData "ModuleCheckMode" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "ModuleScopeChecked" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ModuleTypeChecked" 'PrefixI 'False) (U1 :: Type -> Type))

class Monad m => MonadStConcreteNames m where Source #

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).

Minimal complete definition

runStConcreteNames

Methods

runStConcreteNames :: StateT ConcreteNames m a -> m a Source #

useConcreteNames :: m ConcreteNames Source #

modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> m () Source #

#### Instances

Instances details

MonadStConcreteNames AbsToCon Source # |
Instance details Defined in Agda.Syntax.Translation.AbstractToConcrete Methods runStConcreteNames :: StateT ConcreteNames AbsToCon a -> AbsToCon a Source # useConcreteNames :: AbsToCon ConcreteNames Source # modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> AbsToCon () Source #
MonadStConcreteNames TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods runStConcreteNames :: StateT ConcreteNames TCM a -> TCM a Source # useConcreteNames :: TCM ConcreteNames Source # modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> TCM () Source #
ReadTCState m => MonadStConcreteNames (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods runStConcreteNames :: StateT ConcreteNames (PureConversionT m) a -> PureConversionT m a Source # useConcreteNames :: PureConversionT m ConcreteNames Source # modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> PureConversionT m () Source #
MonadStConcreteNames m => MonadStConcreteNames (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods runStConcreteNames :: StateT ConcreteNames (IdentityT m) a -> IdentityT m a Source # useConcreteNames :: IdentityT m ConcreteNames Source # modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> IdentityT m () Source #
MonadStConcreteNames m => MonadStConcreteNames (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods runStConcreteNames :: StateT ConcreteNames (ReaderT r m) a -> ReaderT r m a Source # useConcreteNames :: ReaderT r m ConcreteNames Source # modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> ReaderT r m () Source #
MonadStConcreteNames m => MonadStConcreteNames (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods runStConcreteNames :: StateT ConcreteNames (StateT s m) a -> StateT s m a Source # useConcreteNames :: StateT s m ConcreteNames Source # modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> StateT s m () Source #

type SourceToModule = Map AbsolutePath TopLevelModuleName Source #

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

class FreshName a where Source #

Create a fresh name from `a`.

Methods

freshName_ :: MonadFresh NameId m => a -> m Name Source #

#### Instances

Instances details

FreshName Range Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshName_ :: MonadFresh NameId m => Range -> m Name Source #
FreshName String Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshName_ :: MonadFresh NameId m => String -> m Name Source #
FreshName () Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshName_ :: MonadFresh NameId m => () -> m Name Source #
FreshName (Range, String) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshName_ :: MonadFresh NameId m => (Range, String) -> m Name Source #

newtype CheckpointId Source #

Constructors

CheckpointId Int |

#### Instances

Instances details

HasFresh CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' CheckpointId TCState Source # nextFresh' :: CheckpointId -> CheckpointId Source #
PrettyTCM CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Pretty Methods prettyTCM :: MonadPretty m => CheckpointId -> m Doc Source #
EmbPrj CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Serialise.Instances.Internal Methods icode :: CheckpointId -> S Int32 Source # icod_ :: CheckpointId -> S Int32 Source # value :: Int32 -> R CheckpointId Source #
Pretty CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods pretty :: CheckpointId -> Doc Source # prettyPrec :: Int -> CheckpointId -> Doc Source # prettyList :: [CheckpointId] -> Doc Source #
Data CheckpointId Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CheckpointId -> c CheckpointId Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CheckpointId Source #

toConstr :: CheckpointId -> Constr Source #

dataTypeOf :: CheckpointId -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CheckpointId) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CheckpointId) Source #

gmapT :: (forall b. Data b => b -> b) -> CheckpointId -> CheckpointId Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CheckpointId -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CheckpointId -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CheckpointId -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CheckpointId -> m CheckpointId Source #

Enum CheckpointId Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

succ :: CheckpointId -> CheckpointId Source #

pred :: CheckpointId -> CheckpointId Source #

toEnum :: Int -> CheckpointId Source #

fromEnum :: CheckpointId -> Int Source #

enumFrom :: CheckpointId -> [CheckpointId] Source #

enumFromThen :: CheckpointId -> CheckpointId -> [CheckpointId] Source #

enumFromTo :: CheckpointId -> CheckpointId -> [CheckpointId] Source #

enumFromThenTo :: CheckpointId -> CheckpointId -> CheckpointId -> [CheckpointId] Source #

Num CheckpointId Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

(+) :: CheckpointId -> CheckpointId -> CheckpointId Source #

(-) :: CheckpointId -> CheckpointId -> CheckpointId Source #

(*) :: CheckpointId -> CheckpointId -> CheckpointId Source #

negate :: CheckpointId -> CheckpointId Source #

abs :: CheckpointId -> CheckpointId Source #

signum :: CheckpointId -> CheckpointId Source #

fromInteger :: Integer -> CheckpointId Source #

Integral CheckpointId Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

quot :: CheckpointId -> CheckpointId -> CheckpointId Source #

rem :: CheckpointId -> CheckpointId -> CheckpointId Source #

div :: CheckpointId -> CheckpointId -> CheckpointId Source #

mod :: CheckpointId -> CheckpointId -> CheckpointId Source #

quotRem :: CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId) Source #

divMod :: CheckpointId -> CheckpointId -> (CheckpointId, CheckpointId) Source #

toInteger :: CheckpointId -> Integer Source #

Real CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods toRational :: CheckpointId -> Rational Source #
Show CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> CheckpointId -> ShowS Source # show :: CheckpointId -> String Source # showList :: [CheckpointId] -> ShowS Source #
NFData CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: CheckpointId -> () Source #
Eq CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: CheckpointId -> CheckpointId -> Bool Source # (/=) :: CheckpointId -> CheckpointId -> Bool Source #
Ord CheckpointId Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

Methods

compare :: CheckpointId -> CheckpointId -> Ordering Source #

(<) :: CheckpointId -> CheckpointId -> Bool Source #

(<=) :: CheckpointId -> CheckpointId -> Bool Source #

(>) :: CheckpointId -> CheckpointId -> Bool Source #

(>=) :: CheckpointId -> CheckpointId -> Bool Source #

max :: CheckpointId -> CheckpointId -> CheckpointId Source #

min :: CheckpointId -> CheckpointId -> CheckpointId Source #

class Monad m => MonadFresh i m where Source #

Minimal complete definition

Nothing

Methods

fresh :: m i Source #

default fresh :: (MonadTrans t, MonadFresh i n, t n ~ m) => m i Source #

#### Instances

Instances details

HasFresh i => MonadFresh i TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fresh :: TCM i Source #
Monad m => MonadFresh NameId (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods fresh :: PureConversionT m NameId Source #
Monad m => MonadFresh ProblemId (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods fresh :: PureConversionT m ProblemId Source #
Monad m => MonadFresh Int (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods fresh :: PureConversionT m Int Source #
MonadFresh i m => MonadFresh i (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fresh :: ListT m i Source #
MonadFresh i m => MonadFresh i (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fresh :: IdentityT m i Source #
MonadFresh i m => MonadFresh i (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fresh :: ReaderT r m i Source #
MonadFresh i m => MonadFresh i (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods fresh :: StateT s m i Source #

class Enum i => HasFresh i where Source #

Minimal complete definition

freshLens

Methods

freshLens :: Lens' i TCState Source #

nextFresh' :: i -> i Source #

#### Instances

Instances details

HasFresh InteractionId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' InteractionId TCState Source # nextFresh' :: InteractionId -> InteractionId Source #
HasFresh MetaId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' MetaId TCState Source # nextFresh' :: MetaId -> MetaId Source #
HasFresh NameId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' NameId TCState Source # nextFresh' :: NameId -> NameId Source #
HasFresh ProblemId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' ProblemId TCState Source # nextFresh' :: ProblemId -> ProblemId Source #
HasFresh CheckpointId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' CheckpointId TCState Source # nextFresh' :: CheckpointId -> CheckpointId Source #
HasFresh MutualId Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' MutualId TCState Source # nextFresh' :: MutualId -> MutualId Source #
HasFresh Int Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods freshLens :: Lens' Int TCState Source # nextFresh' :: Int -> Int Source #

data TypeCheckAction Source #

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.

Constructors

EnterSection !ModuleName !Telescope |
LeaveSection !ModuleName |
Decl !Declaration | Never a Section or ScopeDecl
Pragmas !PragmaOptions |

#### Instances

Instances details

Generic TypeCheckAction Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep TypeCheckAction :: Type -> Type Source # Methods from :: TypeCheckAction -> Rep TypeCheckAction x Source # to :: Rep TypeCheckAction x -> TypeCheckAction Source #
NFData TypeCheckAction Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: TypeCheckAction -> () Source #
type Rep TypeCheckAction Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep TypeCheckAction = D1 ('MetaData "TypeCheckAction" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) ((C1 ('MetaCons "EnterSection" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 ModuleName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Telescope)) :+: C1 ('MetaCons "LeaveSection" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 ModuleName))) :+: (C1 ('MetaCons "Decl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Declaration)) :+: C1 ('MetaCons "Pragmas" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PragmaOptions))))

type CurrentTypeCheckLog = [(TypeCheckAction, PostScopeState)] Source #

Like `CachedTypeCheckLog`, but storing the log for an ongoing type checking of a module. Stored in reverse order (last performed action first).

type CachedTypeCheckLog = [(TypeCheckAction, PostScopeState)] Source #

A log of what the type checker does and states after the action is completed. The cached version is stored first executed action first.

data LoadedFileCache Source #

Constructors

LoadedFileCache |

Fields

- lfcCached :: !CachedTypeCheckLog
- lfcCurrent :: !CurrentTypeCheckLog

#### Instances

Instances details

Generic LoadedFileCache Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep LoadedFileCache :: Type -> Type Source # Methods from :: LoadedFileCache -> Rep LoadedFileCache x Source # to :: Rep LoadedFileCache x -> LoadedFileCache Source #
NFData LoadedFileCache Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: LoadedFileCache -> () Source #
type Rep LoadedFileCache Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep LoadedFileCache = D1 ('MetaData "LoadedFileCache" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "LoadedFileCache" 'PrefixI 'True) (S1 ('MetaSel ('Just "lfcCached") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 CachedTypeCheckLog) :*: S1 ('MetaSel ('Just "lfcCurrent") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 CurrentTypeCheckLog)))

data PersistentTCState Source #

A part of the state which is not reverted when an error is thrown or the state is reset.

Constructors

PersistentTCSt |

Fields

- stDecodedModules :: !DecodedModules
- stPersistentOptions :: CommandLineOptions
- stInteractionOutputCallback :: InteractionOutputCallback

  Callback function to call when there is a response to give to the interactive frontend. See the documentation of `InteractionOutputCallback`.

- 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!

- stAccumStatistics :: !Statistics

  Should be strict field.

- stPersistLoadedFileCache :: !(Maybe LoadedFileCache)

  Cached typechecking state from the last loaded file. Should be `Nothing` when checking imports.

- stPersistBackends :: [Backend]

  Current backends with their options

#### Instances

Instances details

LensCommandLineOptions PersistentTCState Source # |
Instance details Defined in Agda.Interaction.Options.Lenses Methods getCommandLineOptions :: PersistentTCState -> CommandLineOptions Source # setCommandLineOptions :: CommandLineOptions -> PersistentTCState -> PersistentTCState Source # mapCommandLineOptions :: (CommandLineOptions -> CommandLineOptions) -> PersistentTCState -> PersistentTCState Source #
LensIncludePaths PersistentTCState Source # |

Instance details

Defined in Agda.Interaction.Options.Lenses

Methods

getIncludePaths :: PersistentTCState -> [FilePath] Source #

setIncludePaths :: [FilePath] -> PersistentTCState -> PersistentTCState Source #

mapIncludePaths :: ([FilePath] -> [FilePath]) -> PersistentTCState -> PersistentTCState Source #

getAbsoluteIncludePaths :: PersistentTCState -> [AbsolutePath] Source #

setAbsoluteIncludePaths :: [AbsolutePath] -> PersistentTCState -> PersistentTCState Source #

mapAbsoluteIncludePaths :: ([AbsolutePath] -> [AbsolutePath]) -> PersistentTCState -> PersistentTCState Source #

LensPersistentVerbosity PersistentTCState Source # |
Instance details Defined in Agda.Interaction.Options.Lenses Methods getPersistentVerbosity :: PersistentTCState -> PersistentVerbosity Source # setPersistentVerbosity :: PersistentVerbosity -> PersistentTCState -> PersistentTCState Source # mapPersistentVerbosity :: (PersistentVerbosity -> PersistentVerbosity) -> PersistentTCState -> PersistentTCState Source #
LensSafeMode PersistentTCState Source # |
Instance details Defined in Agda.Interaction.Options.Lenses Methods getSafeMode :: PersistentTCState -> SafeMode Source # setSafeMode :: SafeMode -> PersistentTCState -> PersistentTCState Source # mapSafeMode :: (SafeMode -> SafeMode) -> PersistentTCState -> PersistentTCState Source #
Generic PersistentTCState Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep PersistentTCState :: Type -> Type Source # Methods from :: PersistentTCState -> Rep PersistentTCState x Source # to :: Rep PersistentTCState x -> PersistentTCState Source #
NFData PersistentTCState Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: PersistentTCState -> () Source #
type Rep PersistentTCState Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep PersistentTCState = D1 ('MetaData "PersistentTCState" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "PersistentTCSt" 'PrefixI 'True) ((S1 ('MetaSel ('Just "stDecodedModules") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 DecodedModules) :*: (S1 ('MetaSel ('Just "stPersistentOptions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CommandLineOptions) :*: S1 ('MetaSel ('Just "stInteractionOutputCallback") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 InteractionOutputCallback))) :*: ((S1 ('MetaSel ('Just "stBenchmark") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Benchmark) :*: S1 ('MetaSel ('Just "stAccumStatistics") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Statistics)) :*: (S1 ('MetaSel ('Just "stPersistLoadedFileCache") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe LoadedFileCache)) :*: S1 ('MetaSel ('Just "stPersistBackends") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Backend])))))

data MutualBlock Source #

A mutual block of names in the signature.

Constructors

MutualBlock |

Fields

- mutualInfo :: MutualInfo

  The original info of the mutual block.

- mutualNames :: Set QName

#### Instances

Instances details

Null MutualBlock Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods empty :: MutualBlock Source # null :: MutualBlock -> Bool Source #
Generic MutualBlock Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep MutualBlock :: Type -> Type Source # Methods from :: MutualBlock -> Rep MutualBlock x Source # to :: Rep MutualBlock x -> MutualBlock Source #
Show MutualBlock Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods showsPrec :: Int -> MutualBlock -> ShowS Source # show :: MutualBlock -> String Source # showList :: [MutualBlock] -> ShowS Source #
NFData MutualBlock Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: MutualBlock -> () Source #
Eq MutualBlock Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods (==) :: MutualBlock -> MutualBlock -> Bool Source # (/=) :: MutualBlock -> MutualBlock -> Bool Source #
type Rep MutualBlock Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep MutualBlock = D1 ('MetaData "MutualBlock" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "MutualBlock" 'PrefixI 'True) (S1 ('MetaSel ('Just "mutualInfo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MutualInfo) :*: S1 ('MetaSel ('Just "mutualNames") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set QName))))

data PostScopeState Source #

Constructors

PostScopeState |

Fields

- stPostSyntaxInfo :: !HighlightingInfo

  Highlighting info.

- stPostDisambiguatedNames :: !DisambiguatedNames

  Disambiguation carried out by the type checker. Maps position of first name character to disambiguated ``QName`` for each ``AmbiguousQName`` already passed by the type checker.

- stPostMetaStore :: !MetaStore
- stPostInteractionPoints :: !InteractionPoints
- stPostAwakeConstraints :: !Constraints
- stPostSleepingConstraints :: !Constraints
- stPostDirty :: !Bool

  Dirty when a constraint is added, used to prevent pointer update. Currently unused.

- stPostOccursCheckDefs :: !(Set QName)

  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.

- stPostSignature :: !Signature

  Declared identifiers of the current file. These will be serialized after successful type checking.

- stPostModuleCheckpoints :: !(Map ModuleName CheckpointId)

  For each module remember the checkpoint corresponding to the orignal context of the module parameters.

- stPostImportsDisplayForms :: !DisplayForms

  Display forms we add for imported identifiers

- stPostCurrentModule :: !(Maybe ModuleName)

  The current module is available after it has been type checked.

- stPostInstanceDefs :: !TempInstanceTable
- 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)

- 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.

- stPostShadowingNames :: !(Map Name [RawName])

  Map keeping track for each (abstract) name the list of all (raw) names that it could maybe be shadowed by.

- stPostStatistics :: !Statistics

  Counters to collect various statistics about meta variables etc. Only for current file.

- stPostTCWarnings :: ![TCWarning]
- stPostMutualBlocks :: !(Map MutualId MutualBlock)
- stPostLocalBuiltins :: !(BuiltinThings PrimFun)
- stPostFreshMetaId :: !MetaId
- stPostFreshMutualId :: !MutualId
- stPostFreshProblemId :: !ProblemId
- stPostFreshCheckpointId :: !CheckpointId
- stPostFreshInt :: !Int
- stPostFreshNameId :: !NameId
- stPostAreWeCaching :: !Bool
- stPostPostponeInstanceSearch :: !Bool
- stPostConsideringInstance :: !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.

- stPostLocalPartialDefs :: !(Set QName)

  Local partial definitions, to be stored in the `Interface`

#### Instances

Instances details

Generic PostScopeState Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep PostScopeState :: Type -> Type Source # Methods from :: PostScopeState -> Rep PostScopeState x Source # to :: Rep PostScopeState x -> PostScopeState Source #
NFData PostScopeState Source # | This instance could be optimised, some things are guaranteed to be forced.
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: PostScopeState -> () Source #
type Rep PostScopeState Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep PostScopeState = D1 ('MetaData "PostScopeState" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "PostScopeState" 'PrefixI 'True) ((((S1 ('MetaSel ('Just "stPostSyntaxInfo") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 HighlightingInfo) :*: (S1 ('MetaSel ('Just "stPostDisambiguatedNames") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 DisambiguatedNames) :*: S1 ('MetaSel ('Just "stPostMetaStore") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 MetaStore))) :*: ((S1 ('MetaSel ('Just "stPostInteractionPoints") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 InteractionPoints) :*: S1 ('MetaSel ('Just "stPostAwakeConstraints") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Constraints)) :*: (S1 ('MetaSel ('Just "stPostSleepingConstraints") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Constraints) :*: S1 ('MetaSel ('Just "stPostDirty") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)))) :*: (((S1 ('MetaSel ('Just "stPostOccursCheckDefs") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Set QName)) :*: S1 ('MetaSel ('Just "stPostSignature") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Signature)) :*: (S1 ('MetaSel ('Just "stPostModuleCheckpoints") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map ModuleName CheckpointId)) :*: S1 ('MetaSel ('Just "stPostImportsDisplayForms") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 DisplayForms))) :*: ((S1 ('MetaSel ('Just "stPostCurrentModule") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe ModuleName)) :*: S1 ('MetaSel ('Just "stPostInstanceDefs") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 TempInstanceTable)) :*: (S1 ('MetaSel ('Just "stPostConcreteNames") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 ConcreteNames) :*: S1 ('MetaSel ('Just "stPostUsedNames") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map RawName [RawName])))))) :*: ((((S1 ('MetaSel ('Just "stPostShadowingNames") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map Name [RawName])) :*: S1 ('MetaSel ('Just "stPostStatistics") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Statistics)) :*: (S1 ('MetaSel ('Just "stPostTCWarnings") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 [TCWarning]) :*: S1 ('MetaSel ('Just "stPostMutualBlocks") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map MutualId MutualBlock)))) :*: ((S1 ('MetaSel ('Just "stPostLocalBuiltins") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (BuiltinThings PrimFun)) :*: S1 ('MetaSel ('Just "stPostFreshMetaId") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 MetaId)) :*: (S1 ('MetaSel ('Just "stPostFreshMutualId") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 MutualId) :*: S1 ('MetaSel ('Just "stPostFreshProblemId") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 ProblemId)))) :*: (((S1 ('MetaSel ('Just "stPostFreshCheckpointId") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 CheckpointId) :*: S1 ('MetaSel ('Just "stPostFreshInt") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int)) :*: (S1 ('MetaSel ('Just "stPostFreshNameId") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 NameId) :*: S1 ('MetaSel ('Just "stPostAreWeCaching") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool))) :*: ((S1 ('MetaSel ('Just "stPostPostponeInstanceSearch") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool) :*: S1 ('MetaSel ('Just "stPostConsideringInstance") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)) :*: (S1 ('MetaSel ('Just "stPostInstantiateBlocking") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool) :*: S1 ('MetaSel ('Just "stPostLocalPartialDefs") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Set QName))))))))

type ConcreteNames = Map Name [Name] Source #

type DisambiguatedNames = IntMap DisambiguatedName Source #

data DisambiguatedName Source #

Name disambiguation for the sake of highlighting.

Constructors

DisambiguatedName NameKind QName |

#### Instances

Instances details

Generic DisambiguatedName Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep DisambiguatedName :: Type -> Type Source # Methods from :: DisambiguatedName -> Rep DisambiguatedName x Source # to :: Rep DisambiguatedName x -> DisambiguatedName Source #
NFData DisambiguatedName Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: DisambiguatedName -> () Source #
type Rep DisambiguatedName Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep DisambiguatedName = D1 ('MetaData "DisambiguatedName" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "DisambiguatedName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NameKind) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QName)))

data PreScopeState Source #

Constructors

PreScopeState |

Fields

- stPreTokens :: !HighlightingInfo

  Highlighting info for tokens and Happy parser warnings (but not for those tokens/warnings for which highlighting exists in `stPostSyntaxInfo`).

- stPreImports :: !Signature

  Imported declared identifiers. Those most not be serialized!

- stPreImportedModules :: !(Set ModuleName)
- stPreModuleToSource :: !ModuleToSource
- stPreVisitedModules :: !VisitedModules
- stPreScope :: !ScopeInfo
- stPrePatternSyns :: !PatternSynDefns

  Pattern synonyms of the current file. Serialized.

- stPrePatternSynImports :: !PatternSynDefns

  Imported pattern synonyms. Must not be serialized!

- stPreGeneralizedVars :: !(Maybe (Set QName))

  Collected generalizable variables; used during scope checking of terms

- stPrePragmaOptions :: !PragmaOptions

  Options applying to the current file. `OPTIONS` pragmas only affect this field.

- stPreImportedBuiltins :: !(BuiltinThings PrimFun)
- stPreImportedDisplayForms :: !DisplayForms

  Display forms added by someone else to imported identifiers

- stPreImportedInstanceDefs :: !InstanceTable
- stPreForeignCode :: !(Map BackendName [ForeignCode])

  `{-# FOREIGN #-}` code that should be included in the compiled output. Does not include code for imported modules.

- stPreFreshInteractionId :: !InteractionId
- stPreImportedUserWarnings :: !(Map QName Text)

  Imported `UserWarning`s, not to be stored in the `Interface`

- stPreLocalUserWarnings :: !(Map QName Text)

  Locally defined `UserWarning`s, to be stored in the `Interface`

- stPreWarningOnImport :: !(Maybe Text)

  Whether the current module should raise a warning when opened

- stPreImportedPartialDefs :: !(Set QName)

  Imported partial definitions, not to be stored in the `Interface`

- stPreProjectConfigs :: !(Map FilePath ProjectConfig)

  Map from directories to paths of closest enclosing .agda-lib files (or `Nothing` if there are none).

- stPreAgdaLibFiles :: !(Map FilePath AgdaLibFile)

  Contents of .agda-lib files that have already been parsed.

#### Instances

Instances details

Generic PreScopeState Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Associated Types type Rep PreScopeState :: Type -> Type Source # Methods from :: PreScopeState -> Rep PreScopeState x Source # to :: Rep PreScopeState x -> PreScopeState Source #
NFData PreScopeState Source # | This instance could be optimised, some things are guaranteed to be forced.
Instance details Defined in Agda.TypeChecking.Monad.Base Methods rnf :: PreScopeState -> () Source #
type Rep PreScopeState Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Base

type Rep PreScopeState = D1 ('MetaData "PreScopeState" "Agda.TypeChecking.Monad.Base" "Agda-2.6.2.2-7KnEKyKhaJHFPwDzdI3vIK" 'False) (C1 ('MetaCons "PreScopeState" 'PrefixI 'True) ((((S1 ('MetaSel ('Just "stPreTokens") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 HighlightingInfo) :*: S1 ('MetaSel ('Just "stPreImports") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Signature)) :*: (S1 ('MetaSel ('Just "stPreImportedModules") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Set ModuleName)) :*: (S1 ('MetaSel ('Just "stPreModuleToSource") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 ModuleToSource) :*: S1 ('MetaSel ('Just "stPreVisitedModules") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 VisitedModules)))) :*: ((S1 ('MetaSel ('Just "stPreScope") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 ScopeInfo) :*: S1 ('MetaSel ('Just "stPrePatternSyns") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PatternSynDefns)) :*: (S1 ('MetaSel ('Just "stPrePatternSynImports") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PatternSynDefns) :*: (S1 ('MetaSel ('Just "stPreGeneralizedVars") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe (Set QName))) :*: S1 ('MetaSel ('Just "stPrePragmaOptions") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PragmaOptions))))) :*: (((S1 ('MetaSel ('Just "stPreImportedBuiltins") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (BuiltinThings PrimFun)) :*: S1 ('MetaSel ('Just "stPreImportedDisplayForms") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 DisplayForms)) :*: (S1 ('MetaSel ('Just "stPreImportedInstanceDefs") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 InstanceTable) :*: (S1 ('MetaSel ('Just "stPreForeignCode") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map BackendName [ForeignCode])) :*: S1 ('MetaSel ('Just "stPreFreshInteractionId") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 InteractionId)))) :*: ((S1 ('MetaSel ('Just "stPreImportedUserWarnings") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map QName Text)) :*: (S1 ('MetaSel ('Just "stPreLocalUserWarnings") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map QName Text)) :*: S1 ('MetaSel ('Just "stPreWarningOnImport") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Text)))) :*: (S1 ('MetaSel ('Just "stPreImportedPartialDefs") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Set QName)) :*: (S1 ('MetaSel ('Just "stPreProjectConfigs") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map FilePath ProjectConfig)) :*: S1 ('MetaSel ('Just "stPreAgdaLibFiles") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Map FilePath AgdaLibFile))))))))

class Monad m => ReadTCState m where Source #

Minimal complete definition

Nothing

Methods

getTCState :: m TCState Source #

default getTCState :: (MonadTrans t, ReadTCState n, t n ~ m) => m TCState Source #

locallyTCState :: Lens' a TCState -> (a -> a) -> m b -> m b Source #

default locallyTCState :: (MonadTransControl t, ReadTCState n, t n ~ m) => Lens' a TCState -> (a -> a) -> m b -> m b Source #

withTCState :: (TCState -> TCState) -> m a -> m a Source #

#### Instances

Instances details

ReadTCState IM Source # |
Instance details Defined in Agda.Interaction.Monad Methods getTCState :: IM TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> IM b -> IM b Source # withTCState :: (TCState -> TCState) -> IM a -> IM a Source #
ReadTCState AbsToCon Source # |
Instance details Defined in Agda.Syntax.Translation.AbstractToConcrete Methods getTCState :: AbsToCon TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> AbsToCon b -> AbsToCon b Source # withTCState :: (TCState -> TCState) -> AbsToCon a -> AbsToCon a Source #
ReadTCState TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods getTCState :: TerM TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> TerM b -> TerM b Source # withTCState :: (TCState -> TCState) -> TerM a -> TerM a Source #
ReadTCState ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: ReduceM TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> ReduceM b -> ReduceM b Source # withTCState :: (TCState -> TCState) -> ReduceM a -> ReduceM a Source #
ReadTCState NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods getTCState :: NLM TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> NLM b -> NLM b Source # withTCState :: (TCState -> TCState) -> NLM a -> NLM a Source #
ReadTCState m => ReadTCState (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods getTCState :: PureConversionT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> PureConversionT m b -> PureConversionT m b Source # withTCState :: (TCState -> TCState) -> PureConversionT m a -> PureConversionT m a Source #
ReadTCState m => ReadTCState (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: BlockT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> BlockT m b -> BlockT m b Source # withTCState :: (TCState -> TCState) -> BlockT m a -> BlockT m a Source #
MonadIO m => ReadTCState (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: TCMT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> TCMT m b -> TCMT m b Source # withTCState :: (TCState -> TCState) -> TCMT m a -> TCMT m a Source #
ReadTCState m => ReadTCState (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods getTCState :: NamesT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> NamesT m b -> NamesT m b Source # withTCState :: (TCState -> TCState) -> NamesT m a -> NamesT m a Source #
ReadTCState m => ReadTCState (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: ListT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> ListT m b -> ListT m b Source # withTCState :: (TCState -> TCState) -> ListT m a -> ListT m a Source #
ReadTCState m => ReadTCState (ChangeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: ChangeT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> ChangeT m b -> ChangeT m b Source # withTCState :: (TCState -> TCState) -> ChangeT m a -> ChangeT m a Source #
ReadTCState m => ReadTCState (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: MaybeT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> MaybeT m b -> MaybeT m b Source # withTCState :: (TCState -> TCState) -> MaybeT m a -> MaybeT m a Source #
ReadTCState m => ReadTCState (ExceptT err m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: ExceptT err m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> ExceptT err m b -> ExceptT err m b Source # withTCState :: (TCState -> TCState) -> ExceptT err m a -> ExceptT err m a Source #
ReadTCState m => ReadTCState (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: IdentityT m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> IdentityT m b -> IdentityT m b Source # withTCState :: (TCState -> TCState) -> IdentityT m a -> IdentityT m a Source #
ReadTCState m => ReadTCState (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: ReaderT r m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> ReaderT r m b -> ReaderT r m b Source # withTCState :: (TCState -> TCState) -> ReaderT r m a -> ReaderT r m a Source #
ReadTCState m => ReadTCState (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: StateT s m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> StateT s m b -> StateT s m b Source # withTCState :: (TCState -> TCState) -> StateT s m a -> StateT s m a Source #
(Monoid w, ReadTCState m) => ReadTCState (WriterT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Base Methods getTCState :: WriterT w m TCState Source # locallyTCState :: Lens' a TCState -> (a -> a) -> WriterT w m b -> WriterT w m b Source # withTCState :: (TCState -> TCState) -> WriterT w m a -> WriterT w m a Source #

initPersistentState :: PersistentTCState Source #

Empty persistent state.

initPreScopeState :: PreScopeState Source #

Empty state of type checker.

initPostScopeState :: PostScopeState Source #

initState :: TCState Source #

stTokens :: Lens' HighlightingInfo TCState Source #

stImports :: Lens' Signature TCState Source #

stImportedModules :: Lens' (Set ModuleName) TCState Source #

stModuleToSource :: Lens' ModuleToSource TCState Source #

stVisitedModules :: Lens' VisitedModules TCState Source #

stScope :: Lens' ScopeInfo TCState Source #

stPatternSyns :: Lens' PatternSynDefns TCState Source #

stPatternSynImports :: Lens' PatternSynDefns TCState Source #

stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState Source #

stPragmaOptions :: Lens' PragmaOptions TCState Source #

stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState Source #

stForeignCode :: Lens' (Map BackendName [ForeignCode]) TCState Source #

stFreshInteractionId :: Lens' InteractionId TCState Source #

stImportedUserWarnings :: Lens' (Map QName Text) TCState Source #

stLocalUserWarnings :: Lens' (Map QName Text) TCState Source #

getUserWarnings :: ReadTCState m => m (Map QName Text) Source #

stWarningOnImport :: Lens' (Maybe Text) TCState Source #

stImportedPartialDefs :: Lens' (Set QName) TCState Source #

stLocalPartialDefs :: Lens' (Set QName) TCState Source #

getPartialDefs :: ReadTCState m => m (Set QName) Source #

stLoadedFileCache :: Lens' (Maybe LoadedFileCache) TCState Source #

stBackends :: Lens' [Backend] TCState Source #

stProjectConfigs :: Lens' (Map FilePath ProjectConfig) TCState Source #

stAgdaLibFiles :: Lens' (Map FilePath AgdaLibFile) TCState Source #

stFreshNameId :: Lens' NameId TCState Source #

stSyntaxInfo :: Lens' HighlightingInfo TCState Source #

stDisambiguatedNames :: Lens' DisambiguatedNames TCState Source #

stMetaStore :: Lens' MetaStore TCState Source #

stInteractionPoints :: Lens' InteractionPoints TCState Source #

stAwakeConstraints :: Lens' Constraints TCState Source #

stSleepingConstraints :: Lens' Constraints TCState Source #

stDirty :: Lens' Bool TCState Source #

stOccursCheckDefs :: Lens' (Set QName) TCState Source #

stSignature :: Lens' Signature TCState Source #

stModuleCheckpoints :: Lens' (Map ModuleName CheckpointId) TCState Source #

stImportsDisplayForms :: Lens' DisplayForms TCState Source #

stImportedDisplayForms :: Lens' DisplayForms TCState Source #

stCurrentModule :: Lens' (Maybe ModuleName) TCState Source #

stImportedInstanceDefs :: Lens' InstanceTable TCState Source #

stInstanceDefs :: Lens' TempInstanceTable TCState Source #

stConcreteNames :: Lens' ConcreteNames TCState Source #

stUsedNames :: Lens' (Map RawName [RawName]) TCState Source #

stShadowingNames :: Lens' (Map Name [RawName]) TCState Source #

stStatistics :: Lens' Statistics TCState Source #

stTCWarnings :: Lens' [TCWarning] TCState Source #

stMutualBlocks :: Lens' (Map MutualId MutualBlock) TCState Source #

stLocalBuiltins :: Lens' (BuiltinThings PrimFun) TCState Source #

stFreshMetaId :: Lens' MetaId TCState Source #

stFreshMutualId :: Lens' MutualId TCState Source #

stFreshProblemId :: Lens' ProblemId TCState Source #

stFreshCheckpointId :: Lens' CheckpointId TCState Source #

stFreshInt :: Lens' Int TCState Source #

stAreWeCaching :: Lens' Bool TCState Source #

stPostponeInstanceSearch :: Lens' Bool TCState Source #

stConsideringInstance :: Lens' Bool TCState Source #

stInstantiateBlocking :: Lens' Bool TCState Source #

stBuiltinThings :: TCState -> BuiltinThings PrimFun Source #

nextFresh :: HasFresh i => TCState -> (i, TCState) Source #

freshName :: MonadFresh NameId m => Range -> String -> m Name Source #

freshNoName :: MonadFresh NameId m => Range -> m Name Source #

freshNoName_ :: MonadFresh NameId m => m Name Source #

freshRecordName :: MonadFresh NameId m => m Name Source #

sourceToModule :: TCM SourceToModule Source #

Creates a `SourceToModule` map based on `stModuleToSource`.

O(n log n).

For a single reverse lookup in `stModuleToSource`, rather use `lookupModuleFromSourse`.

lookupModuleFromSource :: ReadTCState m => AbsolutePath -> m (Maybe TopLevelModuleName) Source #

Lookup an `AbsolutePath` in `sourceToModule`.

O(n).

iFullHash :: Interface -> Hash Source #

Combines the source hash and the (full) hashes of the imported modules.

intSignature :: Lens' Signature Interface Source #

A lens for the `iSignature` field of the `Interface` type.

buildClosure :: (MonadTCEnv m, ReadTCState m) => a -> m (Closure a) Source #

fromCmp :: Comparison -> CompareDirection Source #

Embed `Comparison` into `CompareDirection`.

flipCmp :: CompareDirection -> CompareDirection Source #

Flip the direction of comparison.

dirToCmp :: (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c Source #

Turn a `Comparison` function into a `CompareDirection` function.

Property: `dirToCmp f (fromCmp cmp) = f cmp`

normalMetaPriority :: MetaPriority Source #

lowMetaPriority :: MetaPriority Source #

highMetaPriority :: MetaPriority Source #

getMetaInfo :: MetaVariable -> Closure Range Source #

getMetaScope :: MetaVariable -> ScopeInfo Source #

getMetaEnv :: MetaVariable -> TCEnv Source #

getMetaSig :: MetaVariable -> Signature Source #

getMetaRelevance :: MetaVariable -> Relevance Source #

getMetaModality :: MetaVariable -> Modality Source #

metaFrozen :: Lens' Frozen MetaVariable Source #

_mvInfo :: Lens' MetaInfo MetaVariable Source #

sigSections :: Lens' Sections Signature Source #

sigDefinitions :: Lens' Definitions Signature Source #

sigRewriteRules :: Lens' RewriteRuleMap Signature Source #

secTelescope :: Lens' Telescope Section Source #

emptySignature :: Signature Source #

defaultDisplayForm :: QName -> [LocalDisplayForm] Source #

By default, we have no display form.

theDefLens :: Lens' Defn Definition Source #

defaultDefn :: ArgInfo -> QName -> Type -> Language -> Defn -> Definition Source #

Create a definition with sensible defaults.

jsBackendName :: BackendName Source #

ghcBackendName :: BackendName Source #

noCompiledRep :: CompiledRepresentation Source #

modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo Source #

projDropPars :: Projection -> ProjOrigin -> Term Source #

Building the projection function (which drops the parameters).

projArgInfo :: Projection -> ArgInfo Source #

The info of the principal (record) argument.

setEtaEquality :: EtaEquality -> HasEta -> EtaEquality Source #

Make sure we do not overwrite a user specification.

emptyCompKit :: CompKit Source #

defaultAxiom :: Defn Source #

constTranspAxiom :: Defn Source #

recRecursive :: Defn -> Bool Source #

Is the record type recursive?

recEtaEquality :: Defn -> HasEta Source #

emptyFunction :: Defn Source #

A template for creating `Function` definitions, with sensible defaults.

funFlag :: FunctionFlag -> Lens' Bool Defn Source #

funStatic :: Lens' Bool Defn Source #

funInline :: Lens' Bool Defn Source #

funMacro :: Lens' Bool Defn Source #

isMacro :: Defn -> Bool Source #

isEmptyFunction :: Defn -> Bool Source #

Checking whether we are dealing with a function yet to be defined.

isCopatternLHS :: [Clause] -> Bool Source #

recCon :: Defn -> QName Source #

defIsRecord :: Defn -> Bool Source #

defIsDataOrRecord :: Defn -> Bool Source #

defConstructors :: Defn -> [QName] Source #

redReturn :: a -> ReduceM (Reduced a' a) Source #

redBind :: ReduceM (Reduced a a') -> (a -> b) -> (a' -> ReduceM (Reduced b b')) -> ReduceM (Reduced b b') Source #

Conceptually: `redBind m f k = either (return . Left . f) k =<< m`

notReduced :: a -> MaybeReduced a Source #

reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term) Source #

allReductions :: AllowedReductions Source #

Not quite all reductions (skip non-terminating reductions)

reallyAllReductions :: AllowedReductions Source #

reduceAllDefs :: ReduceDefs Source #

locallyReduceDefs :: MonadTCEnv m => ReduceDefs -> m a -> m a Source #

locallyReduceAllDefs :: MonadTCEnv m => m a -> m a Source #

shouldReduceDef :: MonadTCEnv m => QName -> m Bool Source #

locallyReconstructed :: MonadTCEnv m => m a -> m a Source #

isReconstructed :: MonadTCEnv m => m Bool Source #

primFun :: QName -> Arity -> ([Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun Source #

defClauses :: Definition -> [Clause] Source #

defCompiled :: Definition -> Maybe CompiledClauses Source #

defParameters :: Definition -> Maybe Nat Source #

defInverse :: Definition -> FunctionInverse Source #

defCompilerPragmas :: BackendName -> Definition -> [CompilerPragma] Source #

defDelayed :: Definition -> Delayed Source #

Are the clauses of this definition delayed?

defNonterminating :: Definition -> Bool Source #

Has the definition failed the termination checker?

defTerminationUnconfirmed :: Definition -> Bool Source #

Has the definition not termination checked or did the check fail?

defAbstract :: Definition -> IsAbstract Source #

defForced :: Definition -> [IsForced] Source #

ifTopLevelAndHighlightingLevelIsOr :: MonadTCEnv tcm => HighlightingLevel -> Bool -> tcm () -> tcm () Source #

`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`.

ifTopLevelAndHighlightingLevelIs :: MonadTCEnv tcm => HighlightingLevel -> tcm () -> tcm () Source #

`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`.

initEnv :: TCEnv Source #

defaultUnquoteFlags :: UnquoteFlags Source #

unquoteNormalise :: Lens' Bool UnquoteFlags Source #

eUnquoteNormalise :: Lens' Bool TCEnv Source #

eContext :: Lens' Context TCEnv Source #

eLetBindings :: Lens' LetBindings TCEnv Source #

eCurrentModule :: Lens' ModuleName TCEnv Source #

eCurrentPath :: Lens' (Maybe AbsolutePath) TCEnv Source #

eAnonymousModules :: Lens' [(ModuleName, Nat)] TCEnv Source #

eImportPath :: Lens' [TopLevelModuleName] TCEnv Source #

eMutualBlock :: Lens' (Maybe MutualId) TCEnv Source #

eTerminationCheck :: Lens' (TerminationCheck ()) TCEnv Source #

eCoverageCheck :: Lens' CoverageCheck TCEnv Source #

eMakeCase :: Lens' Bool TCEnv Source #

eSolvingConstraints :: Lens' Bool TCEnv Source #

eCheckingWhere :: Lens' Bool TCEnv Source #

eWorkingOnTypes :: Lens' Bool TCEnv Source #

eAssignMetas :: Lens' Bool TCEnv Source #

eActiveProblems :: Lens' (Set ProblemId) TCEnv Source #

eAbstractMode :: Lens' AbstractMode TCEnv Source #

eModality :: Lens' Modality TCEnv Source #

eRelevance :: Lens' Relevance TCEnv Source #

eQuantity :: Lens' Quantity TCEnv Source #

eSplitOnStrict :: Lens' Bool TCEnv Source #

eDisplayFormsEnabled :: Lens' Bool TCEnv Source #

eRange :: Lens' Range TCEnv Source #

eHighlightingRange :: Lens' Range TCEnv Source #

eCall :: Lens' (Maybe (Closure Call)) TCEnv Source #

eHighlightingLevel :: Lens' HighlightingLevel TCEnv Source #

eHighlightingMethod :: Lens' HighlightingMethod TCEnv Source #

eExpandLast :: Lens' ExpandHidden TCEnv Source #

eAppDef :: Lens' (Maybe QName) TCEnv Source #

eSimplification :: Lens' Simplification TCEnv Source #

eAllowedReductions :: Lens' AllowedReductions TCEnv Source #

eReduceDefs :: Lens' ReduceDefs TCEnv Source #

eReconstructed :: Lens' Bool TCEnv Source #

eInjectivityDepth :: Lens' Int TCEnv Source #

eCompareBlocked :: Lens' Bool TCEnv Source #

ePrintDomainFreePi :: Lens' Bool TCEnv Source #

ePrintMetasBare :: Lens' Bool TCEnv Source #

eInsideDotPattern :: Lens' Bool TCEnv Source #

eUnquoteFlags :: Lens' UnquoteFlags TCEnv Source #

eInstanceDepth :: Lens' Int TCEnv Source #

eIsDebugPrinting :: Lens' Bool TCEnv Source #

ePrintingPatternLambdas :: Lens' [QName] TCEnv Source #

eCallByNeed :: Lens' Bool TCEnv Source #

eCurrentCheckpoint :: Lens' CheckpointId TCEnv Source #

eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv Source #

eGeneralizeMetas :: Lens' DoGeneralize TCEnv Source #

eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv Source #

eActiveBackendName :: Lens' (Maybe BackendName) TCEnv Source #

eConflComputingOverlap :: Lens' Bool TCEnv Source #

eCurrentlyElaborating :: Lens' Bool TCEnv Source #

aDefToMode :: IsAbstract -> AbstractMode Source #

aModeToDef :: AbstractMode -> Maybe IsAbstract Source #

isDontExpandLast :: ExpandHidden -> Bool Source #

recordFieldWarningToError :: RecordFieldWarning -> TypeError Source #

warningName :: Warning -> WarningName Source #

tcWarningOrigin :: TCWarning -> SrcFile Source #

sizedTypesOption :: HasOptions m => m Bool Source #

guardednessOption :: HasOptions m => m Bool Source #

withoutKOption :: HasOptions m => m Bool Source #

enableCaching :: HasOptions m => m Bool Source #

mapRedEnv :: (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv Source #

mapRedSt :: (TCState -> TCState) -> ReduceEnv -> ReduceEnv Source #

mapRedEnvSt :: (TCEnv -> TCEnv) -> (TCState -> TCState) -> ReduceEnv -> ReduceEnv Source #

reduceEnv :: Lens' TCEnv ReduceEnv Source #

reduceSt :: Lens' TCState ReduceEnv Source #

onReduceEnv :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a Source #

fmapReduce :: (a -> b) -> ReduceM a -> ReduceM b Source #

apReduce :: ReduceM (a -> b) -> ReduceM a -> ReduceM b Source #

thenReduce :: ReduceM a -> ReduceM b -> ReduceM b Source #

beforeReduce :: ReduceM a -> ReduceM b -> ReduceM a Source #

bindReduce :: ReduceM a -> (a -> ReduceM b) -> ReduceM b Source #

runReduceM :: ReduceM a -> TCM a Source #

runReduceF :: (a -> ReduceM b) -> TCM (a -> b) Source #

useR :: ReadTCState m => Lens' a TCState -> m a Source #

askR :: ReduceM ReduceEnv Source #

localR :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a Source #

asksTC :: MonadTCEnv m => (TCEnv -> a) -> m a Source #

viewTC :: MonadTCEnv m => Lens' a TCEnv -> m a Source #

locallyTC :: MonadTCEnv m => Lens' a TCEnv -> (a -> a) -> m b -> m b Source #

Modify the lens-indicated part of the `TCEnv` in a subcomputation.

getsTC :: ReadTCState m => (TCState -> a) -> m a Source #

modifyTC' :: MonadTCState m => (TCState -> TCState) -> m () Source #

A variant of `modifyTC` in which the computation is strict in the new state.

useTC :: ReadTCState m => Lens' a TCState -> m a Source #

setTCLens :: MonadTCState m => Lens' a TCState -> a -> m () infix 4 Source #

Overwrite the part of the `TCState` focused on by the lens.

modifyTCLens :: MonadTCState m => Lens' a TCState -> (a -> a) -> m () Source #

Modify the part of the `TCState` focused on by the lens.

modifyTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m a) -> m () Source #

Modify a part of the state monadically.

stateTCLens :: MonadTCState m => Lens' a TCState -> (a -> (r, a)) -> m r Source #

Modify the part of the `TCState` focused on by the lens, and return some result.

stateTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m (r, a)) -> m r Source #

Modify a part of the state monadically, and return some result.

runBlocked :: Monad m => BlockT m a -> m (Either Blocker a) Source #

mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a Source #

pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a Source #

returnTCMT :: Applicative m => a -> TCMT m a Source #

bindTCMT :: Monad m => TCMT m a -> (a -> TCMT m b) -> TCMT m b Source #

thenTCMT :: Applicative m => TCMT m a -> TCMT m b -> TCMT m b Source #

fmapTCMT :: Functor m => (a -> b) -> TCMT m a -> TCMT m b Source #

apTCMT :: Applicative m => TCMT m (a -> b) -> TCMT m a -> TCMT m b Source #

catchError_ :: TCM a -> (TCErr -> TCM a) -> TCM a Source #

Preserve the state of the failing computation.

finally_ :: TCM a -> TCM b -> TCM a Source #

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.

internalError :: (HasCallStack, MonadTCM tcm) => String -> tcm a Source #

locatedTypeError :: MonadTCError m => (a -> TypeError) -> HasCallStack => a -> m b Source #

Utility function for 1-arg constructed type errors. Note that the `HasCallStack` constraint is on the *resulting* function.

genericError :: (HasCallStack, MonadTCError m) => String -> m a Source #

genericDocError :: (HasCallStack, MonadTCError m) => Doc -> m a Source #

typeError' :: MonadTCError m => CallStack -> TypeError -> m a Source #

typeError :: (HasCallStack, MonadTCError m) => TypeError -> m a Source #

typeError'_ :: (MonadTCEnv m, ReadTCState m) => CallStack -> TypeError -> m TCErr Source #

typeError_ :: (HasCallStack, MonadTCEnv m, ReadTCState m) => TypeError -> m TCErr Source #

runTCM :: MonadIO m => TCEnv -> TCState -> TCMT m a -> m (a, TCState) Source #

Running the type checking monad (most general form).

runTCMTop :: TCM a -> IO (Either TCErr a) Source #

Running the type checking monad on toplevel (with initial state).

runTCMTop' :: MonadIO m => TCMT m a -> m a Source #

runSafeTCM :: TCM a -> TCState -> IO (a, TCState) Source #

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

forkTCM :: TCM a -> TCM () Source #

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.

patternInTeleName :: String Source #

Base name for patterns in telescopes

extendedLambdaName :: String Source #

Base name for extended lambda patterns

isExtendedLambdaName :: QName -> Bool Source #

Check whether we have an definition from an extended lambda.

absurdLambdaName :: String Source #

Name of absurdLambda definitions.

isAbsurdLambdaName :: QName -> Bool Source #

Check whether we have an definition from an absurd lambda.

generalizedFieldName :: String Source #

Base name for generalized variable projections

getGeneralizedFieldName :: QName -> Maybe String Source #

Check whether we have a generalized variable field

getIncludeDirs :: HasOptions m => m [AbsolutePath] Source #

Gets the include directories.

Precondition: `optAbsoluteIncludePaths` must be nonempty (i.e. `setCommandLineOptions` must have run).

libToTCM :: LibM a -> TCM a Source #

class (MonadTCEnv m, ReadTCState m) => MonadInteractionPoints m where Source #

Minimal complete definition

Nothing

Methods

freshInteractionId :: m InteractionId Source #

default freshInteractionId :: (MonadTrans t, MonadInteractionPoints n, t n ~ m) => m InteractionId Source #

modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> m () Source #

default modifyInteractionPoints :: (MonadTrans t, MonadInteractionPoints n, t n ~ m) => (InteractionPoints -> InteractionPoints) -> m () Source #

#### Instances

Instances details

MonadInteractionPoints TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods freshInteractionId :: TCM InteractionId Source # modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> TCM () Source #
(PureTCM m, MonadBlock m) => MonadInteractionPoints (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods freshInteractionId :: PureConversionT m InteractionId Source # modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> PureConversionT m () Source #
MonadInteractionPoints m => MonadInteractionPoints (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods freshInteractionId :: IdentityT m InteractionId Source # modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> IdentityT m () Source #
MonadInteractionPoints m => MonadInteractionPoints (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods freshInteractionId :: ReaderT r m InteractionId Source # modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> ReaderT r m () Source #
MonadInteractionPoints m => MonadInteractionPoints (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods freshInteractionId :: StateT s m InteractionId Source # modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> StateT s m () Source #

addImport :: ModuleName -> TCM () Source #

addImportCycleCheck :: TopLevelModuleName -> TCM a -> TCM a Source #

getImports :: TCM (Set ModuleName) Source #

isImported :: ModuleName -> TCM Bool Source #

getImportPath :: TCM [TopLevelModuleName] Source #

visitModule :: ModuleInfo -> TCM () Source #

setVisitedModules :: VisitedModules -> TCM () Source #

getVisitedModules :: ReadTCState m => m VisitedModules Source #

getPrettyVisitedModules :: ReadTCState m => m Doc Source #

getVisitedModule :: ReadTCState m => TopLevelModuleName -> m (Maybe ModuleInfo) Source #

getDecodedModules :: TCM DecodedModules Source #

setDecodedModules :: DecodedModules -> TCM () Source #

getDecodedModule :: TopLevelModuleName -> TCM (Maybe ModuleInfo) Source #

storeDecodedModule :: ModuleInfo -> TCM () Source #

dropDecodedModule :: TopLevelModuleName -> TCM () Source #

withImportPath :: [TopLevelModuleName] -> TCM a -> TCM a Source #

checkForImportCycle :: TCM () Source #

Assumes that the first module in the import path is the module we are worried about.

currentModule :: MonadTCEnv m => m ModuleName Source #

Get the name of the current module, if any.

withCurrentModule :: MonadTCEnv m => ModuleName -> m a -> m a Source #

Set the name of the current module.

getCurrentPath :: MonadTCEnv m => m AbsolutePath Source #

Get the path of the currently checked file

getAnonymousVariables :: MonadTCEnv m => ModuleName -> m Nat Source #

Get the number of variables bound by anonymous modules.

withAnonymousModule :: ModuleName -> Nat -> TCM a -> TCM a Source #

Add variables bound by an anonymous module.

withEnv :: MonadTCEnv m => TCEnv -> m a -> m a Source #

Set the current environment to the given

getEnv :: TCM TCEnv Source #

Get the current environment

withHighlightingLevel :: HighlightingLevel -> TCM a -> TCM a Source #

Set highlighting level

doExpandLast :: TCM a -> TCM a Source #

Restore setting for `ExpandLast` to default.

dontExpandLast :: TCM a -> TCM a Source #

reallyDontExpandLast :: TCM a -> TCM a Source #

performedSimplification :: MonadTCEnv m => m a -> m a Source #

If the reduced did a proper match (constructor or literal pattern), then record this as simplification step.

performedSimplification' :: MonadTCEnv m => Simplification -> m a -> m a Source #

getSimplification :: MonadTCEnv m => m Simplification Source #

updateAllowedReductions :: (AllowedReductions -> AllowedReductions) -> TCEnv -> TCEnv Source #

Lens for `AllowedReductions`.

modifyAllowedReductions :: MonadTCEnv m => (AllowedReductions -> AllowedReductions) -> m a -> m a Source #

putAllowedReductions :: MonadTCEnv m => AllowedReductions -> m a -> m a Source #

onlyReduceProjections :: MonadTCEnv m => m a -> m a Source #

Reduce `Def f vs` only if `f` is a projection.

allowAllReductions :: MonadTCEnv m => m a -> m a Source #

Allow all reductions except for non-terminating functions (default).

allowNonTerminatingReductions :: MonadTCEnv m => m a -> m a Source #

Allow all reductions including non-terminating functions.

onlyReduceTypes :: MonadTCEnv m => m a -> m a Source #

Allow all reductions when reducing types. Otherwise only allow inlined functions to be unfolded.

typeLevelReductions :: MonadTCEnv m => m a -> m a Source #

Update allowed reductions when working on types

insideDotPattern :: TCM a -> TCM a Source #

isInsideDotPattern :: TCM Bool Source #

callByName :: TCM a -> TCM a Source #

Don't use call-by-need evaluation for the given computation.

class MonadTCEnv m => MonadAddContext m where Source #

Minimal complete definition

Nothing

Methods

addCtx :: Name -> Dom Type -> m a -> m a Source #

`addCtx x arg cont` add a variable to the context.

Chooses an unused `Name`.

Warning: Does not update module parameter substitution!

default addCtx :: (MonadAddContext n, MonadTransControl t, t n ~ m) => Name -> Dom Type -> m a -> m a Source #

addLetBinding' :: Name -> Term -> Dom Type -> m a -> m a Source #

Add a let bound variable to the context

default addLetBinding' :: (MonadAddContext n, MonadTransControl t, t n ~ m) => Name -> Term -> Dom Type -> m a -> m a Source #

updateContext :: Substitution -> (Context -> Context) -> m a -> m a Source #

Update the context. Requires a substitution that transports things living in the old context to the new.

default updateContext :: (MonadAddContext n, MonadTransControl t, t n ~ m) => Substitution -> (Context -> Context) -> m a -> m a Source #

withFreshName :: Range -> ArgName -> (Name -> m a) -> m a Source #

default withFreshName :: (MonadAddContext n, MonadTransControl t, t n ~ m) => Range -> ArgName -> (Name -> m a) -> m a Source #

#### Instances

Instances details

MonadAddContext TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods addCtx :: Name -> Dom Type -> TerM a -> TerM a Source # addLetBinding' :: Name -> Term -> Dom Type -> TerM a -> TerM a Source # updateContext :: Substitution -> (Context -> Context) -> TerM a -> TerM a Source # withFreshName :: Range -> ArgName -> (Name -> TerM a) -> TerM a Source #
MonadAddContext ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Reduce.Monad Methods addCtx :: Name -> Dom Type -> ReduceM a -> ReduceM a Source # addLetBinding' :: Name -> Term -> Dom Type -> ReduceM a -> ReduceM a Source # updateContext :: Substitution -> (Context -> Context) -> ReduceM a -> ReduceM a Source # withFreshName :: Range -> ArgName -> (Name -> ReduceM a) -> ReduceM a Source #
MonadAddContext TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addCtx :: Name -> Dom Type -> TCM a -> TCM a Source # addLetBinding' :: Name -> Term -> Dom Type -> TCM a -> TCM a Source # updateContext :: Substitution -> (Context -> Context) -> TCM a -> TCM a Source # withFreshName :: Range -> ArgName -> (Name -> TCM a) -> TCM a Source #
MonadAddContext NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods addCtx :: Name -> Dom Type -> NLM a -> NLM a Source # addLetBinding' :: Name -> Term -> Dom Type -> NLM a -> NLM a Source # updateContext :: Substitution -> (Context -> Context) -> NLM a -> NLM a Source # withFreshName :: Range -> ArgName -> (Name -> NLM a) -> NLM a Source #
MonadAddContext m => MonadAddContext (PureConversionT m) Source # |

Instance details

Defined in Agda.TypeChecking.Conversion.Pure

Methods

addCtx :: Name -> Dom Type -> PureConversionT m a -> PureConversionT m a Source #

addLetBinding' :: Name -> Term -> Dom Type -> PureConversionT m a -> PureConversionT m a Source #

updateContext :: Substitution -> (Context -> Context) -> PureConversionT m a -> PureConversionT m a Source #

withFreshName :: Range -> ArgName -> (Name -> PureConversionT m a) -> PureConversionT m a Source #

MonadAddContext m => MonadAddContext (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addCtx :: Name -> Dom Type -> BlockT m a -> BlockT m a Source # addLetBinding' :: Name -> Term -> Dom Type -> BlockT m a -> BlockT m a Source # updateContext :: Substitution -> (Context -> Context) -> BlockT m a -> BlockT m a Source # withFreshName :: Range -> ArgName -> (Name -> BlockT m a) -> BlockT m a Source #
MonadAddContext m => MonadAddContext (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods addCtx :: Name -> Dom Type -> NamesT m a -> NamesT m a Source # addLetBinding' :: Name -> Term -> Dom Type -> NamesT m a -> NamesT m a Source # updateContext :: Substitution -> (Context -> Context) -> NamesT m a -> NamesT m a Source # withFreshName :: Range -> ArgName -> (Name -> NamesT m a) -> NamesT m a Source #
MonadAddContext m => MonadAddContext (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addCtx :: Name -> Dom Type -> ListT m a -> ListT m a Source # addLetBinding' :: Name -> Term -> Dom Type -> ListT m a -> ListT m a Source # updateContext :: Substitution -> (Context -> Context) -> ListT m a -> ListT m a Source # withFreshName :: Range -> ArgName -> (Name -> ListT m a) -> ListT m a Source #
MonadAddContext m => MonadAddContext (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addCtx :: Name -> Dom Type -> MaybeT m a -> MaybeT m a Source # addLetBinding' :: Name -> Term -> Dom Type -> MaybeT m a -> MaybeT m a Source # updateContext :: Substitution -> (Context -> Context) -> MaybeT m a -> MaybeT m a Source # withFreshName :: Range -> ArgName -> (Name -> MaybeT m a) -> MaybeT m a Source #
MonadAddContext m => MonadAddContext (ExceptT e m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> ExceptT e m a -> ExceptT e m a Source #

addLetBinding' :: Name -> Term -> Dom Type -> ExceptT e m a -> ExceptT e m a Source #

updateContext :: Substitution -> (Context -> Context) -> ExceptT e m a -> ExceptT e m a Source #

withFreshName :: Range -> ArgName -> (Name -> ExceptT e m a) -> ExceptT e m a Source #

MonadAddContext m => MonadAddContext (IdentityT m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> IdentityT m a -> IdentityT m a Source #

addLetBinding' :: Name -> Term -> Dom Type -> IdentityT m a -> IdentityT m a Source #

updateContext :: Substitution -> (Context -> Context) -> IdentityT m a -> IdentityT m a Source #

withFreshName :: Range -> ArgName -> (Name -> IdentityT m a) -> IdentityT m a Source #

MonadAddContext m => MonadAddContext (ReaderT r m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> ReaderT r m a -> ReaderT r m a Source #

addLetBinding' :: Name -> Term -> Dom Type -> ReaderT r m a -> ReaderT r m a Source #

updateContext :: Substitution -> (Context -> Context) -> ReaderT r m a -> ReaderT r m a Source #

withFreshName :: Range -> ArgName -> (Name -> ReaderT r m a) -> ReaderT r m a Source #

MonadAddContext m => MonadAddContext (StateT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addCtx :: Name -> Dom Type -> StateT r m a -> StateT r m a Source # addLetBinding' :: Name -> Term -> Dom Type -> StateT r m a -> StateT r m a Source # updateContext :: Substitution -> (Context -> Context) -> StateT r m a -> StateT r m a Source # withFreshName :: Range -> ArgName -> (Name -> StateT r m a) -> StateT r m a Source #
(Monoid w, MonadAddContext m) => MonadAddContext (WriterT w m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Context

Methods

addCtx :: Name -> Dom Type -> WriterT w m a -> WriterT w m a Source #

addLetBinding' :: Name -> Term -> Dom Type -> WriterT w m a -> WriterT w m a Source #

updateContext :: Substitution -> (Context -> Context) -> WriterT w m a -> WriterT w m a Source #

withFreshName :: Range -> ArgName -> (Name -> WriterT w m a) -> WriterT w m a Source #

checkpointSubstitution :: MonadTCEnv tcm => CheckpointId -> tcm Substitution Source #

Get the substitution from the context at a given checkpoint to the current context.

class (Functor m, Applicative m, MonadFail m) => HasBuiltins m where Source #

Minimal complete definition

Nothing

Methods

getBuiltinThing :: String -> m (Maybe (Builtin PrimFun)) Source #

default getBuiltinThing :: (MonadTrans t, HasBuiltins n, t n ~ m) => String -> m (Maybe (Builtin PrimFun)) Source #

#### Instances

Instances details

HasBuiltins AbsToCon Source # |
Instance details Defined in Agda.Syntax.Translation.AbstractToConcrete Methods getBuiltinThing :: String -> AbsToCon (Maybe (Builtin PrimFun)) Source #
HasBuiltins TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods getBuiltinThing :: String -> TerM (Maybe (Builtin PrimFun)) Source #
HasBuiltins ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Reduce.Monad Methods getBuiltinThing :: String -> ReduceM (Maybe (Builtin PrimFun)) Source #
HasBuiltins NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods getBuiltinThing :: String -> NLM (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods getBuiltinThing :: String -> PureConversionT m (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> BlockT m (Maybe (Builtin PrimFun)) Source #
MonadIO m => HasBuiltins (TCMT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> TCMT m (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods getBuiltinThing :: String -> NamesT m (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> ListT m (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> MaybeT m (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (ExceptT e m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> ExceptT e m (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> IdentityT m (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (ReaderT e m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> ReaderT e m (Maybe (Builtin PrimFun)) Source #
HasBuiltins m => HasBuiltins (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> StateT s m (Maybe (Builtin PrimFun)) Source #
(HasBuiltins m, Monoid w) => HasBuiltins (WriterT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Builtin Methods getBuiltinThing :: String -> WriterT w m (Maybe (Builtin PrimFun)) Source #

class TraceS a where Source #

Debug print some lines if the verbosity level for the given `VerboseKey` is at least `VerboseLevel`.

Note: In the presence of `OverloadedStrings`, just @`traceS key level "Literate string"` `gives an` Ambiguous type variable`error in` GHC@. Use the legacy functions `traceSLn` and `traceSDoc` instead then.

Methods

traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> a -> m c -> m c Source #

#### Instances

Instances details

TraceS Doc Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> Doc -> m c -> m c Source #
TraceS String Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m c -> m c Source #
TraceS (TCM Doc) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m c -> m c Source #
TraceS [TCM Doc] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> [TCM Doc] -> m c -> m c Source #
TraceS [Doc] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> [Doc] -> m c -> m c Source #
TraceS [String] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> [String] -> m c -> m c Source #

class ReportS a where Source #

Debug print some lines if the verbosity level for the given `VerboseKey` is at least `VerboseLevel`.

Note: In the presence of `OverloadedStrings`, just @`reportS key level "Literate string"` `gives an` Ambiguous type variable`error in` GHC@. Use the legacy functions `reportSLn` and `reportSDoc` instead then.

Methods

reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> a -> m () Source #

#### Instances

Instances details

ReportS Doc Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> Doc -> m () Source #
ReportS String Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () Source #
ReportS (TCM Doc) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m () Source #
ReportS [TCM Doc] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> [TCM Doc] -> m () Source #
ReportS [Doc] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> [Doc] -> m () Source #
ReportS [String] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Debug Methods reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> [String] -> m () Source #

defaultGetVerbosity :: HasOptions m => m Verbosity Source #

defaultIsDebugPrinting :: MonadTCEnv m => m Bool Source #

defaultNowDebugPrinting :: MonadTCEnv m => m a -> m a Source #

displayDebugMessage :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () Source #

Print a debug message if switched on.

catchAndPrintImpossible :: (CatchImpossible m, Monad m) => VerboseKey -> VerboseLevel -> m String -> m String Source #

During printing, catch internal errors of kind `Impossible` and print them.

reportSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () Source #

Conditionally println debug string.

__IMPOSSIBLE_VERBOSE__ :: (HasCallStack, MonadDebug m) => String -> m a Source #

reportSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m () Source #

Conditionally render debug `Doc` and print it.

reportResult :: MonadDebug m => VerboseKey -> VerboseLevel -> (a -> TCM Doc) -> m a -> m a Source #

Debug print the result of a computation.

unlessDebugPrinting :: MonadDebug m => m () -> m () Source #

traceSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a Source #

traceSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m a -> m a Source #

Conditionally render debug `Doc`, print it, and then continue.

openVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () Source #

closeVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> m () Source #

closeVerboseBracketException :: MonadDebug m => VerboseKey -> VerboseLevel -> m () Source #

parseVerboseKey :: VerboseKey -> [String] Source #

hasVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool Source #

Check whether a certain verbosity level is activated.

Precondition: The level must be non-negative.

hasExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool Source #

Check whether a certain verbosity level is activated (exact match).

whenExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m () Source #

Run a computation if a certain verbosity level is activated (exact match).

__CRASH_WHEN__ :: (HasCallStack, MonadTCM m, MonadDebug m) => VerboseKey -> VerboseLevel -> m () Source #

verboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m () Source #

Run a computation if a certain verbosity level is activated.

Precondition: The level must be non-negative.

applyWhenVerboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> (m a -> m a) -> m a -> m a Source #

Apply a function if a certain verbosity level is activated.

Precondition: The level must be non-negative.

verbosity :: VerboseKey -> Lens' VerboseLevel TCState Source #

Verbosity lens.

class ReadTCState m => MonadStatistics m where Source #

Minimal complete definition

Nothing

Methods

modifyCounter :: String -> (Integer -> Integer) -> m () Source #

default modifyCounter :: (MonadStatistics n, MonadTrans t, t n ~ m) => String -> (Integer -> Integer) -> m () Source #

#### Instances

Instances details

MonadStatistics TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods modifyCounter :: String -> (Integer -> Integer) -> TerM () Source #
MonadStatistics TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Statistics Methods modifyCounter :: String -> (Integer -> Integer) -> TCM () Source #
ReadTCState m => MonadStatistics (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods modifyCounter :: String -> (Integer -> Integer) -> PureConversionT m () Source #
MonadStatistics m => MonadStatistics (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Statistics Methods modifyCounter :: String -> (Integer -> Integer) -> MaybeT m () Source #
MonadStatistics m => MonadStatistics (ExceptT e m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Statistics Methods modifyCounter :: String -> (Integer -> Integer) -> ExceptT e m () Source #
MonadStatistics m => MonadStatistics (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Statistics Methods modifyCounter :: String -> (Integer -> Integer) -> ReaderT r m () Source #
MonadStatistics m => MonadStatistics (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Statistics Methods modifyCounter :: String -> (Integer -> Integer) -> StateT s m () Source #
(MonadStatistics m, Monoid w) => MonadStatistics (WriterT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Statistics Methods modifyCounter :: String -> (Integer -> Integer) -> WriterT w m () Source #

getStatistics :: ReadTCState m => m Statistics Source #

Get the statistics.

modifyStatistics :: (Statistics -> Statistics) -> TCM () Source #

Modify the statistics via given function.

tick :: MonadStatistics m => String -> m () Source #

Increase specified counter by `1`.

tickN :: MonadStatistics m => String -> Integer -> m () Source #

Increase specified counter by `n`.

tickMax :: MonadStatistics m => String -> Integer -> m () Source #

Set the specified counter to the maximum of its current value and `n`.

printStatistics :: (MonadDebug m, MonadTCEnv m, HasOptions m) => Int -> Maybe TopLevelModuleName -> Statistics -> m () Source #

Print the given statistics if verbosity "profile.ticks" is given.

class (Functor m, Applicative m, MonadFail m, HasOptions m, MonadDebug m, MonadTCEnv m) => HasConstInfo m where Source #

Minimal complete definition

Nothing

Methods

getConstInfo :: QName -> m Definition Source #

Lookup the definition of a name. The result is a closed thing, all free variables have been abstracted over.

getConstInfo' :: QName -> m (Either SigError Definition) Source #

Version that reports exceptions:

default getConstInfo' :: (HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m (Either SigError Definition) Source #

getRewriteRulesFor :: QName -> m RewriteRules Source #

Lookup the rewrite rules with the given head symbol.

default getRewriteRulesFor :: (HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m RewriteRules Source #

#### Instances

Instances details

HasConstInfo TerM Source # |
Instance details Defined in Agda.Termination.Monad Methods getConstInfo :: QName -> TerM Definition Source # getConstInfo' :: QName -> TerM (Either SigError Definition) Source # getRewriteRulesFor :: QName -> TerM RewriteRules Source #
HasConstInfo ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Reduce.Monad Methods getConstInfo :: QName -> ReduceM Definition Source # getConstInfo' :: QName -> ReduceM (Either SigError Definition) Source # getRewriteRulesFor :: QName -> ReduceM RewriteRules Source #
HasConstInfo NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch Methods getConstInfo :: QName -> NLM Definition Source # getConstInfo' :: QName -> NLM (Either SigError Definition) Source # getRewriteRulesFor :: QName -> NLM RewriteRules Source #
HasConstInfo m => HasConstInfo (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure Methods getConstInfo :: QName -> PureConversionT m Definition Source # getConstInfo' :: QName -> PureConversionT m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> PureConversionT m RewriteRules Source #
HasConstInfo m => HasConstInfo (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> BlockT m Definition Source # getConstInfo' :: QName -> BlockT m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> BlockT m RewriteRules Source #
HasConstInfo (TCMT IO) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> TCMT IO Definition Source # getConstInfo' :: QName -> TCMT IO (Either SigError Definition) Source # getRewriteRulesFor :: QName -> TCMT IO RewriteRules Source #
HasConstInfo m => HasConstInfo (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names Methods getConstInfo :: QName -> NamesT m Definition Source # getConstInfo' :: QName -> NamesT m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> NamesT m RewriteRules Source #
HasConstInfo m => HasConstInfo (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> ListT m Definition Source # getConstInfo' :: QName -> ListT m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> ListT m RewriteRules Source #
HasConstInfo m => HasConstInfo (ChangeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> ChangeT m Definition Source # getConstInfo' :: QName -> ChangeT m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> ChangeT m RewriteRules Source #
HasConstInfo m => HasConstInfo (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> MaybeT m Definition Source # getConstInfo' :: QName -> MaybeT m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> MaybeT m RewriteRules Source #
HasConstInfo m => HasConstInfo (ExceptT err m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> ExceptT err m Definition Source # getConstInfo' :: QName -> ExceptT err m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> ExceptT err m RewriteRules Source #
HasConstInfo m => HasConstInfo (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> IdentityT m Definition Source # getConstInfo' :: QName -> IdentityT m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> IdentityT m RewriteRules Source #
HasConstInfo m => HasConstInfo (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> ReaderT r m Definition Source # getConstInfo' :: QName -> ReaderT r m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> ReaderT r m RewriteRules Source #
HasConstInfo m => HasConstInfo (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> StateT s m Definition Source # getConstInfo' :: QName -> StateT s m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> StateT s m RewriteRules Source #
(Monoid w, HasConstInfo m) => HasConstInfo (WriterT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Signature Methods getConstInfo :: QName -> WriterT w m Definition Source # getConstInfo' :: QName -> WriterT w m (Either SigError Definition) Source # getRewriteRulesFor :: QName -> WriterT w m RewriteRules Source #

data SigError Source #

Signature lookup errors.

Constructors

SigUnknown String | The name is not in the signature; default error message.
SigAbstract | The name is not available, since it is abstract.

lookupSection :: (Functor m, ReadTCState m) => ModuleName -> m Telescope Source #

Lookup a section telescope.

If it doesn't exist, like in hierarchical top-level modules, the section telescope is empty.

inFreshModuleIfFreeParams :: TCM a -> TCM a Source #

Unless all variables in the context are module parameters, create a fresh module to capture the non-module parameters. Used when unquoting to make sure generated definitions work properly.

class (HasBuiltins m, HasConstInfo m, MonadAddContext m, MonadDebug m, MonadReduce m, MonadTCEnv m, ReadTCState m) => PureTCM m Source #

#### Instances

Instances details

PureTCM TerM Source # |
Instance details Defined in Agda.Termination.Monad
PureTCM ReduceM Source # |
Instance details Defined in Agda.TypeChecking.Reduce.Monad
PureTCM TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
PureTCM NLM Source # |
Instance details Defined in Agda.TypeChecking.Rewriting.NonLinMatch
(HasBuiltins m, HasConstInfo m, MonadAddContext m, MonadReduce m) => PureTCM (PureConversionT m) Source # |
Instance details Defined in Agda.TypeChecking.Conversion.Pure
PureTCM m => PureTCM (BlockT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
(HasBuiltins m, HasConstInfo m, MonadAddContext m, MonadReduce m) => PureTCM (NamesT m) Source # |
Instance details Defined in Agda.TypeChecking.Names
PureTCM m => PureTCM (ListT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
PureTCM m => PureTCM (MaybeT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
PureTCM m => PureTCM (ExceptT e m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
PureTCM m => PureTCM (IdentityT m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
PureTCM m => PureTCM (ReaderT r m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
PureTCM m => PureTCM (StateT s m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure
(PureTCM m, Monoid w) => PureTCM (WriterT w m) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Pure

cachingStarts :: (MonadDebug m, MonadTCState m, ReadTCState m) => m () Source #

To be called before any write or restore calls.

areWeCaching :: ReadTCState m => m Bool Source #

writeToCurrentLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => TypeCheckAction -> m () Source #

Writes a `TypeCheckAction` to the current log, using the current `PostScopeState`

restorePostScopeState :: (MonadDebug m, MonadTCState m) => PostScopeState -> m () Source #

localCache :: (MonadTCState m, ReadTCState m) => m a -> m a Source #

Runs the action and restores the current cache at the end of it.

withoutCache :: (MonadTCState m, ReadTCState m) => m a -> m a Source #

Runs the action without cache and restores the current cache at the end of it.

readFromCachedLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => m (Maybe (TypeCheckAction, PostScopeState)) Source #

Reads the next entry in the cached type check log, if present.

cleanCachedLog :: (MonadDebug m, MonadTCState m) => m () Source #

Empties the "to read" CachedState. To be used when it gets invalid.

activateLoadedFileCache :: (HasOptions m, MonadDebug m, MonadTCState m) => m () Source #

Makes sure that the `stLoadedFileCache` is `Just`, with a clean current log. Crashes is `stLoadedFileCache` is already active with a dirty log. Should be called when we start typechecking the current file.

cacheCurrentLog :: (MonadDebug m, MonadTCState m) => m () Source #

Caches the current type check log. Discardes the old cache. Does nothing if caching is inactive.

data SpeculateResult Source #

Constructors

SpeculateAbort |
SpeculateCommit |

resetState :: TCM () Source #

Resets the non-persistent part of the type checking state.

resetAllState :: TCM () Source #

Resets all of the type checking state.

Keep only `Benchmark` and backend information.

localTCState :: TCM a -> TCM a Source #

Restore `TCState` after performing subcomputation.

In contrast to `localState`, the `Benchmark` info from the subcomputation is saved.

localTCStateSaving :: TCM a -> TCM (a, TCState) Source #

Same as `localTCState` but also returns the state in which we were just before reverting it.

localTCStateSavingWarnings :: TCM a -> TCM a Source #

Same as `localTCState` but keep all warnings.

speculateTCState :: TCM (a, SpeculateResult) -> TCM a Source #

Allow rolling back the state changes of a TCM computation.

speculateTCState_ :: TCM SpeculateResult -> TCM () Source #

freshTCM :: TCM a -> TCM (Either TCErr a) Source #

A fresh TCM instance.

The computation is run in a fresh state, with the exception that the persistent state is preserved. If the computation changes the state, then these changes are ignored, except for changes to the persistent state. (Changes to the persistent state are also ignored if errors other than type errors or IO exceptions are encountered.)

lensPersistentState :: Lens' PersistentTCState TCState Source #

updatePersistentState :: (PersistentTCState -> PersistentTCState) -> TCState -> TCState Source #

modifyPersistentState :: (PersistentTCState -> PersistentTCState) -> TCM () Source #

lensAccumStatisticsP :: Lens' Statistics PersistentTCState Source #

Lens for `stAccumStatistics`.

lensAccumStatistics :: Lens' Statistics TCState Source #

getScope :: ReadTCState m => m ScopeInfo Source #

Get the current scope.

setScope :: ScopeInfo -> TCM () Source #

Set the current scope.

modifyScope_ :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m () Source #

Modify the current scope without updating the inverse maps.

modifyScope :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m () Source #

Modify the current scope.

useScope :: ReadTCState m => Lens' a ScopeInfo -> m a Source #

Get a part of the current scope.

locallyScope :: ReadTCState m => Lens' a ScopeInfo -> (a -> a) -> m b -> m b Source #

Run a computation in a modified scope.

withScope :: ReadTCState m => ScopeInfo -> m a -> m (a, ScopeInfo) Source #

Run a computation in a local scope.

withScope_ :: ReadTCState m => ScopeInfo -> m a -> m a Source #

Same as `withScope`, but discard the scope from the computation.

localScope :: TCM a -> TCM a Source #

Discard any changes to the scope by a computation.

notInScopeError :: QName -> TCM a Source #

Scope error.

notInScopeWarning :: QName -> TCM () Source #

printScope :: String -> Int -> String -> TCM () Source #

Debug print the scope.

modifySignature :: MonadTCState m => (Signature -> Signature) -> m () Source #

modifyImportedSignature :: MonadTCState m => (Signature -> Signature) -> m () Source #

getSignature :: ReadTCState m => m Signature Source #

modifyGlobalDefinition :: MonadTCState m => QName -> (Definition -> Definition) -> m () Source #

Update a possibly imported definition. Warning: changes made to imported definitions (during type checking) will not persist outside the current module. This function is currently used to update the compiled representation of a function during compilation.

setSignature :: MonadTCState m => Signature -> m () Source #

withSignature :: (ReadTCState m, MonadTCState m) => Signature -> m a -> m a Source #

Run some computation in a different signature, restore original signature.

addRewriteRulesFor :: QName -> RewriteRules -> [QName] -> Signature -> Signature Source #

setMatchableSymbols :: QName -> [QName] -> Signature -> Signature Source #

lookupDefinition :: QName -> Signature -> Maybe Definition Source #

updateDefinitions :: (Definitions -> Definitions) -> Signature -> Signature Source #

updateDefinition :: QName -> (Definition -> Definition) -> Signature -> Signature Source #

updateTheDef :: (Defn -> Defn) -> Definition -> Definition Source #

updateDefType :: (Type -> Type) -> Definition -> Definition Source #

updateDefArgOccurrences :: ([Occurrence] -> [Occurrence]) -> Definition -> Definition Source #

updateDefPolarity :: ([Polarity] -> [Polarity]) -> Definition -> Definition Source #

updateDefCompiledRep :: (CompiledRepresentation -> CompiledRepresentation) -> Definition -> Definition Source #

addCompilerPragma :: BackendName -> CompilerPragma -> Definition -> Definition Source #

updateFunClauses :: ([Clause] -> [Clause]) -> Defn -> Defn Source #

updateCovering :: ([Clause] -> [Clause]) -> Defn -> Defn Source #

updateCompiledClauses :: (Maybe CompiledClauses -> Maybe CompiledClauses) -> Defn -> Defn Source #

updateDefCopatternLHS :: (Bool -> Bool) -> Definition -> Definition Source #

updateDefBlocked :: (Blocked_ -> Blocked_) -> Definition -> Definition Source #

setTopLevelModule :: QName -> TCM () Source #

Set the top-level module. This affects the global module id of freshly generated names.

withTopLevelModule :: QName -> TCM a -> TCM a Source #

Use a different top-level module for a computation. Used when generating names for imported modules.

currentModuleNameHash :: ReadTCState m => m ModuleNameHash Source #

addForeignCode :: BackendName -> String -> TCM () Source #

getInteractionOutputCallback :: ReadTCState m => m InteractionOutputCallback Source #

appInteractionOutputCallback :: Response -> TCM () Source #

setInteractionOutputCallback :: InteractionOutputCallback -> TCM () Source #

getPatternSyns :: ReadTCState m => m PatternSynDefns Source #

setPatternSyns :: PatternSynDefns -> TCM () Source #

modifyPatternSyns :: (PatternSynDefns -> PatternSynDefns) -> TCM () Source #

Lens for `stPatternSyns`.

getPatternSynImports :: ReadTCState m => m PatternSynDefns Source #

getAllPatternSyns :: ReadTCState m => m PatternSynDefns Source #

Get both local and imported pattern synonyms

lookupPatternSyn :: AmbiguousQName -> TCM PatternSynDefn Source #

lookupSinglePatternSyn :: QName -> TCM PatternSynDefn Source #

theBenchmark :: TCState -> Benchmark Source #

Lens getter for `Benchmark` from `TCState`.

updateBenchmark :: (Benchmark -> Benchmark) -> TCState -> TCState Source #

Lens map for `Benchmark`.

modifyBenchmark :: (Benchmark -> Benchmark) -> TCM () Source #

Lens modify for `Benchmark`.

addImportedInstances :: Signature -> TCM () Source #

Look through the signature and reconstruct the instance table.

updateInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCState -> TCState Source #

Lens for `stInstanceDefs`.

modifyInstanceDefs :: (TempInstanceTable -> TempInstanceTable) -> TCM () Source #

getAllInstanceDefs :: TCM TempInstanceTable Source #

getAnonInstanceDefs :: TCM (Set QName) Source #

clearAnonInstanceDefs :: TCM () Source #

Remove all instances whose type is still unresolved.

addUnknownInstance :: QName -> TCM () Source #

Add an instance whose type is still unresolved.

addNamedInstance Source #

Arguments

:: QName | Name of the instance.
-> QName | Name of the class.
-> TCM () |

Add instance to some ``class'`.

class (MonadTCEnv m, ReadTCState m) => MonadTrace m where Source #

Minimal complete definition

traceClosureCall

Methods

traceCall :: Call -> m a -> m a Source #

Record a function call in the trace.

traceCallM :: m Call -> m a -> m a Source #

traceCallCPS :: Call -> ((a -> m b) -> m b) -> (a -> m b) -> m b Source #

Reset `envCall` to previous value in the continuation.

Caveat: if the last `traceCall` did not set an `interestingCall`, for example, only set the `Range` with `SetRange`, we will revert to the last interesting call.

traceClosureCall :: Closure Call -> m a -> m a Source #

printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> m () Source #

Lispify and print the given highlighting information.

default printHighlightingInfo :: (MonadTrans t, MonadTrace n, t n ~ m) => RemoveTokenBasedHighlighting -> HighlightingInfo -> m () Source #

#### Instances

Instances details

MonadTrace TCM Source # |
Instance details Defined in Agda.TypeChecking.Monad.Trace Methods traceCall :: Call -> TCM a -> TCM a Source # traceCallM :: TCM Call -> TCM a -> TCM a Source # traceCallCPS :: Call -> ((a -> TCM b) -> TCM b) -> (a -> TCM b) -> TCM b Source # traceClosureCall :: Closure Call -> TCM a -> TCM a Source # printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> TCM () Source #
MonadTrace m => MonadTrace (ExceptT e m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Trace

Methods

traceCall :: Call -> ExceptT e m a -> ExceptT e m a Source #

traceCallM :: ExceptT e m Call -> ExceptT e m a -> ExceptT e m a Source #

traceCallCPS :: Call -> ((a -> ExceptT e m b) -> ExceptT e m b) -> (a -> ExceptT e m b) -> ExceptT e m b Source #

traceClosureCall :: Closure Call -> ExceptT e m a -> ExceptT e m a Source #

printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> ExceptT e m () Source #

MonadTrace m => MonadTrace (IdentityT m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Trace

Methods

traceCall :: Call -> IdentityT m a -> IdentityT m a Source #

traceCallM :: IdentityT m Call -> IdentityT m a -> IdentityT m a Source #

traceCallCPS :: Call -> ((a -> IdentityT m b) -> IdentityT m b) -> (a -> IdentityT m b) -> IdentityT m b Source #

traceClosureCall :: Closure Call -> IdentityT m a -> IdentityT m a Source #

printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> IdentityT m () Source #

MonadTrace m => MonadTrace (ReaderT r m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Trace

Methods

traceCall :: Call -> ReaderT r m a -> ReaderT r m a Source #

traceCallM :: ReaderT r m Call -> ReaderT r m a -> ReaderT r m a Source #

traceCallCPS :: Call -> ((a -> ReaderT r m b) -> ReaderT r m b) -> (a -> ReaderT r m b) -> ReaderT r m b Source #

traceClosureCall :: Closure Call -> ReaderT r m a -> ReaderT r m a Source #

printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> ReaderT r m () Source #

MonadTrace m => MonadTrace (StateT s m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Trace

Methods

traceCall :: Call -> StateT s m a -> StateT s m a Source #

traceCallM :: StateT s m Call -> StateT s m a -> StateT s m a Source #

traceCallCPS :: Call -> ((a -> StateT s m b) -> StateT s m b) -> (a -> StateT s m b) -> StateT s m b Source #

traceClosureCall :: Closure Call -> StateT s m a -> StateT s m a Source #

printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> StateT s m () Source #

(MonadTrace m, Monoid w) => MonadTrace (WriterT w m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Trace

Methods

traceCall :: Call -> WriterT w m a -> WriterT w m a Source #

traceCallM :: WriterT w m Call -> WriterT w m a -> WriterT w m a Source #

traceCallCPS :: Call -> ((a -> WriterT w m b) -> WriterT w m b) -> (a -> WriterT w m b) -> WriterT w m b Source #

traceClosureCall :: Closure Call -> WriterT w m a -> WriterT w m a Source #

printHighlightingInfo :: RemoveTokenBasedHighlighting -> HighlightingInfo -> WriterT w m () Source #

interestingCall :: Call -> Bool Source #

getCurrentRange :: MonadTCEnv m => m Range Source #

setCurrentRange :: (MonadTrace m, HasRange x) => x -> m a -> m a Source #

Sets the current range (for error messages etc.) to the range of the given object, if it has a range (i.e., its range is not `noRange`).

highlightAsTypeChecked Source #

Arguments

:: MonadTrace m |

=> Range

    rPre

-> Range

    r

-> m a |
-> m a |

`highlightAsTypeChecked rPre r m` runs `m` and returns its result. Additionally, some code may be highlighted:

- If `r` is non-empty and not a sub-range of `rPre` (after `continuousPerLine` has been applied to both): `r` is highlighted as being type-checked while `m` is running (this highlighting is removed if `m` completes successfully).
- Otherwise: Highlighting is removed for `rPre - r` before `m` runs, and if `m` completes successfully, then `rPre - r` is highlighted as being type-checked.

noMutualBlock :: TCM a -> TCM a Source #

inMutualBlock :: (MutualId -> TCM a) -> TCM a Source #

Pass the current mutual block id or create a new mutual block if we are not already inside on.

setMutualBlockInfo :: MutualId -> MutualInfo -> TCM () Source #

Set the mutual block info for a block, possibly overwriting the existing one.

insertMutualBlockInfo :: MutualId -> MutualInfo -> TCM () Source #

Set the mutual block info for a block if non-existing.

setMutualBlock :: MutualId -> QName -> TCM () Source #

Set the mutual block for a definition.

currentOrFreshMutualBlock :: TCM MutualId Source #

Get the current mutual block, if any, otherwise a fresh mutual block is returned.

lookupMutualBlock :: MutualId -> TCM MutualBlock Source #

mutualBlockOf :: QName -> TCM MutualId Source #

Reverse lookup of a mutual block id for a names.

enterClosure :: (MonadTCEnv m, ReadTCState m, LensClosure a c) => c -> (a -> m b) -> m b Source #

withClosure :: (MonadTCEnv m, ReadTCState m) => Closure a -> (a -> m b) -> m (Closure b) Source #

mapClosure :: (MonadTCEnv m, ReadTCState m) => (a -> m b) -> Closure a -> m (Closure b) Source #

class (MonadTCEnv m, ReadTCState m, MonadError TCErr m, MonadBlock m, HasOptions m, MonadDebug m) => MonadConstraint m where Source #

Monad service class containing methods for adding and solving constraints

Methods

addConstraint :: Blocker -> Constraint -> m () Source #

Unconditionally add the constraint.

addAwakeConstraint :: Blocker -> Constraint -> m () Source #

Add constraint as awake constraint.

solveConstraint :: Constraint -> m () Source #

solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> m () Source #

Solve awake constraints matching the predicate. If the second argument is True solve constraints even if already `isSolvingConstraints`.

wakeConstraints :: (ProblemConstraint -> WakeUp) -> m () Source #

stealConstraints :: ProblemId -> m () Source #

modifyAwakeConstraints :: (Constraints -> Constraints) -> m () Source #

modifySleepingConstraints :: (Constraints -> Constraints) -> m () Source #

#### Instances

Instances details

MonadConstraint TCM Source # |

Instance details

Defined in Agda.TypeChecking.Constraints

Methods

addConstraint :: Blocker -> Constraint -> TCM () Source #

addAwakeConstraint :: Blocker -> Constraint -> TCM () Source #

solveConstraint :: Constraint -> TCM () Source #

solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> TCM () Source #

wakeConstraints :: (ProblemConstraint -> WakeUp) -> TCM () Source #

stealConstraints :: ProblemId -> TCM () Source #

modifyAwakeConstraints :: (Constraints -> Constraints) -> TCM () Source #

modifySleepingConstraints :: (Constraints -> Constraints) -> TCM () Source #

(PureTCM m, MonadBlock m) => MonadConstraint (PureConversionT m) Source # |

Instance details

Defined in Agda.TypeChecking.Conversion.Pure

Methods

addConstraint :: Blocker -> Constraint -> PureConversionT m () Source #

addAwakeConstraint :: Blocker -> Constraint -> PureConversionT m () Source #

solveConstraint :: Constraint -> PureConversionT m () Source #

solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> PureConversionT m () Source #

wakeConstraints :: (ProblemConstraint -> WakeUp) -> PureConversionT m () Source #

stealConstraints :: ProblemId -> PureConversionT m () Source #

modifyAwakeConstraints :: (Constraints -> Constraints) -> PureConversionT m () Source #

modifySleepingConstraints :: (Constraints -> Constraints) -> PureConversionT m () Source #

MonadConstraint m => MonadConstraint (ReaderT e m) Source # |

Instance details

Defined in Agda.TypeChecking.Monad.Constraints

Methods

addConstraint :: Blocker -> Constraint -> ReaderT e m () Source #

addAwakeConstraint :: Blocker -> Constraint -> ReaderT e m () Source #

solveConstraint :: Constraint -> ReaderT e m () Source #

solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> ReaderT e m () Source #

wakeConstraints :: (ProblemConstraint -> WakeUp) -> ReaderT e m () Source #

stealConstraints :: ProblemId -> ReaderT e m () Source #

modifyAwakeConstraints :: (Constraints -> Constraints) -> ReaderT e m () Source #

modifySleepingConstraints :: (Constraints -> Constraints) -> ReaderT e m () Source #

data ConstraintStatus Source #

Constructors

AwakeConstraint |
SleepingConstraint |

#### Instances

Instances details

Show ConstraintStatus Source # |
Instance details Defined in Agda.TypeChecking.Monad.Constraints Methods showsPrec :: Int -> ConstraintStatus -> ShowS Source # show :: ConstraintStatus -> String Source # showList :: [ConstraintStatus] -> ShowS Source #
Eq ConstraintStatus Source # |
Instance details Defined in Agda.TypeChecking.Monad.Constraints Methods (==) :: ConstraintStatus -> ConstraintStatus -> Bool Source # (/=) :: ConstraintStatus -> ConstraintStatus -> Bool Source #

solvingProblem :: MonadConstraint m => ProblemId -> m a -> m a Source #

solvingProblems :: MonadConstraint m => Set ProblemId -> m a -> m a Source #

isProblemSolved :: (MonadTCEnv m, ReadTCState m) => ProblemId -> m Bool Source #

getConstraintsForProblem :: ReadTCState m => ProblemId -> m Constraints Source #

getAwakeConstraints :: ReadTCState m => m Constraints Source #

Get the awake constraints

dropConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m () Source #

takeConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m Constraints Source #

Takes out all constraints matching given filter. Danger! The taken constraints need to be solved or put back at some point.

putConstraintsToSleep :: MonadConstraint m => (ProblemConstraint -> Bool) -> m () Source #

putAllConstraintsToSleep :: MonadConstraint m => m () Source #

holdConstraints :: (ConstraintStatus -> ProblemConstraint -> Bool) -> TCM a -> TCM a Source #

Suspend constraints matching the predicate during the execution of the second argument. Caution: held sleeping constraints will not be woken up by events that would normally trigger a wakeup call.

takeAwakeConstraint :: MonadConstraint m => m (Maybe ProblemConstraint) Source #

takeAwakeConstraint' :: MonadConstraint m => (ProblemConstraint -> Bool) -> m (Maybe ProblemConstraint) Source #

getAllConstraints :: ReadTCState m => m Constraints Source #

withConstraint :: MonadConstraint m => (Constraint -> m a) -> ProblemConstraint -> m a Source #

buildProblemConstraint :: (MonadTCEnv m, ReadTCState m) => Set ProblemId -> Blocker -> Constraint -> m ProblemConstraint Source #

buildProblemConstraint_ :: (MonadTCEnv m, ReadTCState m) => Blocker -> Constraint -> m ProblemConstraint Source #

buildConstraint :: Blocker -> Constraint -> TCM ProblemConstraint Source #

addAndUnblocker :: MonadBlock m => Blocker -> m a -> m a Source #

addOrUnblocker :: MonadBlock m => Blocker -> m a -> m a Source #

addConstraint' :: Blocker -> Constraint -> TCM () Source #

Add new a constraint

addAwakeConstraint' :: Blocker -> Constraint -> TCM () Source #

addConstraintTo :: Lens' Constraints TCState -> Blocker -> Constraint -> TCM () Source #

nowSolvingConstraints :: MonadTCEnv m => m a -> m a Source #

Start solving constraints

isSolvingConstraints :: MonadTCEnv m => m Bool Source #

catchConstraint :: MonadConstraint m => Constraint -> m () -> m () Source #

Add constraint if the action raises a pattern violation

mapAwakeConstraints :: (Constraints -> Constraints) -> TCState -> TCState Source #

mapSleepingConstraints :: (Constraints -> Constraints) -> TCState -> TCState Source #

setPragmaOptions :: PragmaOptions -> TCM () Source #

Sets the pragma options.

setCommandLineOptions :: CommandLineOptions -> TCM () Source #

Sets the command line options (both persistent and pragma options are updated).

Relative include directories are made absolute with respect to the current working directory. If the include directories have changed (thus, they are `Left` now, and were previously ``Right` something`), then the state is reset (completely, see setIncludeDirs) .

An empty list of relative include directories (``Left` []`) is interpreted as `["."]`.

setCommandLineOptions' Source #

Arguments

:: AbsolutePath | The base directory of relative paths.
-> CommandLineOptions |
-> TCM () |

getAgdaLibFiles :: FilePath -> TCM [AgdaLibFile] Source #

getLibraryOptions :: FilePath -> TCM [OptionsPragma] Source #

setLibraryPaths Source #

Arguments

:: AbsolutePath | The base directory of relative paths.
-> CommandLineOptions |
-> TCM CommandLineOptions |

setLibraryIncludes :: CommandLineOptions -> TCM CommandLineOptions Source #

addDefaultLibraries Source #

Arguments

:: AbsolutePath | The base directory of relative paths.
-> CommandLineOptions |
-> TCM CommandLineOptions |

addTrustedExecutables :: CommandLineOptions -> TCM CommandLineOptions Source #

setOptionsFromPragma :: OptionsPragma -> TCM () Source #

enableDisplayForms :: MonadTCEnv m => m a -> m a Source #

Disable display forms.

disableDisplayForms :: MonadTCEnv m => m a -> m a Source #

Disable display forms.

displayFormsEnabled :: MonadTCEnv m => m Bool Source #

Check if display forms are enabled.

setIncludeDirs Source #

Arguments

:: [FilePath] | New include directories.
-> AbsolutePath | The base directory of relative paths.
-> TCM () |

Makes the given directories absolute and stores them as include directories.

If the include directories change, then the state is reset (completely, except for the include directories and some other things).

An empty list is interpreted as `["."]`.

isPropEnabled :: HasOptions m => m Bool Source #

isTwoLevelEnabled :: HasOptions m => m Bool Source #

hasUniversePolymorphism :: HasOptions m => m Bool Source #

showImplicitArguments :: HasOptions m => m Bool Source #

showIrrelevantArguments :: HasOptions m => m Bool Source #

showIdentitySubstitutions :: HasOptions m => m Bool Source #

withShowAllArguments :: ReadTCState m => m a -> m a Source #

Switch on printing of implicit and irrelevant arguments. E.g. for reification in with-function generation.

Restores all `PragmaOptions` after completion. Thus, do not attempt to make persistent `PragmaOptions` changes in a `withShowAllArguments` bracket.

withShowAllArguments' :: ReadTCState m => Bool -> m a -> m a Source #

withPragmaOptions :: ReadTCState m => (PragmaOptions -> PragmaOptions) -> m a -> m a Source #

Change `PragmaOptions` for a computation and restore afterwards.

positivityCheckEnabled :: HasOptions m => m Bool Source #

typeInType :: HasOptions m => m Bool Source #

etaEnabled :: HasOptions m => m Bool Source #

maxInstanceSearchDepth :: HasOptions m => m Int Source #

maxInversionDepth :: HasOptions m => m Int Source #

getLanguage :: HasOptions m => m Language Source #

Returns the `Language` currently in effect.

makeOpen :: (ReadTCState m, MonadTCEnv m) => a -> m (Open a) Source #

Create an open term in the current context.

getOpen :: (TermSubst a, MonadTCEnv m) => Open a -> m a Source #

Extract the value from an open term. The checkpoint at which it was created must be in scope.

tryGetOpen :: (TermSubst a, ReadTCState m, MonadTCEnv m) => (Substitution -> a -> Maybe a) -> Open a -> m (Maybe a) Source #

Extract the value from an open term. If the checkpoint is no longer in scope use the provided function to pull the object to the most recent common checkpoint. The function is given the substitution from the common ancestor to the checkpoint of the thing.

isClosed :: Open a -> Bool Source #

An `Open` is closed if it has checkpoint 0.

newtype KeepNames a Source #

Wrapper to tell `addContext` not to mark names as `NotInScope`. Used when adding a user-provided, but already type checked, telescope to the context.

Constructors

KeepNames a |

#### Instances

Instances details

AddContext (KeepNames Telescope) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => KeepNames Telescope -> m a -> m a Source # contextSize :: KeepNames Telescope -> Nat Source #
AddContext (KeepNames String, Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => (KeepNames String, Dom Type) -> m a -> m a Source # contextSize :: (KeepNames String, Dom Type) -> Nat Source #

class AddContext b where Source #

Various specializations of `addCtx`.

Methods

addContext :: MonadAddContext m => b -> m a -> m a Source #

contextSize :: b -> Nat Source #

#### Instances

Instances details

AddContext Name Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => Name -> m a -> m a Source # contextSize :: Name -> Nat Source #
AddContext Telescope Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => Telescope -> m a -> m a Source # contextSize :: Telescope -> Nat Source #
AddContext String Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => String -> m a -> m a Source # contextSize :: String -> Nat Source #
AddContext (Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => Dom Type -> m a -> m a Source # contextSize :: Dom Type -> Nat Source #
AddContext (Dom (Name, Type)) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => Dom (Name, Type) -> m a -> m a Source # contextSize :: Dom (Name, Type) -> Nat Source #
AddContext (Dom (String, Type)) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => Dom (String, Type) -> m a -> m a Source # contextSize :: Dom (String, Type) -> Nat Source #
AddContext (KeepNames Telescope) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => KeepNames Telescope -> m a -> m a Source # contextSize :: KeepNames Telescope -> Nat Source #
AddContext a => AddContext [a] Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => [a] -> m a0 -> m a0 Source # contextSize :: [a] -> Nat Source #
AddContext (Name, Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => (Name, Dom Type) -> m a -> m a Source # contextSize :: (Name, Dom Type) -> Nat Source #
AddContext (KeepNames String, Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => (KeepNames String, Dom Type) -> m a -> m a Source # contextSize :: (KeepNames String, Dom Type) -> Nat Source #
AddContext (List1 Name, Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => (List1 Name, Dom Type) -> m a -> m a Source # contextSize :: (List1 Name, Dom Type) -> Nat Source #
AddContext (List1 (Arg Name), Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => (List1 (Arg Name), Type) -> m a -> m a Source # contextSize :: (List1 (Arg Name), Type) -> Nat Source #
AddContext (List1 (NamedArg Name), Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => (List1 (NamedArg Name), Type) -> m a -> m a Source # contextSize :: (List1 (NamedArg Name), Type) -> Nat Source #
AddContext (List1 (WithHiding Name), Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => (List1 (WithHiding Name), Dom Type) -> m a -> m a Source # contextSize :: (List1 (WithHiding Name), Dom Type) -> Nat Source #
AddContext (String, Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => (String, Dom Type) -> m a -> m a Source # contextSize :: (String, Dom Type) -> Nat Source #
AddContext ([Name], Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => ([Name], Dom Type) -> m a -> m a Source # contextSize :: ([Name], Dom Type) -> Nat Source #
AddContext ([Arg Name], Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => ([Arg Name], Type) -> m a -> m a Source # contextSize :: ([Arg Name], Type) -> Nat Source #
AddContext ([NamedArg Name], Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => ([NamedArg Name], Type) -> m a -> m a Source # contextSize :: ([NamedArg Name], Type) -> Nat Source #
AddContext ([WithHiding Name], Dom Type) Source # |
Instance details Defined in Agda.TypeChecking.Monad.Context Methods addContext :: MonadAddContext m => ([WithHiding Name], Dom Type) -> m a -> m a Source # contextSize :: ([WithHiding Name], Dom Type) -> Nat Source #

unsafeModifyContext :: MonadTCEnv tcm => (Context -> Context) -> tcm a -> tcm a Source #

Modify a `Context` in a computation. Warning: does not update the checkpoints. Use `updateContext` instead.

modifyContextInfo :: MonadTCEnv tcm => (forall e. Dom e -> Dom e) -> tcm a -> tcm a Source #

Modify the `Dom` part of context entries.

inTopContext :: (MonadTCEnv tcm, ReadTCState tcm) => tcm a -> tcm a Source #

Change to top (=empty) context. Resets the checkpoints.

unsafeInTopContext :: (MonadTCEnv m, ReadTCState m) => m a -> m a Source #

Change to top (=empty) context, but don't update the checkpoints. Totally not safe!

unsafeEscapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a Source #

Delete the last `n` bindings from the context.

Doesn't update checkpoints! Use `escapeContext` or `updateContext rho (drop n)` instead, for an appropriate substitution `rho`.

escapeContext :: MonadAddContext m => Impossible -> Int -> m a -> m a Source #

Delete the last `n` bindings from the context. Any occurrences of these variables are replaced with the given `err`.

checkpoint :: (MonadDebug tcm, MonadTCM tcm, MonadFresh CheckpointId tcm, ReadTCState tcm) => Substitution -> tcm a -> tcm a Source #

Add a new checkpoint. Do not use directly!

checkpointSubstitution' :: MonadTCEnv tcm => CheckpointId -> tcm (Maybe Substitution) Source #

Get the substitution from the context at a given checkpoint to the current context.

getModuleParameterSub :: (MonadTCEnv m, ReadTCState m) => ModuleName -> m (Maybe Substitution) Source #

Get substitution `Γ ⊢ ρ : Γm` where `Γ` is the current context and `Γm` is the module parameter telescope of module `m`.

Returns `Nothing` in case the we don't have a checkpoint for `m`.

defaultAddCtx :: MonadAddContext m => Name -> Dom Type -> m a -> m a Source #

Default implementation of addCtx in terms of updateContext

withFreshName_ :: MonadAddContext m => ArgName -> (Name -> m a) -> m a Source #

withShadowingNameTCM :: Name -> TCM b -> TCM b Source #

Run the given TCM action, and register the given variable as being shadowed by all the names with the same root that are added to the context during this TCM action.

addRecordNameContext :: (MonadAddContext m, MonadFresh NameId m) => Dom Type -> m b -> m b Source #

underAbstraction :: (Subst a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b Source #

Go under an abstraction. Do not extend context in case of `NoAbs`.

underAbstraction' :: (Subst a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b Source #

underAbstractionAbs :: (Subst a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b Source #

Go under an abstraction, treating `NoAbs` as `Abs`.

underAbstractionAbs' :: (Subst a, MonadAddContext m, AddContext (name, Dom Type)) => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b Source #

underAbstraction_ :: (Subst a, MonadAddContext m) => Abs a -> (a -> m b) -> m b Source #

Go under an abstract without worrying about the type to add to the context.

mapAbstraction :: (Subst a, Subst b, MonadAddContext m) => Dom Type -> (a -> m b) -> Abs a -> m (Abs b) Source #

Map a monadic function on the thing under the abstraction, adding the abstracted variable to the context.

getLetBindings :: MonadTCM tcm => tcm [(Name, (Term, Dom Type))] Source #

defaultAddLetBinding' :: (ReadTCState m, MonadTCEnv m) => Name -> Term -> Dom Type -> m a -> m a Source #

Add a let bound variable

addLetBinding :: MonadAddContext m => ArgInfo -> Name -> Term -> Type -> m a -> m a Source #

Add a let bound variable

getContext :: MonadTCEnv m => m [Dom (Name, Type)] Source #

Get the current context.

getContextSize :: (Applicative m, MonadTCEnv m) => m Nat Source #

Get the size of the current context.

getContextArgs :: (Applicative m, MonadTCEnv m) => m Args Source #

Generate `[var (n - 1), ..., var 0]` for all declarations in the context.

getContextTerms :: (Applicative m, MonadTCEnv m) => m [Term] Source #

Generate `[var (n - 1), ..., var 0]` for all declarations in the context.

getContextTelescope :: (Applicative m, MonadTCEnv m) => m Telescope Source #

Get the current context as a `Telescope`.

getContextNames :: (Applicative m, MonadTCEnv m) => m [Name] Source #

Get the names of all declarations in the context.

lookupBV' :: MonadTCEnv m => Nat -> m (Maybe (Dom (Name, Type))) Source #

get type of bound variable (i.e. deBruijn index)

lookupBV :: (MonadFail m, MonadTCEnv m) => Nat -> m (Dom (Name, Type)) Source #

domOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m (Dom Type) Source #

typeOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m Type Source #

nameOfBV' :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m (Maybe Name) Source #

nameOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m Name Source #

getVarInfo :: (MonadFail m, MonadTCEnv m) => Name -> m (Term, Dom Type) Source #

Get the term corresponding to a named variable. If it is a lambda bound variable the deBruijn index is returned and if it is a let bound variable its definition is returned.

data SortKit Source #

Sort primitives.

Constructors

SortKit |

Fields

- nameOfSet :: QName
- nameOfProp :: QName
- nameOfSSet :: QName
- nameOfSetOmega :: IsFibrant -> QName

data CoinductionKit Source #

The coinductive primitives.

Constructors

CoinductionKit |

Fields

- nameOfInf :: QName
- nameOfSharp :: QName
- nameOfFlat :: QName

litType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => Literal -> m Type Source #

setBuiltinThings :: BuiltinThings PrimFun -> TCM () Source #

bindBuiltinName :: String -> Term -> TCM () Source #

bindPrimitive :: String -> PrimFun -> TCM () Source #

getBuiltin :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => String -> m Term Source #

getBuiltin' :: HasBuiltins m => String -> m (Maybe Term) Source #

getPrimitive' :: HasBuiltins m => String -> m (Maybe PrimFun) Source #

getPrimitive :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => String -> m PrimFun Source #

getPrimitiveTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => String -> m Term Source #

getPrimitiveTerm' :: HasBuiltins m => String -> m (Maybe Term) Source #

getTerm' :: HasBuiltins m => String -> m (Maybe Term) Source #

getName' :: HasBuiltins m => String -> m (Maybe QName) Source #

getTerm :: HasBuiltins m => String -> String -> m Term Source #

`getTerm use name` looks up `name` as a primitive or builtin, and throws an error otherwise. The `use` argument describes how the name is used for the sake of the error message.

constructorForm :: HasBuiltins m => Term -> m Term Source #

Rewrite a literal to constructor form if possible.

constructorForm' :: Applicative m => m Term -> m Term -> Term -> m Term Source #

primInteger :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIntegerPos :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIntegerNegSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFloat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primChar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primBool :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSigma :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primUnit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primUnitUnit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primTrue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFalse :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primList :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNil :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primCons :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primMaybe :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNothing :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primJust :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIO :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primId :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primConId :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIdElim :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primPath :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primPathP :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primInterval :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIZero :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIOne :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIMin :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primINeg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primPartial :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primPartialP :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIsOne :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primItIsOne :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primTrans :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primHComp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primEquiv :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primEquivFun :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primEquivProof :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primTranspProof :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

prim_glueU :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

prim_unglueU :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primGlue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

prim_glue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

prim_unglue :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFaceForall :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIsOne1 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIsOne2 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIsOneEmpty :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSub :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSubIn :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSubOut :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primZero :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNatPlus :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNatMinus :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNatTimes :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNatDivSucAux :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNatModSucAux :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNatEquality :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primNatLess :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primWord64 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSizeUniv :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSize :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSizeLt :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSizeSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSizeInf :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSizeMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primInf :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSharp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFlat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primEquality :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primRefl :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primRewrite :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primLevel :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primLevelZero :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primLevelSuc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primLevelMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primProp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSetOmega :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primLockUniv :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primSSetOmega :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primStrictSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFromNat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFromNeg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFromString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primQName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primArg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primArgArg :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAbs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAbsAbs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaSort :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primHiding :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primHidden :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primInstance :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primVisible :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primRelevance :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primRelevant :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primIrrelevant :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primQuantity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primQuantity0 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primQuantityω :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primModality :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primModalityConstructor :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAssoc :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAssocLeft :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAssocRight :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAssocNon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primPrecedence :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primPrecRelated :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primPrecUnrelated :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFixity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primFixityFixity :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primArgInfo :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primArgArgInfo :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaSortSet :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaSortLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaSortProp :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaSortPropLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaSortInf :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaSortUnsupported :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermVar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermLam :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermExtLam :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermCon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermPi :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermSort :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermUnsupported :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTermMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaErrorPart :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaErrorPartString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaErrorPartTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaErrorPartName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaLiteral :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaLitNat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaLitWord64 :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaLitFloat :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaLitChar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaLitString :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaLitQName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaLitMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaPattern :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaPatCon :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaPatVar :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaPatDot :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaPatLit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaPatProj :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaPatAbsurd :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaClause :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaClauseClause :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaClauseAbsurd :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaDefinitionFunDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaDefinitionDataDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaDefinitionRecordDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaDefinitionDataConstructor :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaDefinitionPostulate :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaDefinitionPrimitive :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaDefinition :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCM :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMReturn :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMBind :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMUnify :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMTypeError :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMInferType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMCheckType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMNormalise :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMReduce :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMCatchError :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMGetContext :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMExtendContext :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMInContext :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMFreshName :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMDeclareDef :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMDeclarePostulate :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMDefineFun :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMGetType :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMGetDefinition :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMQuoteTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMQuoteOmegaTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMUnquoteTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMBlockOnMeta :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMCommit :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMIsMacro :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMWithNormalisation :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMWithReconsParams :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMDebugPrint :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMOnlyReduceDefs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMDontReduceDefs :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMNoConstraints :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMRunSpeculative :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

primAgdaTCMExec :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term Source #

coinductionKit' :: TCM CoinductionKit Source #

Tries to build a `CoinductionKit`.

coinductionKit :: TCM (Maybe CoinductionKit) Source #

sortKit :: HasBuiltins m => m SortKit Source #

getPrimName :: Term -> QName Source #

getBuiltinName' :: HasBuiltins m => String -> m (Maybe QName) Source #

getPrimitiveName' :: HasBuiltins m => String -> m (Maybe QName) Source #

isPrimitive :: HasBuiltins m => String -> QName -> m Bool Source #

intervalView' :: HasBuiltins m => m (Term -> IntervalView) Source #

intervalView :: HasBuiltins m => Term -> m IntervalView Source #

intervalUnview :: HasBuiltins m => IntervalView -> m Term Source #

intervalUnview' :: HasBuiltins m => m (IntervalView -> Term) Source #

pathView :: HasBuiltins m => Type -> m PathView Source #

Check whether the type is actually an path (lhs ≡ rhs) and extract lhs, rhs, and their type.

Precondition: type is reduced.

pathView' :: HasBuiltins m => m (Type -> PathView) Source #

idViewAsPath :: HasBuiltins m => Type -> m PathView Source #

Non dependent Path

boldPathView :: Type -> PathView Source #

pathUnview :: PathView -> Type Source #

Revert the `PathView`.

Postcondition: type is reduced.

primEqualityName :: TCM QName Source #

Get the name of the equality type.

equalityView :: Type -> TCM EqualityView Source #

Check whether the type is actually an equality (lhs ≡ rhs) and extract lhs, rhs, and their type.

Precondition: type is reduced.

equalityUnview :: EqualityView -> Type Source #

Revert the `EqualityView`.

Postcondition: type is reduced.

constrainedPrims :: [String] Source #

Primitives with typechecking constrants.

getNameOfConstrained :: HasBuiltins m => String -> m (Maybe QName) Source #

type SizeMaxView' = [DeepSizeView] Source #

type SizeMaxView = NonEmpty DeepSizeView Source #

data SizeViewComparable a Source #

Constructors

NotComparable |
YesAbove DeepSizeView a |
YesBelow DeepSizeView a |

#### Instances

Instances details

Functor SizeViewComparable Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods fmap :: (a -> b) -> SizeViewComparable a -> SizeViewComparable b Source # (<$) :: a -> SizeViewComparable b -> SizeViewComparable a Source #

data DeepSizeView Source #

A deep view on sizes.

Constructors

DSizeInf |
DSizeVar ProjectedVar Offset |
DSizeMeta MetaId Elims Offset |
DOtherSize Term |

#### Instances

Instances details

Pretty DeepSizeView Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods pretty :: DeepSizeView -> Doc Source # prettyPrec :: Int -> DeepSizeView -> Doc Source # prettyList :: [DeepSizeView] -> Doc Source #
Show DeepSizeView Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods showsPrec :: Int -> DeepSizeView -> ShowS Source # show :: DeepSizeView -> String Source # showList :: [DeepSizeView] -> ShowS Source #

type Offset = Nat Source #

data ProjectedVar Source #

A de Bruijn index under some projections.

Constructors

ProjectedVar |

Fields

- pvIndex :: Int
- prProjs :: [(ProjOrigin, QName)]

#### Instances

Instances details

Show ProjectedVar Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods showsPrec :: Int -> ProjectedVar -> ShowS Source # show :: ProjectedVar -> String Source # showList :: [ProjectedVar] -> ShowS Source #
Eq ProjectedVar Source # | Ignore `ProjOrigin` in equality test.
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods (==) :: ProjectedVar -> ProjectedVar -> Bool Source # (/=) :: ProjectedVar -> ProjectedVar -> Bool Source #

data SizeView Source #

A useful view on sizes.

Constructors

SizeInf |
SizeSuc Term |
OtherSize Term |

class IsSizeType a where Source #

Check if a type is the `primSize` type. The argument should be `reduce`d.

Methods

isSizeType :: (HasOptions m, HasBuiltins m) => a -> m (Maybe BoundedSize) Source #

#### Instances

Instances details

IsSizeType Term Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods isSizeType :: (HasOptions m, HasBuiltins m) => Term -> m (Maybe BoundedSize) Source #
IsSizeType CompareAs Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods isSizeType :: (HasOptions m, HasBuiltins m) => CompareAs -> m (Maybe BoundedSize) Source #
IsSizeType a => IsSizeType (Dom a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods isSizeType :: (HasOptions m, HasBuiltins m) => Dom a -> m (Maybe BoundedSize) Source #
IsSizeType a => IsSizeType (Type' a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods isSizeType :: (HasOptions m, HasBuiltins m) => Type' a -> m (Maybe BoundedSize) Source #
IsSizeType a => IsSizeType (b, a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods isSizeType :: (HasOptions m, HasBuiltins m) => (b, a) -> m (Maybe BoundedSize) Source #

data BoundedSize Source #

Result of querying whether size variable `i` is bounded by another size.

Constructors

BoundedLt Term | yes `i : Size< t`
BoundedNo |

#### Instances

Instances details

Show BoundedSize Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods showsPrec :: Int -> BoundedSize -> ShowS Source # show :: BoundedSize -> String Source # showList :: [BoundedSize] -> ShowS Source #
Eq BoundedSize Source # |
Instance details Defined in Agda.TypeChecking.Monad.SizedTypes Methods (==) :: BoundedSize -> BoundedSize -> Bool Source # (/=) :: BoundedSize -> BoundedSize -> Bool Source #

isSizeTypeTest :: (HasOptions m, HasBuiltins m) => m (Term -> Maybe BoundedSize) Source #

getBuiltinDefName :: HasBuiltins m => String -> m (Maybe QName) Source #

getBuiltinSize :: HasBuiltins m => m (Maybe QName, Maybe QName) Source #

isSizeNameTest :: (HasOptions m, HasBuiltins m) => m (QName -> Bool) Source #

isSizeNameTestRaw :: (HasOptions m, HasBuiltins m) => m (QName -> Bool) Source #

haveSizedTypes :: TCM Bool Source #

Test whether OPTIONS --sized-types and whether the size built-ins are defined.

haveSizeLt :: TCM Bool Source #

Test whether the SIZELT builtin is defined.

builtinSizeHook :: String -> QName -> Type -> TCM () Source #

Add polarity info to a SIZE builtin.

sizeSort :: Sort Source #

The sort of built-in types `SIZE` and `SIZELT`.

sizeUniv :: Type Source #

The type of built-in types `SIZE` and `SIZELT`.

sizeType_ :: QName -> Type Source #

The built-in type `SIZE` with user-given name.

sizeType :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => m Type Source #

The built-in type `SIZE`.

sizeSucName :: (HasBuiltins m, HasOptions m) => m (Maybe QName) Source #

The name of `SIZESUC`.

sizeSuc :: HasBuiltins m => Nat -> Term -> m Term Source #

sizeSuc_ :: QName -> Term -> Term Source #

sizeMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => NonEmpty Term -> m Term Source #

Transform list of terms into a term build from binary maximum.

sizeView :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => Term -> m SizeView Source #

Expects argument to be `reduce`d.

viewProjectedVar :: Term -> Maybe ProjectedVar Source #

unviewProjectedVar :: ProjectedVar -> Term Source #

sizeViewComparable :: DeepSizeView -> DeepSizeView -> SizeViewComparable () Source #

`sizeViewComparable v w` checks whether `v >= w` (then `Left`) or `v <= w` (then `Right`). If uncomparable, it returns `NotComparable`.

sizeViewSuc_ :: QName -> DeepSizeView -> DeepSizeView Source #

sizeViewPred :: Nat -> DeepSizeView -> DeepSizeView Source #

`sizeViewPred k v` decrements `v` by `k` (must be possible!).

sizeViewOffset :: DeepSizeView -> Maybe Offset Source #

`sizeViewOffset v` returns the number of successors or Nothing when infty.

removeSucs :: (DeepSizeView, DeepSizeView) -> (DeepSizeView, DeepSizeView) Source #

Remove successors common to both sides.

unSizeView :: SizeView -> TCM Term Source #

Turn a size view into a term.

unDeepSizeView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => DeepSizeView -> m Term Source #

maxViewMax :: SizeMaxView -> SizeMaxView -> SizeMaxView Source #

maxViewCons :: DeepSizeView -> SizeMaxView -> SizeMaxView Source #

`maxViewCons v ws = max v ws`. It only adds `v` to `ws` if it is not subsumed by an element of `ws`.

sizeViewComparableWithMax :: DeepSizeView -> SizeMaxView -> SizeViewComparable SizeMaxView' Source #

`sizeViewComparableWithMax v ws` tries to find `w` in `ws` that compares with `v` and singles this out. Precondition: `v /= DSizeInv`.

maxViewSuc_ :: QName -> SizeMaxView -> SizeMaxView Source #

unMaxView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => SizeMaxView -> m Term Source #

addConstant :: QName -> Definition -> TCM () Source #

Add a constant to the signature. Lifts the definition to top level.

addConstant' :: QName -> ArgInfo -> QName -> Type -> Defn -> TCM () Source #

A combination of `addConstant` and `defaultDefn`. The `Language` does not need to be supplied.

setTerminates :: QName -> Bool -> TCM () Source #

Set termination info of a defined function symbol.

setCompiledClauses :: QName -> CompiledClauses -> TCM () Source #

Set CompiledClauses of a defined function symbol.

setSplitTree :: QName -> SplitTree -> TCM () Source #

Set SplitTree of a defined function symbol.

modifyFunClauses :: QName -> ([Clause] -> [Clause]) -> TCM () Source #

Modify the clauses of a function.

addClauses :: QName -> [Clause] -> TCM () Source #

Lifts clauses to the top-level and adds them to definition. Also adjusts the `funCopatternLHS` field if necessary.

mkPragma :: String -> TCM CompilerPragma Source #

addPragma :: BackendName -> QName -> String -> TCM () Source #

Add a compiler pragma `{-# COMPILE backend name text #-}`

getUniqueCompilerPragma :: BackendName -> QName -> TCM (Maybe CompilerPragma) Source #

setFunctionFlag :: FunctionFlag -> Bool -> QName -> TCM () Source #

markStatic :: QName -> TCM () Source #

markInline :: Bool -> QName -> TCM () Source #

markInjective :: QName -> TCM () Source #

unionSignatures :: [Signature] -> Signature Source #

addSection :: ModuleName -> TCM () Source #

Add a section to the signature.

The current context will be stored as the cumulative module parameters for this section.

setModuleCheckpoint :: ModuleName -> TCM () Source #

Sets the checkpoint for the given module to the current checkpoint.

getSection :: (Functor m, ReadTCState m) => ModuleName -> m (Maybe Section) Source #

Get a section.

Why Maybe? The reason is that we look up all prefixes of a module to compute number of parameters, and for hierarchical top-level modules, A.B.C say, A and A.B do not exist.

addDisplayForms :: QName -> TCM () Source #

Add display forms for a name `f` copied by a module application. Essentially if `f` can reduce to

    λ xs → A.B.C.f vs

by unfolding module application copies (`defCopy`), then we add a display form

    A.B.C.f vs ==> f xs

applySection Source #

Arguments

:: ModuleName | Name of new module defined by the module macro.
-> Telescope | Parameters of new module.
-> ModuleName | Name of old module applied to arguments.
-> Args | Arguments of module application.
-> ScopeCopyInfo | Imported names and modules
-> TCM () |

Module application (followed by module parameter abstraction).

applySection' :: ModuleName -> Telescope -> ModuleName -> Args -> ScopeCopyInfo -> TCM () Source #

addDisplayForm :: QName -> DisplayForm -> TCM () Source #

Add a display form to a definition (could be in this or imported signature).

isLocal :: ReadTCState m => QName -> m Bool Source #

getDisplayForms :: (HasConstInfo m, ReadTCState m) => QName -> m [LocalDisplayForm] Source #

chaseDisplayForms :: QName -> TCM (Set QName) Source #

Find all names used (recursively) by display forms of a given name.

hasLoopingDisplayForm :: QName -> TCM Bool Source #

Check if a display form is looping.

canonicalName :: HasConstInfo m => QName -> m QName Source #

sameDef :: HasConstInfo m => QName -> QName -> m (Maybe QName) Source #

whatInduction :: MonadTCM tcm => QName -> tcm Induction Source #

Can be called on either a (co)datatype, a record type or a (co)constructor.

singleConstructorType :: QName -> TCM Bool Source #

Does the given constructor come from a single-constructor type?

Precondition: The name has to refer to a constructor.

sigError :: (String -> a) -> a -> SigError -> a Source #

Standard eliminator for `SigError`.

getOriginalConstInfo :: (ReadTCState m, HasConstInfo m) => QName -> m Definition Source #

The computation `getConstInfo` sometimes tweaks the returned `Definition`, depending on the current `Language` and the `Language` of the `Definition`. This variant of `getConstInfo` does not perform any tweaks.

defaultGetRewriteRulesFor :: (ReadTCState m, MonadTCEnv m) => QName -> m RewriteRules Source #

getOriginalProjection :: HasConstInfo m => QName -> m QName Source #

Get the original name of the projection (the current one could be from a module application).

defaultGetConstInfo :: (HasOptions m, MonadDebug m, MonadTCEnv m) => TCState -> TCEnv -> QName -> m (Either SigError Definition) Source #

getConInfo :: HasConstInfo m => ConHead -> m Definition Source #

getPolarity :: HasConstInfo m => QName -> m [Polarity] Source #

Look up the polarity of a definition.

getPolarity' :: HasConstInfo m => Comparison -> QName -> m [Polarity] Source #

Look up polarity of a definition and compose with polarity represented by `Comparison`.

setPolarity :: (MonadTCState m, MonadDebug m) => QName -> [Polarity] -> m () Source #

Set the polarity of a definition.

getForcedArgs :: HasConstInfo m => QName -> m [IsForced] Source #

Look up the forced arguments of a definition.

getArgOccurrence :: QName -> Nat -> TCM Occurrence Source #

Get argument occurrence info for argument `i` of definition `d` (never fails).

setArgOccurrences :: MonadTCState m => QName -> [Occurrence] -> m () Source #

Sets the `defArgOccurrences` for the given identifier (which should already exist in the signature).

modifyArgOccurrences :: MonadTCState m => QName -> ([Occurrence] -> [Occurrence]) -> m () Source #

setTreeless :: QName -> TTerm -> TCM () Source #

setCompiledArgUse :: QName -> [ArgUsage] -> TCM () Source #

getCompiled :: HasConstInfo m => QName -> m (Maybe Compiled) Source #

getErasedConArgs :: HasConstInfo m => QName -> m [Bool] Source #

Returns a list of length `conArity`. If no erasure analysis has been performed yet, this will be a list of `False`s.

setErasedConArgs :: QName -> [Bool] -> TCM () Source #

getTreeless :: HasConstInfo m => QName -> m (Maybe TTerm) Source #

getCompiledArgUse :: HasConstInfo m => QName -> m (Maybe [ArgUsage]) Source #

addDataCons :: QName -> [QName] -> TCM () Source #

add data constructors to a datatype

getMutual :: QName -> TCM (Maybe [QName]) Source #

Get the mutually recursive identifiers of a symbol from the signature.

getMutual_ :: Defn -> Maybe [QName] Source #

Get the mutually recursive identifiers from a `Definition`.

setMutual :: QName -> [QName] -> TCM () Source #

Set the mutually recursive identifiers.

mutuallyRecursive :: QName -> QName -> TCM Bool Source #

Check whether two definitions are mutually recursive.

definitelyNonRecursive_ :: Defn -> Bool Source #

A functiondatarecord definition is nonRecursive if it is not even mutually recursive with itself.

getCurrentModuleFreeVars :: TCM Nat Source #

Get the number of parameters to the current module.

getDefModule :: HasConstInfo m => QName -> m (Either SigError ModuleName) Source #

getDefFreeVars :: (Functor m, Applicative m, ReadTCState m, MonadTCEnv m) => QName -> m Nat Source #

Compute the number of free variables of a defined name. This is the sum of number of parameters shared with the current module and the number of anonymous variables (if the name comes from a let-bound module).

freeVarsToApply :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => QName -> m Args Source #

getModuleFreeVars :: (Functor m, Applicative m, MonadTCEnv m, ReadTCState m) => ModuleName -> m Nat Source #

moduleParamsToApply :: (Functor m, Applicative m, HasOptions m, MonadTCEnv m, ReadTCState m, MonadDebug m) => ModuleName -> m Args Source #

Compute the context variables to apply a definition to.

We have to insert the module telescope of the common prefix of the current module and the module where the definition comes from. (Properly raised to the current context.)

Example: `module M₁ Γ where module M₁ Δ where f = ... module M₃ Θ where ... M₁.M₂.f [insert Γ raised by Θ]`

instantiateDef :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => Definition -> m Definition Source #

Instantiate a closed definition with the correct part of the current context.

instantiateRewriteRule :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRule -> m RewriteRule Source #

instantiateRewriteRules :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRules -> m RewriteRules Source #

makeAbstract :: Definition -> Maybe Definition Source #

Give the abstract view of a definition.

inAbstractMode :: MonadTCEnv m => m a -> m a Source #

Enter abstract mode. Abstract definition in the current module are transparent.

inConcreteMode :: MonadTCEnv m => m a -> m a Source #

Not in abstract mode. All abstract definitions are opaque.

ignoreAbstractMode :: MonadTCEnv m => m a -> m a Source #

Ignore abstract mode. All abstract definitions are transparent.

inConcreteOrAbstractMode :: (MonadTCEnv m, HasConstInfo m) => QName -> (Definition -> m a) -> m a Source #

Enter concrete or abstract mode depending on whether the given identifier is concrete or abstract.

treatAbstractly :: MonadTCEnv m => QName -> m Bool Source #

Check whether a name might have to be treated abstractly (either if we're `inAbstractMode` or it's not a local name). Returns true for things not declared abstract as well, but for those `makeAbstract` will have no effect.

treatAbstractly' :: QName -> TCEnv -> Bool Source #

Andreas, 2015-07-01: If the `current` module is a weak suffix of the identifier module, we can see through its abstract definition if we are abstract. (Then `treatAbstractly'` returns `False`).

If I am not mistaken, then we cannot see definitions in the `where` block of an abstract function from the perspective of the function, because then the current module is a strict prefix of the module of the local identifier. This problem is fixed by removing trailing anonymous module name parts (underscores) from both names.

typeOfConst :: (HasConstInfo m, ReadTCState m) => QName -> m Type Source #

Get type of a constant, instantiated to the current context.

relOfConst :: HasConstInfo m => QName -> m Relevance Source #

Get relevance of a constant.

modalityOfConst :: HasConstInfo m => QName -> m Modality Source #

Get modality of a constant.

droppedPars :: Definition -> Int Source #

The number of dropped parameters for a definition. 0 except for projection(-like) functions and constructors.

isProjection :: HasConstInfo m => QName -> m (Maybe Projection) Source #

Is it the name of a record projection?

isProjection_ :: Defn -> Maybe Projection Source #

isRelevantProjection :: HasConstInfo m => QName -> m (Maybe Projection) Source #

Is it the name of a non-irrelevant record projection?

isRelevantProjection_ :: Definition -> Maybe Projection Source #

isStaticFun :: Defn -> Bool Source #

Is it a function marked STATIC?

isInlineFun :: Defn -> Bool Source #

Is it a function marked INLINE?

isProperProjection :: Defn -> Bool Source #

Returns `True` if we are dealing with a proper projection, i.e., not a projection-like function nor a record field value (projection applied to argument).

projectionArgs :: Definition -> Int Source #

Number of dropped initial arguments of a projection(-like) function.

usesCopatterns :: HasConstInfo m => QName -> m Bool Source #

Check whether a definition uses copatterns.

applyDef :: HasConstInfo m => ProjOrigin -> QName -> Arg Term -> m Term Source #

Apply a function `f` to its first argument, producing the proper postfix projection if `f` is a projection which is not irrelevant.

class UnFreezeMeta a where Source #

Unfreeze meta and its type if this is a meta again. Does not unfreeze deep occurrences of metas.

Methods

unfreezeMeta :: MonadMetaSolver m => a -> m () Source #

#### Instances

Instances details

UnFreezeMeta MetaId Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods unfreezeMeta :: MonadMetaSolver m => MetaId -> m () Source #
UnFreezeMeta Level Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods unfreezeMeta :: MonadMetaSolver m => Level -> m () Source #
UnFreezeMeta PlusLevel Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods unfreezeMeta :: MonadMetaSolver m => PlusLevel -> m () Source #
UnFreezeMeta Sort Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods unfreezeMeta :: MonadMetaSolver m => Sort -> m () Source #
UnFreezeMeta Term Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods unfreezeMeta :: MonadMetaSolver m => Term -> m () Source #
UnFreezeMeta Type Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods unfreezeMeta :: MonadMetaSolver m => Type -> m () Source #
UnFreezeMeta a => UnFreezeMeta (Abs a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods unfreezeMeta :: MonadMetaSolver m => Abs a -> m () Source #
UnFreezeMeta a => UnFreezeMeta [a] Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods unfreezeMeta :: MonadMetaSolver m => [a] -> m () Source #

class IsInstantiatedMeta a where Source #

Check whether all metas are instantiated. Precondition: argument is a meta (in some form) or a list of metas.

Methods

isInstantiatedMeta :: (MonadFail m, ReadTCState m) => a -> m Bool Source #

#### Instances

Instances details

IsInstantiatedMeta MetaId Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods isInstantiatedMeta :: (MonadFail m, ReadTCState m) => MetaId -> m Bool Source #
IsInstantiatedMeta Level Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Level -> m Bool Source #
IsInstantiatedMeta PlusLevel Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods isInstantiatedMeta :: (MonadFail m, ReadTCState m) => PlusLevel -> m Bool Source #
IsInstantiatedMeta Term Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Term -> m Bool Source #
IsInstantiatedMeta a => IsInstantiatedMeta (Arg a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Arg a -> m Bool Source #
IsInstantiatedMeta a => IsInstantiatedMeta (Abs a) Source # | Does not worry about raising.
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Abs a -> m Bool Source #
IsInstantiatedMeta a => IsInstantiatedMeta (Maybe a) Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods isInstantiatedMeta :: (MonadFail m, ReadTCState m) => Maybe a -> m Bool Source #
IsInstantiatedMeta a => IsInstantiatedMeta [a] Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods isInstantiatedMeta :: (MonadFail m, ReadTCState m) => [a] -> m Bool Source #

class (MonadConstraint m, MonadReduce m, MonadAddContext m, MonadTCEnv m, ReadTCState m, HasBuiltins m, HasConstInfo m, MonadDebug m) => MonadMetaSolver m where Source #

Monad service class for creating, solving and eta-expanding of metavariables.

Methods

newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId Source #

Generate a new meta variable with some instantiation given. For instance, the instantiation could be a `PostponedTypeCheckingProblem`.

assignV :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> m () Source #

Assign to an open metavar which may not be frozen. First check that metavar args are in pattern fragment. Then do extended occurs check on given thing.

Assignment is aborted by throwing a `PatternErr` via a call to `patternViolation`. This error is caught by `catchConstraint` during equality checking (`compareAtom`) and leads to restoration of the original constraints.

assignTerm' :: MonadMetaSolver m => MetaId -> [Arg ArgName] -> Term -> m () Source #

Directly instantiate the metavariable. Skip pattern check, occurs check and frozen check. Used for eta expanding frozen metas.

etaExpandMeta :: [MetaKind] -> MetaId -> m () Source #

Eta expand a metavariable, if it is of the specified kind. Don't do anything if the metavariable is a blocked term.

updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> m () Source #

Update the status of the metavariable

speculateMetas :: m () -> m KeepMetas -> m () Source #

'speculateMetas fallback m' speculatively runs `m`, but if the result is `RollBackMetas` any changes to metavariables are rolled back and `fallback` is run instead.

#### Instances

Instances details

MonadMetaSolver TCM Source # |

Instance details

Defined in Agda.TypeChecking.MetaVars

Methods

newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId Source #

assignV :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> TCM () Source #

assignTerm' :: MetaId -> [Arg ArgName] -> Term -> TCM () Source #

etaExpandMeta :: [MetaKind] -> MetaId -> TCM () Source #

updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> TCM () Source #

speculateMetas :: TCM () -> TCM KeepMetas -> TCM () Source #

(PureTCM m, MonadBlock m) => MonadMetaSolver (PureConversionT m) Source # |

Instance details

Defined in Agda.TypeChecking.Conversion.Pure

Methods

newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> PureConversionT m MetaId Source #

assignV :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> PureConversionT m () Source #

assignTerm' :: MetaId -> [Arg ArgName] -> Term -> PureConversionT m () Source #

etaExpandMeta :: [MetaKind] -> MetaId -> PureConversionT m () Source #

updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> PureConversionT m () Source #

speculateMetas :: PureConversionT m () -> PureConversionT m KeepMetas -> PureConversionT m () Source #

data KeepMetas Source #

Constructors

KeepMetas |
RollBackMetas |

data MetaKind Source #

Various kinds of metavariables.

Constructors

Records | Meta variables of record type.
SingletonRecords | Meta variables of "hereditarily singleton" record type.
Levels | Meta variables of level type, if type-in-type is activated.

#### Instances

Instances details

Bounded MetaKind Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods minBound :: MetaKind Source # maxBound :: MetaKind Source #
Enum MetaKind Source # |

Instance details

Defined in Agda.TypeChecking.Monad.MetaVars

Methods

succ :: MetaKind -> MetaKind Source #

pred :: MetaKind -> MetaKind Source #

toEnum :: Int -> MetaKind Source #

fromEnum :: MetaKind -> Int Source #

enumFrom :: MetaKind -> [MetaKind] Source #

enumFromThen :: MetaKind -> MetaKind -> [MetaKind] Source #

enumFromTo :: MetaKind -> MetaKind -> [MetaKind] Source #

enumFromThenTo :: MetaKind -> MetaKind -> MetaKind -> [MetaKind] Source #

Show MetaKind Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods showsPrec :: Int -> MetaKind -> ShowS Source # show :: MetaKind -> String Source # showList :: [MetaKind] -> ShowS Source #
Eq MetaKind Source # |
Instance details Defined in Agda.TypeChecking.Monad.MetaVars Methods (==) :: MetaKind -> MetaKind -> Bool Source # (/=) :: MetaKind -> MetaKind -> Bool Source #

allMetaKinds :: [MetaKind] Source #

All possible metavariable kinds.

dontAssignMetas :: (MonadTCEnv m, HasOptions m, MonadDebug m) => m a -> m a Source #

Switch off assignment of metas.

getMetaStore :: ReadTCState m => m MetaStore Source #

Get the meta store.

modifyMetaStore :: (MetaStore -> MetaStore) -> TCM () Source #

metasCreatedBy :: ReadTCState m => m a -> m (a, MetaStore) Source #

Run a computation and record which new metas it created.

lookupMeta' :: ReadTCState m => MetaId -> m (Maybe MetaVariable) Source #

Lookup a meta variable.

lookupMeta :: (MonadFail m, ReadTCState m) => MetaId -> m MetaVariable Source #

metaType :: (MonadFail m, ReadTCState m) => MetaId -> m Type Source #

Type of a term or sort meta.

updateMetaVarTCM :: MetaId -> (MetaVariable -> MetaVariable) -> TCM () Source #

Update the information associated with a meta variable.

insertMetaVar :: MetaId -> MetaVariable -> TCM () Source #

Insert a new meta variable with associated information into the meta store.

getMetaPriority :: (MonadFail m, ReadTCState m) => MetaId -> m MetaPriority Source #

isSortMeta :: (MonadFail m, ReadTCState m) => MetaId -> m Bool Source #

isSortMeta_ :: MetaVariable -> Bool Source #

getMetaType :: (MonadFail m, ReadTCState m) => MetaId -> m Type Source #

getMetaContextArgs :: MonadTCEnv m => MetaVariable -> m Args Source #

Compute the context variables that a meta should be applied to, accounting for pruning.

getMetaTypeInContext :: (MonadFail m, MonadTCEnv m, ReadTCState m, MonadReduce m, HasBuiltins m) => MetaId -> m Type Source #

Given a meta, return the type applied to the current context.

isGeneralizableMeta :: (ReadTCState m, MonadFail m) => MetaId -> m DoGeneralize Source #

Is it a meta that might be generalized?

isInstantiatedMeta' :: (MonadFail m, ReadTCState m) => MetaId -> m (Maybe Term) Source #

constraintMetas :: Constraint -> TCM (Set MetaId) Source #

Returns all metavariables in a constraint. Slightly complicated by the fact that blocked terms are represented by two meta variables. To find the second one we need to look up the meta listeners for the one in the UnBlock constraint. This is used for the purpose of deciding if a metavariable is constrained or if it can be generalized over (see Agda.TypeChecking.Generalize).

createMetaInfo :: (MonadTCEnv m, ReadTCState m) => m MetaInfo Source #

Create `MetaInfo` in the current environment.

createMetaInfo' :: (MonadTCEnv m, ReadTCState m) => RunMetaOccursCheck -> m MetaInfo Source #

setValueMetaName :: MonadMetaSolver m => Term -> MetaNameSuggestion -> m () Source #

getMetaNameSuggestion :: (MonadFail m, ReadTCState m) => MetaId -> m MetaNameSuggestion Source #

setMetaNameSuggestion :: MonadMetaSolver m => MetaId -> MetaNameSuggestion -> m () Source #

setMetaGeneralizableArgInfo :: MonadMetaSolver m => MetaId -> ArgInfo -> m () Source #

Change the ArgInfo that will be used when generalizing over this meta.

updateMetaVarRange :: MonadMetaSolver m => MetaId -> Range -> m () Source #

setMetaOccursCheck :: MonadMetaSolver m => MetaId -> RunMetaOccursCheck -> m () Source #

registerInteractionPoint :: forall m. MonadInteractionPoints m => Bool -> Range -> Maybe Nat -> m InteractionId Source #

Register an interaction point during scope checking. If there is no interaction id yet, create one.

findInteractionPoint_ :: Range -> InteractionPoints -> Maybe InteractionId Source #

Find an interaction point by `Range` by searching the whole map. Issue 3000: Don't consider solved interaction points.

O(n): linear in the number of registered interaction points.

connectInteractionPoint :: MonadInteractionPoints m => InteractionId -> MetaId -> m () Source #

Hook up meta variable to interaction point.

removeInteractionPoint :: MonadInteractionPoints m => InteractionId -> m () Source #

Mark an interaction point as solved.

getInteractionPoints :: ReadTCState m => m [InteractionId] Source #

Get a list of interaction ids.

getInteractionMetas :: ReadTCState m => m [MetaId] Source #

Get all metas that correspond to unsolved interaction ids.

getUniqueMetasRanges :: (MonadFail m, ReadTCState m) => [MetaId] -> m [Range] Source #

getUnsolvedMetas :: (MonadFail m, ReadTCState m) => m [Range] Source #

getUnsolvedInteractionMetas :: (MonadFail m, ReadTCState m) => m [Range] Source #

getInteractionIdsAndMetas :: ReadTCState m => m [(InteractionId, MetaId)] Source #

Get all metas that correspond to unsolved interaction ids.

isInteractionMeta :: ReadTCState m => MetaId -> m (Maybe InteractionId) Source #

Does the meta variable correspond to an interaction point?

Time: `O(log n)` where `n` is the number of interaction metas.

lookupInteractionPoint :: (MonadFail m, ReadTCState m, MonadError TCErr m) => InteractionId -> m InteractionPoint Source #

Get the information associated to an interaction point.

lookupInteractionId :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m MetaId Source #

Get `MetaId` for an interaction point. Precondition: interaction point is connected.

lookupInteractionMeta :: ReadTCState m => InteractionId -> m (Maybe MetaId) Source #

Check whether an interaction id is already associated with a meta variable.

lookupInteractionMeta_ :: InteractionId -> InteractionPoints -> Maybe MetaId Source #

newMeta :: MonadMetaSolver m => Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId Source #

Generate new meta variable.

newMetaTCM' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId Source #

Generate a new meta variable with some instantiation given. For instance, the instantiation could be a `PostponedTypeCheckingProblem`.

getInteractionRange :: (MonadInteractionPoints m, MonadFail m, MonadError TCErr m) => InteractionId -> m Range Source #

Get the `Range` for an interaction point.

getMetaRange :: (MonadFail m, ReadTCState m) => MetaId -> m Range Source #

Get the `Range` for a meta variable.

getInteractionScope :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) => InteractionId -> m ScopeInfo Source #

withMetaInfo' :: (MonadTCEnv m, ReadTCState m, MonadTrace m) => MetaVariable -> m a -> m a Source #

withMetaInfo :: (MonadTCEnv m, ReadTCState m, MonadTrace m) => Closure Range -> m a -> m a Source #

withInteractionId :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m, MonadTrace m) => InteractionId -> m a -> m a Source #

withMetaId :: (MonadFail m, MonadTCEnv m, ReadTCState m, MonadTrace m) => MetaId -> m a -> m a Source #

getMetaVariables :: ReadTCState m => (MetaVariable -> Bool) -> m [MetaId] Source #

getOpenMetas :: ReadTCState m => m [MetaId] Source #

isOpenMeta :: MetaInstantiation -> Bool Source #

listenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m () Source #

`listenToMeta l m`: register `l` as a listener to `m`. This is done when the type of l is blocked by `m`.

unlistenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m () Source #

Unregister a listener.

getMetaListeners :: (MonadFail m, ReadTCState m) => MetaId -> m [Listener] Source #

Get the listeners to a meta.

clearMetaListeners :: MonadMetaSolver m => MetaId -> m () Source #

freezeMetas :: MetaStore -> TCM IntSet Source #

Freeze the given meta-variables and return those that were not already frozen.

unfreezeMetas :: TCM () Source #

Thaw all meta variables.

isFrozen :: (MonadFail m, ReadTCState m) => MetaId -> m Bool Source #

data CheckResult where Source #

The result and associated parameters of a type-checked file, when invoked directly via interaction or a backend. Note that the constructor is not exported.

Bundled Patterns

pattern CheckResult :: Interface -> [TCWarning] -> ModuleCheckMode -> Source -> CheckResult | Flattened unidirectional pattern for `CheckResult` for destructuring inside the `ModuleInfo` field.

crInterface :: CheckResult -> Interface Source #

crWarnings :: CheckResult -> [TCWarning] Source #

crMode :: CheckResult -> ModuleCheckMode Source #

activeBackendMayEraseType :: QName -> TCM Bool Source #

Ask the active backend whether a type may be erased. See issue #3732.

backendInteraction :: AbsolutePath -> [Backend] -> TCM () -> (AbsolutePath -> TCM CheckResult) -> TCM () Source #

parseBackendOptions :: [Backend] -> [String] -> CommandLineOptions -> OptM ([Backend], CommandLineOptions) Source #

callBackend :: String -> IsMain -> CheckResult -> TCM () Source #

Call the `compilerMain` function of the given backend.

lookupBackend :: BackendName -> TCM (Maybe Backend) Source #

Look for a backend of the given name.

activeBackend :: TCM (Maybe Backend) Source #

Get the currently active backend (if any).